Skip to content

R
riscv-gcc-1
Commit c43f07af by Martin Jambor Committed by Martin Jambor
Options

ipa-cp.c (ipcp_method_orig_node): Renamed to ipcp_get_orig_node. 

2008-05-06  Martin Jambor  <mjambor@suse.cz>

        * ipa-cp.c (ipcp_method_orig_node): Renamed to ipcp_get_orig_node.
        (ipcp_method_is_cloned): Renamed to ipcp_node_is_clone
        (ipcp_method_set_orig_node): Removed.
        (ipcp_cval_get_cvalue_type): Removed.
        (ipcp_method_get_scale): Renamed to ipcp_get_node_scale.
        (ipcp_method_set_scale): Renamed to ipcp_set_node_scale.
        (ipcp_cval_set_cvalue_type): Removed.
        (ipcp_cval_get_cvalue): Removed.
        (ipcp_cval_set_cvalue): Removed.
        (ipcp_type_is_const): Renamed to ipcp_lat_is_const.
        (ipcp_cval_equal_cvalues): Renamed to ipcp_lats_are_equal
        (ipcp_lats_are_equal): Changed parameters to two ipcp_lattice's
        (ipcp_cval_meet): Renamed to ipa_lattice_meet
        (ipcp_cval_changed): Changed to use ipcp_lat_is_const
        (ipcp_method_cval): Renamed to ipcp_get_ith_lattice
        (ipcp_get_ith_lattice): Changed parameters.
        (ipcp_cval_compute): Renamed to ipcp_lattice_from_jfunc
        (ipcp_lattice_from_jfunc): Changed parameters.
	(ipcp_redirect): Local lattice pointer instead of lattice type variable.
	(ipcp_method_cval_print): Added temporary variable info.
	(ipcp_redirect): Removed already unused local variable caller.
	(ipcp_redirect): New temporary variable orig_callee_info
	(ipcp_redirect): Removed newly unused local variable callee.
	(ipcp_redirect): Removed (a bit confusing) local variable type.
	(ipcp_insert_stage): Added local variable info.
	(ipcp_cval_changed): Renamed to ipcp_lattice_changed, parameters 
	renamed too
	(ipcp_formal_create): Removed.
	(ipcp_method_cval_set): Removed.
	(ipcp_propagate_stage): Renamed lattice variables.
	(ipcp_method_cval_set_cvalue_type): Removed.
	(ipcp_method_cval_print): Renamed to ipcp_print_all_lattices
	(ipcp_print_all_lattices): Changed printed strings to refer to 
	lattices rather than cvals.
	(ipcp_method_cval_init): Renamed to ipcp_initialize_node_lattices
	(ipcp_propagate_const): Changed formal parameters.
	(build_const_val): Changed formal parameters.
	(ipcp_insert_stage): Removed useless variable cvalue
	(build_const_val): Changed formal parameters.
	(ipcp_method_compute_scale): Renamed to ipcp_compute_node_scale
	(ipcp_after_propagate): Renamed to ipcp_change_tops_to_bottom
	(ipcp_callsite_param_print): Renamed to ipcp_print_all_jump_functions
	(ipcp_profile_mt_count_print): Renamed to ipcp_print_func_profile_counts
	(ipcp_print_func_profile_counts): Changed string from "method" to 
	"function"
	(ipcp_profile_cs_count_print): Renamed to ipcp_print_call_profile_counts
	(ipcp_profile_edge_print): Renamed to ipcp_print_edge_profiles
	(ipcp_profile_bb_print): Renamed to ipcp_print_bb_profiles
	(ipcp_structures_print): Renamed to ipcp_print_all_structures
	(ipcp_profile_print): Renamed to ipcp_print_profile_data
	(ipcp_lat_is_const): Changed parameters and made inline.
	(ipcp_replace_map_create): Renamed to ipcp_create_replace_map
	(ipcp_redirect): Renamed to ipcp_need_redirect_p
	(ipcp_need_redirect_p): Calls ipcp_lat_is_const instead of using 
	the predicate condition directly
	(ipcp_propagate_stage): Added local variable args. Removed local
	variable callee.  (Both are mere code simplifications.)
	(ipcp_method_dont_insert_const): Renamed to
	ipcp_node_not_modifiable_p.
	(ipcp_node_not_modifiable_p): Made inline.
	(ipcp_cloned_create): Renamed to ipcp_init_cloned_node
	(ipcp_propagate_const): Renamed to ipcp_propagate_one_const
	(ipcp_print_all_lattices): Removed variable cvalue
	(ipcp_method_scale_print): Renamed to ipcp_function_scale_print
	Updated comments.

From-SVN: r134984
parent 2b9d6cf3
Showing with 352 additions and 392 deletions
gcc/ChangeLog
2008-05-06 Martin Jambor <mjambor@suse.cz>
* ipa-cp.c (ipcp_method_orig_node): Renamed to ipcp_get_orig_node.
(ipcp_method_is_cloned): Renamed to ipcp_node_is_clone
(ipcp_method_set_orig_node): Removed.
(ipcp_cval_get_cvalue_type): Removed.
(ipcp_method_get_scale): Renamed to ipcp_get_node_scale.
(ipcp_method_set_scale): Renamed to ipcp_set_node_scale.
(ipcp_cval_set_cvalue_type): Removed.
(ipcp_cval_get_cvalue): Removed.
(ipcp_cval_set_cvalue): Removed.
(ipcp_type_is_const): Renamed to ipcp_lat_is_const.
(ipcp_cval_equal_cvalues): Renamed to ipcp_lats_are_equal
(ipcp_lats_are_equal): Changed parameters to two ipcp_lattice's
(ipcp_cval_meet): Renamed to ipa_lattice_meet
(ipcp_cval_changed): Changed to use ipcp_lat_is_const
(ipcp_method_cval): Renamed to ipcp_get_ith_lattice
(ipcp_get_ith_lattice): Changed parameters.
(ipcp_cval_compute): Renamed to ipcp_lattice_from_jfunc
(ipcp_lattice_from_jfunc): Changed parameters.
(ipcp_redirect): Local lattice pointer instead of lattice type variable.
(ipcp_method_cval_print): Added temporary variable info.
(ipcp_redirect): Removed already unused local variable caller.
(ipcp_redirect): New temporary variable orig_callee_info
(ipcp_redirect): Removed newly unused local variable callee.
(ipcp_redirect): Removed (a bit confusing) local variable type.
(ipcp_insert_stage): Added local variable info.
(ipcp_cval_changed): Renamed to ipcp_lattice_changed, parameters
renamed too
(ipcp_formal_create): Removed.
(ipcp_method_cval_set): Removed.
(ipcp_propagate_stage): Renamed lattice variables.
(ipcp_method_cval_set_cvalue_type): Removed.
(ipcp_method_cval_print): Renamed to ipcp_print_all_lattices
(ipcp_print_all_lattices): Changed printed strings to refer to
lattices rather than cvals.
(ipcp_method_cval_init): Renamed to ipcp_initialize_node_lattices
(ipcp_propagate_const): Changed formal parameters.
(build_const_val): Changed formal parameters.
(ipcp_insert_stage): Removed useless variable cvalue
(build_const_val): Changed formal parameters.
(ipcp_method_compute_scale): Renamed to ipcp_compute_node_scale
(ipcp_after_propagate): Renamed to ipcp_change_tops_to_bottom
(ipcp_callsite_param_print): Renamed to ipcp_print_all_jump_functions
(ipcp_profile_mt_count_print): Renamed to ipcp_print_func_profile_counts
(ipcp_print_func_profile_counts): Changed string from "method" to
"function"
(ipcp_profile_cs_count_print): Renamed to ipcp_print_call_profile_counts
(ipcp_profile_edge_print): Renamed to ipcp_print_edge_profiles
(ipcp_profile_bb_print): Renamed to ipcp_print_bb_profiles
(ipcp_structures_print): Renamed to ipcp_print_all_structures
(ipcp_profile_print): Renamed to ipcp_print_profile_data
(ipcp_lat_is_const): Changed parameters and made inline.
(ipcp_replace_map_create): Renamed to ipcp_create_replace_map
(ipcp_redirect): Renamed to ipcp_need_redirect_p
(ipcp_need_redirect_p): Calls ipcp_lat_is_const instead of using
the predicate condition directly
(ipcp_propagate_stage): Added local variable args. Removed local
variable callee. (Both are mere code simplifications.)
(ipcp_method_dont_insert_const): Renamed to
ipcp_node_not_modifiable_p.
(ipcp_node_not_modifiable_p): Made inline.
(ipcp_cloned_create): Renamed to ipcp_init_cloned_node
(ipcp_propagate_const): Renamed to ipcp_propagate_one_const
(ipcp_print_all_lattices): Removed variable cvalue
(ipcp_method_scale_print): Renamed to ipcp_function_scale_print
Updated comments.
2008-05-06 Olivier Hainque <hainque@adacore.com> 2008-05-06 Olivier Hainque <hainque@adacore.com>
* tree-sra.c (try_instantiate_multiple_fields): Early return * tree-sra.c (try_instantiate_multiple_fields): Early return
......
gcc/ipa-cp.c
/* Interprocedural constant propagation /* Interprocedural constant propagation
Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc. Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
Contributed by Razya Ladelsky <RAZYA@il.ibm.com> Contributed by Razya Ladelsky <RAZYA@il.ibm.com>
This file is part of GCC. This file is part of GCC.
...@@ -18,61 +18,55 @@ You should have received a copy of the GNU General Public License ...@@ -18,61 +18,55 @@ You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */ <http://www.gnu.org/licenses/>. */
/* Interprocedural constant propagation. /* Interprocedural constant propagation. The aim of interprocedural constant
The aim of interprocedural constant propagation (IPCP) is to find which propagation (IPCP) is to find which function's argument has the same
function's argument has the same constant value in each invocation throughout constant value in each invocation throughout the whole program. For example,
the whole program. For example, for an application consisting of two files, consider the following program:
foo1.c, foo2.c:
foo1.c contains : int g (int y)
{
printf ("value is %d",y);
}
int f (int x) int f (int x)
{ {
g (x); g (x);
} }
void main (void)
{
f (3);
h (3);
}
foo2.c contains :
int h (int y) int h (int y)
{ {
g (y); g (y);
} }
int g (int y)
void main (void)
{ {
printf ("value is %d",y); 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", The IPCP algorithm will find that g's formal argument y is always called
by Challahan David, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, with the value 3.
pg 152-161
The algorithm used is based on "Interprocedural Constant Propagation", by
Challahan David, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, pg
152-161
The optimization is divided into three stages: The optimization is divided into three stages:
First stage - intraprocedural analysis First stage - intraprocedural analysis
======================================= =======================================
This phase computes jump_function and modify information. This phase computes jump_function and modification flags.
A jump function for a callsite represents the values passed as actual A jump function for a callsite represents the values passed as an actual
arguments arguments of a given callsite. There are three types of values:
of the callsite. There are three types of values : Pass through - the caller's formal parameter is passed as an actual argument.
Formal - the caller's formal parameter is passed as an actual argument.
Constant - a constant is passed as an actual argument. Constant - a constant is passed as an actual argument.
Unknown - neither of the above. Unknown - neither of the above.
In order to compute the jump functions, we need the modify information for The jump function info, ipa_jump_func, is stored in ipa_edge_args
the formal parameters of methods.
The jump function info, ipa_jump_func, is defined in ipa_edge
structure (defined in ipa_prop.h and pointed to by cgraph_node->aux) structure (defined in ipa_prop.h and pointed to by cgraph_node->aux)
The modify info, modified_flags, is defined in ipa_node_params structure modified_flags are defined in ipa_node_params structure
(defined in ipa_prop.h and pointed to by cgraph_edge->aux). (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
-ipcp_init_stage() is the first stage driver. -ipcp_init_stage() is the first stage driver.
...@@ -80,51 +74,45 @@ along with GCC; see the file COPYING3. If not see ...@@ -80,51 +74,45 @@ along with GCC; see the file COPYING3. If not see
Second stage - interprocedural analysis Second stage - interprocedural analysis
======================================== ========================================
This phase does the interprocedural constant propagation. This phase does the interprocedural constant propagation.
It computes for all formal parameters in the program It computes lattices for all formal parameters in the program
their cval value that may be: and their value that may be:
TOP - unknown. TOP - unknown.
BOTTOM - non constant. BOTTOM - non constant.
CONSTANT_TYPE - constant value. CONSTANT - constant value.
Cval of formal f will have a constant value if all callsites to this Lattice describing a formal parameter p will have a constant value if all
function have the same constant value passed to f. callsites invoking this function have the same constant value passed to p.
The cval info, ipcp_lattice, is defined in ipa_node_params structure The lattices are stored in ipcp_lattice which is itself in ipa_node_params
(defined in ipa_prop.h and pointed to by cgraph_edge->aux). structure (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
-ipcp_iterate_stage() is the second stage driver. -ipcp_iterate_stage() is the second stage driver.
Third phase - transformation of methods code Third phase - transformation of function code
============================================ ============================================
Propagates the constant-valued formals into the function. Propagates the constant-valued formals into the function.
For each method mt, whose parameters are consts, we create a clone/version. For each function whose parameters are constants, we create its clone.
We use two ways to annotate the versioned function with the constant Then we process the clone in two ways:
formal information:
1. We insert an assignment statement 'parameter = const' at the beginning 1. We insert an assignment statement 'parameter = const' at the beginning
of the cloned method. of the cloned function.
2. For read-only formals whose address is not taken, we replace all uses 2. For read-only parameters that do not live in memory, we replace all their
of the formal with the constant (we provide versioning with an uses with the constant.
ipa_replace_map struct representing the trees we want to replace).
We also need to modify some callsites to call to the cloned methods instead We also need to modify some callsites to call the cloned functiosns instead
of the original ones. For a callsite passing an argument found to be a of the original ones. For a callsite passing an argument found to be a
constant by IPCP, there are two different cases to handle: constant by IPCP, there are two different cases to handle:
1. A constant is passed as an argument. 1. A constant is passed as an argument. In this case the callsite in the
2. A parameter (of the caller) passed as an argument (pass through argument). should be redirected to call the cloned callee.
2. A parameter (of the caller) passed as an argument (pass through
In the first case, the callsite in the original caller should be redirected argument). In such cases both the caller and the callee have clones and
to call the cloned callee. only the callsite in the cloned caller is redirected to call to the
In the second case, both the caller and the callee have clones cloned callee.
and the callsite of the cloned caller would be redirected to call to
the cloned callee. This update is done in two steps: First all cloned functionss are created
during a traversal of the call graph, during which all callsites are
The callgraph is updated accordingly. redirected to call the cloned function. Then the callsites are traversed
and many calls redirected back to fit the description above.
This update is done in two stages:
First all cloned methods are created during a traversal of the callgraph,
during which all callsites are redirected to call the cloned method.
Then the callsites are traversed and updated as described above.
-ipcp_insert_stage() is the third phase driver. -ipcp_insert_stage() is the third phase driver.
...@@ -145,105 +133,65 @@ along with GCC; see the file COPYING3. If not see ...@@ -145,105 +133,65 @@ along with GCC; see the file COPYING3. If not see
#include "tree-dump.h" #include "tree-dump.h"
#include "tree-inline.h" #include "tree-inline.h"
/* Get orig node field of ipa_node_params associated with method MT. */ /* Get the original node field of ipa_node_params associated with node NODE. */
static inline struct cgraph_node * static inline struct cgraph_node *
ipcp_method_orig_node (struct cgraph_node *mt) ipcp_get_orig_node (struct cgraph_node *node)
{ {
return IPA_NODE_REF (mt)->ipcp_orig_node; return IPA_NODE_REF (node)->ipcp_orig_node;
} }
/* Return true if NODE is a cloned/versioned method. */ /* Return true if NODE describes a cloned/versioned function. */
static inline bool static inline bool
ipcp_method_is_cloned (struct cgraph_node *node) ipcp_node_is_clone (struct cgraph_node *node)
{
return (ipcp_method_orig_node (node) != NULL);
}
/* Set ORIG_NODE in ipa_node associated with method NODE. */
static inline void
ipcp_method_set_orig_node (struct cgraph_node *node,
struct cgraph_node *orig_node)
{ {
IPA_NODE_REF (node)->ipcp_orig_node = orig_node; return (ipcp_get_orig_node (node) != NULL);
} }
/* Create ipa_node and its data structures for NEW_NODE. /* Create ipa_node_params and its data structures for NEW_NODE. Set ORIG_NODE
Set ORIG_NODE as the orig_node field in ipa_node. */ as the ipcp_orig_node field in ipa_node_params. */
static void static void
ipcp_cloned_create (struct cgraph_node *orig_node, ipcp_init_cloned_node (struct cgraph_node *orig_node,
struct cgraph_node *new_node) struct cgraph_node *new_node)
{ {
ipa_create_node_params (new_node); ipa_create_node_params (new_node);
ipcp_method_set_orig_node (new_node, orig_node); IPA_NODE_REF (new_node)->ipcp_orig_node = orig_node;
ipa_count_formal_params (new_node); ipa_count_formal_params (new_node);
ipa_create_param_decls_array (new_node); ipa_create_param_decls_array (new_node);
} }
/* Return cval_type field of CVAL. */ /* Return scale for NODE. */
static inline enum ipa_lattice_type
ipcp_cval_get_cvalue_type (struct ipcp_lattice *cval)
{
return cval->type;
}
/* Return scale for MT. */
static inline gcov_type static inline gcov_type
ipcp_method_get_scale (struct cgraph_node *mt) ipcp_get_node_scale (struct cgraph_node *node)
{ {
return IPA_NODE_REF (mt)->count_scale; return IPA_NODE_REF (node)->count_scale;
} }
/* Set COUNT as scale for MT. */ /* Set COUNT as scale for NODE. */
static inline void static inline void
ipcp_method_set_scale (struct cgraph_node *node, gcov_type count) ipcp_set_node_scale (struct cgraph_node *node, gcov_type count)
{ {
IPA_NODE_REF (node)->count_scale = count; IPA_NODE_REF (node)->count_scale = count;
} }
/* Set TYPE as cval_type field of CVAL. */ /* Return whether LAT is a constant lattice. */
static inline void static inline bool
ipcp_cval_set_cvalue_type (struct ipcp_lattice *cval, enum jump_func_type type) ipcp_lat_is_const (struct ipcp_lattice *lat)
{
cval->type = type;
}
/* Return cvalue field of CVAL. */
static inline tree
ipcp_cval_get_cvalue (struct ipcp_lattice *cval)
{
return cval->constant;
}
/* Set VALUE as cvalue field CVAL. */
static inline void
ipcp_cval_set_cvalue (struct ipcp_lattice *cval, tree value,
enum ipa_lattice_type type)
{
if (type == IPA_CONST_VALUE || type == IPA_CONST_VALUE_REF)
cval->constant = value;
}
/* Return whether TYPE is a constant type. */
static bool
ipcp_type_is_const (enum ipa_lattice_type type)
{ {
if (type == IPA_CONST_VALUE || type == IPA_CONST_VALUE_REF) if (lat->type == IPA_CONST_VALUE || lat->type == IPA_CONST_VALUE_REF)
return true; return true;
else else
return false; return false;
} }
/* Return true if CONST_VAL1 and CONST_VAL2 are equal. */ /* Return true if LAT1 and LAT2 are equal. */
static inline bool static inline bool
ipcp_cval_equal_cvalues (tree const_val1, tree const_val2, ipcp_lats_are_equal (struct ipcp_lattice *lat1, struct ipcp_lattice *lat2)
enum ipa_lattice_type type1,
enum ipa_lattice_type type2)
{ {
gcc_assert (ipcp_type_is_const (type1) && ipcp_type_is_const (type2)); gcc_assert (ipcp_lat_is_const (lat1) && ipcp_lat_is_const (lat2));
if (type1 != type2) if (lat1->type != lat2->type)
return false; return false;
if (operand_equal_p (const_val1, const_val2, 0)) if (operand_equal_p (lat1->constant, lat2->constant, 0))
return true; return true;
return false; return false;
...@@ -255,161 +203,110 @@ ipcp_cval_equal_cvalues (tree const_val1, tree const_val2, ...@@ -255,161 +203,110 @@ ipcp_cval_equal_cvalues (tree const_val1, tree const_val2,
Meet (const_a,const_b) = IPA_BOTTOM, if const_a != const_b. Meet (const_a,const_b) = IPA_BOTTOM, if const_a != const_b.
MEET (const_a,const_b) = const_a, if const_a == const_b.*/ MEET (const_a,const_b) = const_a, if const_a == const_b.*/
static void static void
ipcp_cval_meet (struct ipcp_lattice *cval, struct ipcp_lattice *cval1, ipa_lattice_meet (struct ipcp_lattice *res, struct ipcp_lattice *lat1,
struct ipcp_lattice *cval2) struct ipcp_lattice *lat2)
{ {
if (ipcp_cval_get_cvalue_type (cval1) == IPA_BOTTOM if (lat1->type == IPA_BOTTOM || lat2->type == IPA_BOTTOM)
|| ipcp_cval_get_cvalue_type (cval2) == IPA_BOTTOM)
{ {
ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM); res->type = IPA_BOTTOM;
return; return;
} }
if (ipcp_cval_get_cvalue_type (cval1) == IPA_TOP) if (lat1->type == IPA_TOP)
{ {
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval2)); res->type = lat2->type;
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval2), res->constant = lat2->constant;
ipcp_cval_get_cvalue_type (cval2));
return; return;
} }
if (ipcp_cval_get_cvalue_type (cval2) == IPA_TOP) if (lat2->type == IPA_TOP)
{ {
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1)); res->type = lat1->type;
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval1), res->constant = lat1->constant;
ipcp_cval_get_cvalue_type (cval1));
return; return;
} }
if (!ipcp_cval_equal_cvalues (ipcp_cval_get_cvalue (cval1), if (!ipcp_lats_are_equal (lat1, lat2))
ipcp_cval_get_cvalue (cval2),
ipcp_cval_get_cvalue_type (cval1),
ipcp_cval_get_cvalue_type (cval2)))
{ {
ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM); res->type = IPA_BOTTOM;
return; return;
} }
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1)); res->type = lat1->type;
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval1), res->constant = lat1->constant;
ipcp_cval_get_cvalue_type (cval1));
} }
/* Return cval structure for the formal at index INFO_TYPE in MT. */ /* Return the lattice corresponding to the Ith formal parameter of the function
described by INFO. */
static inline struct ipcp_lattice * static inline struct ipcp_lattice *
ipcp_method_cval (struct cgraph_node *mt, int info_type) ipcp_get_ith_lattice (struct ipa_node_params *info, int i)
{ {
return &(IPA_NODE_REF (mt)->ipcp_lattices[info_type]); return &(info->ipcp_lattices[i]);
} }
/* Given the jump function (TYPE, INFO_TYPE), compute a new value of CVAL. /* Given the jump function JFUNC, compute the lattice LAT that describes the
If TYPE is FORMAL_IPA_TYPE, the cval of the corresponding formal is value coming down the callsite. INFO describes the caller node so that
drawn from MT. */ pass-through jump functions can be evaluated. */
static void static void
ipcp_cval_compute (struct ipcp_lattice *cval, struct cgraph_node *mt, ipcp_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat,
enum jump_func_type type, struct ipa_jump_func *jfunc)
union jump_func_value *info_type)
{ {
if (type == IPA_UNKNOWN) if (jfunc->type == IPA_UNKNOWN)
ipcp_cval_set_cvalue_type (cval, IPA_BOTTOM); lat->type = IPA_BOTTOM;
else if (type == IPA_CONST) else if (jfunc->type == IPA_CONST)
{ {
ipcp_cval_set_cvalue_type (cval, IPA_CONST_VALUE); lat->type = IPA_CONST_VALUE;
ipcp_cval_set_cvalue (cval, info_type->constant, IPA_CONST_VALUE); lat->constant = jfunc->value.constant;
} }
else if (type == IPA_CONST_REF) else if (jfunc->type == IPA_CONST_REF)
{ {
ipcp_cval_set_cvalue_type (cval, IPA_CONST_VALUE_REF); lat->type = IPA_CONST_VALUE_REF;
ipcp_cval_set_cvalue (cval, info_type->constant, IPA_CONST_VALUE_REF); lat->constant = jfunc->value.constant;
} }
else if (type == IPA_PASS_THROUGH) else if (jfunc->type == IPA_PASS_THROUGH)
{ {
enum ipa_lattice_type type = struct ipcp_lattice *caller_lat;
ipcp_cval_get_cvalue_type (ipcp_method_cval
(mt, info_type->formal_id)); caller_lat = ipcp_get_ith_lattice (info, jfunc->value.formal_id);
ipcp_cval_set_cvalue_type (cval, type); lat->type = caller_lat->type;
ipcp_cval_set_cvalue (cval, lat->constant = caller_lat->constant;
ipcp_cval_get_cvalue (ipcp_method_cval
(mt, info_type->formal_id)),
type);
} }
} }
/* True when CVAL1 and CVAL2 values are not the same. */ /* True when OLD and NEW values are not the same. */
static bool static bool
ipcp_cval_changed (struct ipcp_lattice *cval1, struct ipcp_lattice *cval2) ipcp_lattice_changed (struct ipcp_lattice *old, struct ipcp_lattice *new)
{ {
if (ipcp_cval_get_cvalue_type (cval1) == ipcp_cval_get_cvalue_type (cval2)) if (old->type == new->type)
{ {
if (ipcp_cval_get_cvalue_type (cval1) != IPA_CONST_VALUE if (!ipcp_lat_is_const (old))
&& ipcp_cval_get_cvalue_type (cval1) != IPA_CONST_VALUE_REF)
return false; return false;
if (ipcp_cval_equal_cvalues (ipcp_cval_get_cvalue (cval1), if (ipcp_lats_are_equal (old, new))
ipcp_cval_get_cvalue (cval2),
ipcp_cval_get_cvalue_type (cval1),
ipcp_cval_get_cvalue_type (cval2)))
return false; return false;
} }
return true; return true;
} }
/* Create cval structure for method MT. */ /* Print all ipcp_lattices of all functions to F. */
static inline void
ipcp_formal_create (struct cgraph_node *mt)
{
IPA_NODE_REF (mt)->ipcp_lattices =
XCNEWVEC (struct ipcp_lattice, ipa_get_param_count (IPA_NODE_REF (mt)));
}
/* Set cval structure of I-th formal of MT to CVAL. */
static inline void
ipcp_method_cval_set (struct cgraph_node *mt, int i, struct ipcp_lattice *cval)
{
IPA_NODE_REF (mt)->ipcp_lattices[i].type = cval->type;
ipcp_cval_set_cvalue (ipcp_method_cval (mt, i),
ipcp_cval_get_cvalue (cval), cval->type);
}
/* Set type of cval structure of formal I of MT to CVAL_TYPE1. */
static inline void
ipcp_method_cval_set_cvalue_type (struct cgraph_node *mt, int i,
enum ipa_lattice_type type)
{
IPA_NODE_REF (mt)->ipcp_lattices[i].type = type;
}
/* Set type of cval structure of formal I of MT to CVAL_TYPE1. */
static inline void
ipcp_method_cval_set_lattice_type (struct cgraph_node *mt, int i,
enum ipa_lattice_type type)
{
IPA_NODE_REF (mt)->ipcp_lattices[i].type = type;
}
/* Print ipcp_cval data structures to F. */
static void static void
ipcp_method_cval_print (FILE * f) ipcp_print_all_lattices (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
int i, count; int i, count;
tree cvalue;
fprintf (f, "\nCVAL PRINT\n"); fprintf (f, "\nLATTICE PRINT\n");
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
fprintf (f, "Printing cvals %s:\n", cgraph_node_name (node)); struct ipa_node_params *info = IPA_NODE_REF (node);
count = ipa_get_param_count (IPA_NODE_REF (node)); fprintf (f, "Printing lattices %s:\n", cgraph_node_name (node));
count = ipa_get_param_count (info);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
== IPA_CONST_VALUE if (lat->type == IPA_CONST_VALUE || lat->type == IPA_CONST_VALUE_REF)
|| ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) ==
IPA_CONST_VALUE_REF)
{ {
fprintf (f, " param [%d]: ", i); fprintf (f, " param [%d]: ", i);
fprintf (f, "type is CONST "); fprintf (f, "type is CONST ");
cvalue = print_generic_expr (f, lat->constant, 0);
ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
print_generic_expr (f, cvalue, 0);
fprintf (f, "\n"); fprintf (f, "\n");
} }
else if (ipcp_method_cval (node, i)->type == IPA_TOP) else if (lat->type == IPA_TOP)
fprintf (f, "param [%d]: type is TOP \n", i); fprintf (f, "param [%d]: type is TOP \n", i);
else else
fprintf (f, "param [%d]: type is BOTTOM \n", i); fprintf (f, "param [%d]: type is BOTTOM \n", i);
...@@ -417,36 +314,33 @@ ipcp_method_cval_print (FILE * f) ...@@ -417,36 +314,33 @@ ipcp_method_cval_print (FILE * f)
} }
} }
/* Initialize ipcp_cval array of MT with IPA_TOP values. /* Initialize ipcp_lattices array. The lattices corresponding to supported
All cvals for a method's formal parameters are initialized to IPA_BOTTOM types (integers, real types and Fortran constants defined as const_decls)
The currently supported types are integer types, real types and are initialized to IPA_TOP, the rest of them to IPA_BOTTOM. */
Fortran constants (i.e. references to constants defined as
const_decls). All other types are not analyzed and therefore are
assigned with IPA_BOTTOM. */
static void static void
ipcp_method_cval_init (struct cgraph_node *mt) ipcp_initialize_node_lattices (struct cgraph_node *node)
{ {
int i; int i;
tree parm_tree; struct ipa_node_params *info = IPA_NODE_REF (node);
ipcp_formal_create (mt); info->ipcp_lattices = XCNEWVEC (struct ipcp_lattice,
for (i = 0; i < ipa_get_param_count (IPA_NODE_REF (mt)) ; i++) ipa_get_param_count (info));
for (i = 0; i < ipa_get_param_count (info) ; i++)
{ {
parm_tree = ipa_get_ith_param (IPA_NODE_REF (mt), i); tree parm_tree = ipa_get_ith_param (info, i);
struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree)) if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree))
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree)) || SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree))
|| POINTER_TYPE_P (TREE_TYPE (parm_tree))) || POINTER_TYPE_P (TREE_TYPE (parm_tree)))
ipcp_method_cval_set_cvalue_type (mt, i, IPA_TOP); lat->type = IPA_TOP;
else else
ipcp_method_cval_set_cvalue_type (mt, i, IPA_BOTTOM); lat->type = IPA_BOTTOM;
} }
} }
/* Create a new assignment statment and make /* Create a new assignment statement and make it the first statement in the
it the first statement in the function FN function. PARM1 is the lhs of the assignment and VAL is the rhs. */
tree.
PARM1 is the lhs of the assignment and
VAL is the rhs. */
static void static void
constant_val_insert (tree parm1, tree val) constant_val_insert (tree parm1, tree val)
{ {
...@@ -462,40 +356,38 @@ constant_val_insert (tree parm1, tree val) ...@@ -462,40 +356,38 @@ constant_val_insert (tree parm1, tree val)
} }
} }
/* build INTEGER_CST tree with type TREE_TYPE and /* build INTEGER_CST tree with type TREE_TYPE and value according to LAT.
value according to CVALUE. Return the tree. */ Return the tree. */
static tree static tree
build_const_val (tree cvalue, enum ipa_lattice_type type, tree tree_type) build_const_val (struct ipcp_lattice *lat, tree tree_type)
{ {
tree const_val = NULL; tree const_val = NULL;
gcc_assert (ipcp_type_is_const (type)); gcc_assert (ipcp_lat_is_const (lat));
const_val = fold_convert (tree_type, cvalue); const_val = fold_convert (tree_type, lat->constant);
return const_val; return const_val;
} }
/* Build the tree representing the constant and call /* Build the tree representing the constant and call constant_val_insert(). */
constant_val_insert(). */
static void static void
ipcp_propagate_const (struct cgraph_node *mt, int param, ipcp_propagate_one_const (struct cgraph_node *node, int param,
tree cvalue, enum ipa_lattice_type type) struct ipcp_lattice *lat)
{ {
tree const_val; tree const_val;
tree parm_tree; tree parm_tree;
if (dump_file) if (dump_file)
fprintf (dump_file, "propagating const to %s\n", cgraph_node_name (mt)); fprintf (dump_file, "propagating const to %s\n", cgraph_node_name (node));
parm_tree = ipa_get_ith_param (IPA_NODE_REF (mt), param); parm_tree = ipa_get_ith_param (IPA_NODE_REF (node), param);
const_val = build_const_val (cvalue, type, TREE_TYPE (parm_tree)); const_val = build_const_val (lat, TREE_TYPE (parm_tree));
constant_val_insert (parm_tree, const_val); constant_val_insert (parm_tree, const_val);
} }
/* Compute the proper scale for NODE. It is the ratio between /* Compute the proper scale for NODE. It is the ratio between the number of
the number of direct calls (represented on the incoming direct calls (represented on the incoming cgraph_edges) and sum of all
cgraph_edges) and sum of all invocations of NODE (represented invocations of NODE (represented as count in cgraph_node). */
as count in cgraph_node). */
static void static void
ipcp_method_compute_scale (struct cgraph_node *node) ipcp_compute_node_scale (struct cgraph_node *node)
{ {
gcov_type sum; gcov_type sum;
struct cgraph_edge *cs; struct cgraph_edge *cs;
...@@ -505,15 +397,14 @@ ipcp_method_compute_scale (struct cgraph_node *node) ...@@ -505,15 +397,14 @@ ipcp_method_compute_scale (struct cgraph_node *node)
for (cs = node->callers; cs != NULL; cs = cs->next_caller) for (cs = node->callers; cs != NULL; cs = cs->next_caller)
sum += cs->count; sum += cs->count;
if (node->count == 0) if (node->count == 0)
ipcp_method_set_scale (node, 0); ipcp_set_node_scale (node, 0);
else else
ipcp_method_set_scale (node, sum * REG_BR_PROB_BASE / node->count); ipcp_set_node_scale (node, sum * REG_BR_PROB_BASE / node->count);
} }
/* Initialization and computation of IPCP data structures. /* Initialization and computation of IPCP data structures. This is the initial
It is an intraprocedural intraprocedural analysis of functions, which gathers information to be
analysis of methods, which gathers information to be propagated propagated later on. */
later on. */
static void static void
ipcp_init_stage (void) ipcp_init_stage (void)
{ {
...@@ -524,9 +415,9 @@ ipcp_init_stage (void) ...@@ -524,9 +415,9 @@ ipcp_init_stage (void)
{ {
ipa_count_formal_params (node); ipa_count_formal_params (node);
ipa_create_param_decls_array (node); ipa_create_param_decls_array (node);
ipcp_method_cval_init (node); ipcp_initialize_node_lattices (node);
ipa_detect_param_modifications (node); ipa_detect_param_modifications (node);
ipcp_method_compute_scale (node); ipcp_compute_node_scale (node);
} }
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
...@@ -547,10 +438,11 @@ ipcp_init_stage (void) ...@@ -547,10 +438,11 @@ ipcp_init_stage (void)
} }
} }
/* Return true if there are some formal parameters whose value is IPA_TOP. /* Return true if there are some formal parameters whose value is IPA_TOP (in
Change their values to IPA_BOTTOM, since they weren't determined. */ the whole compilation unit). Change their values to IPA_BOTTOM, since they
most probably get their values from outside of this compilation unit. */
static bool static bool
ipcp_after_propagate (void) ipcp_change_tops_to_bottom (void)
{ {
int i, count; int i, count;
struct cgraph_node *node; struct cgraph_node *node;
...@@ -559,30 +451,32 @@ ipcp_after_propagate (void) ...@@ -559,30 +451,32 @@ ipcp_after_propagate (void)
prop_again = false; prop_again = false;
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
count = ipa_get_param_count (IPA_NODE_REF (node)); struct ipa_node_params *info = IPA_NODE_REF (node);
count = ipa_get_param_count (info);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) == IPA_TOP) {
{ struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
prop_again = true; if (lat->type == IPA_TOP)
ipcp_method_cval_set_cvalue_type (node, i, IPA_BOTTOM); {
} prop_again = true;
lat->type = IPA_BOTTOM;
}
}
} }
return prop_again; return prop_again;
} }
/* Interprocedural analysis. The algorithm propagates constants from /* Interprocedural analysis. The algorithm propagates constants from the
the caller's parameters to the callee's arguments. */ caller's parameters to the callee's arguments. */
static void static void
ipcp_propagate_stage (void) ipcp_propagate_stage (void)
{ {
int i; int i;
struct ipcp_lattice cval1 = { IPA_BOTTOM, NULL }, cval = { IPA_BOTTOM, NULL }; struct ipcp_lattice inc_lat = { IPA_BOTTOM, NULL };
struct ipcp_lattice *cval2; struct ipcp_lattice new_lat = { IPA_BOTTOM, NULL };
struct cgraph_node *mt, *callee; struct ipcp_lattice *dest_lat;
struct cgraph_edge *cs; struct cgraph_edge *cs;
struct ipa_jump_func *jump_func; struct ipa_jump_func *jump_func;
enum jump_func_type type;
union jump_func_value *jf_value;
struct ipa_func_list *wl; struct ipa_func_list *wl;
int count; int count;
...@@ -590,25 +484,29 @@ ipcp_propagate_stage (void) ...@@ -590,25 +484,29 @@ ipcp_propagate_stage (void)
wl = ipa_init_func_list (); wl = ipa_init_func_list ();
while (wl) while (wl)
{ {
mt = ipa_pop_func_from_list (&wl); struct cgraph_node *node = ipa_pop_func_from_list (&wl);
for (cs = mt->callees; cs; cs = cs->next_callee) struct ipa_node_params *info = IPA_NODE_REF (node);
for (cs = node->callees; cs; cs = cs->next_callee)
{ {
callee = cs->callee; struct ipa_node_params *callee_info = IPA_NODE_REF (cs->callee);
if (ipa_is_called_with_var_arguments (IPA_NODE_REF (callee))) struct ipa_edge_args *args = IPA_EDGE_REF (cs);
if (ipa_is_called_with_var_arguments (callee_info))
continue; continue;
count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
count = ipa_get_cs_argument_count (args);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i); jump_func = ipa_get_ith_jump_func (args, i);
type = jump_func->type; ipcp_lattice_from_jfunc (info, &inc_lat, jump_func);
jf_value = &jump_func->value; dest_lat = ipcp_get_ith_lattice (callee_info, i);
ipcp_cval_compute (&cval1, mt, type, jf_value); ipa_lattice_meet (&new_lat, &inc_lat, dest_lat);
cval2 = ipcp_method_cval (callee, i); if (ipcp_lattice_changed (&new_lat, dest_lat))
ipcp_cval_meet (&cval, &cval1, cval2);
if (ipcp_cval_changed (&cval, cval2))
{ {
ipcp_method_cval_set (callee, i, &cval); dest_lat->type = new_lat.type;
ipa_push_func_to_list (&wl, callee); dest_lat->constant = new_lat.constant;
ipa_push_func_to_list (&wl, cs->callee);
} }
} }
} }
...@@ -621,25 +519,26 @@ static void ...@@ -621,25 +519,26 @@ static void
ipcp_iterate_stage (void) ipcp_iterate_stage (void)
{ {
ipcp_propagate_stage (); ipcp_propagate_stage ();
if (ipcp_after_propagate ()) if (ipcp_change_tops_to_bottom ())
/* Some cvals have changed from IPA_TOP to IPA_BOTTOM. /* Some lattices have changed from IPA_TOP to IPA_BOTTOM.
This change should be propagated. */ This change should be propagated. */
ipcp_propagate_stage (); ipcp_propagate_stage ();
} }
/* Check conditions to forbid constant insertion to MT. */ /* Check conditions to forbid constant insertion to function described by
static bool NODE. */
ipcp_method_dont_insert_const (struct cgraph_node *mt) static inline bool
ipcp_node_not_modifiable_p (struct cgraph_node *node)
{ {
/* ??? Handle pending sizes case. */ /* ??? Handle pending sizes case. */
if (DECL_UNINLINABLE (mt->decl)) if (DECL_UNINLINABLE (node->decl))
return true; return true;
return false; return false;
} }
/* Print ipa_jump_func data structures to F. */ /* Print ipa_jump_func data structures to F. */
static void static void
ipcp_callsite_param_print (FILE * f) ipcp_print_all_jump_functions (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
int i, count; int i, count;
...@@ -687,7 +586,7 @@ ipcp_callsite_param_print (FILE * f) ...@@ -687,7 +586,7 @@ ipcp_callsite_param_print (FILE * f)
/* Print count scale data structures. */ /* Print count scale data structures. */
static void static void
ipcp_method_scale_print (FILE * f) ipcp_function_scale_print (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
...@@ -695,19 +594,19 @@ ipcp_method_scale_print (FILE * f) ...@@ -695,19 +594,19 @@ ipcp_method_scale_print (FILE * f)
{ {
fprintf (f, "printing scale for %s: ", cgraph_node_name (node)); fprintf (f, "printing scale for %s: ", cgraph_node_name (node));
fprintf (f, "value is " HOST_WIDE_INT_PRINT_DEC fprintf (f, "value is " HOST_WIDE_INT_PRINT_DEC
" \n", (HOST_WIDE_INT) ipcp_method_get_scale (node)); " \n", (HOST_WIDE_INT) ipcp_get_node_scale (node));
} }
} }
/* Print counts of all cgraph nodes. */ /* Print counts of all cgraph nodes. */
static void static void
ipcp_profile_mt_count_print (FILE * f) ipcp_print_func_profile_counts (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
fprintf (f, "method %s: ", cgraph_node_name (node)); fprintf (f, "function %s: ", cgraph_node_name (node));
fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC
" \n", (HOST_WIDE_INT) node->count); " \n", (HOST_WIDE_INT) node->count);
} }
...@@ -715,7 +614,7 @@ ipcp_profile_mt_count_print (FILE * f) ...@@ -715,7 +614,7 @@ ipcp_profile_mt_count_print (FILE * f)
/* Print counts of all cgraph edges. */ /* Print counts of all cgraph edges. */
static void static void
ipcp_profile_cs_count_print (FILE * f) ipcp_print_call_profile_counts (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
struct cgraph_edge *cs; struct cgraph_edge *cs;
...@@ -732,9 +631,9 @@ ipcp_profile_cs_count_print (FILE * f) ...@@ -732,9 +631,9 @@ ipcp_profile_cs_count_print (FILE * f)
} }
} }
/* Print all counts and probabilities of cfg edges of all methods. */ /* Print all counts and probabilities of cfg edges of all functions. */
static void static void
ipcp_profile_edge_print (FILE * f) ipcp_print_edge_profiles (FILE * f)
{ {
struct cgraph_node *node; struct cgraph_node *node;
basic_block bb; basic_block bb;
...@@ -743,7 +642,7 @@ ipcp_profile_edge_print (FILE * f) ...@@ -743,7 +642,7 @@ ipcp_profile_edge_print (FILE * f)
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
fprintf (f, "method %s: \n", cgraph_node_name (node)); fprintf (f, "function %s: \n", cgraph_node_name (node));
if (DECL_SAVED_TREE (node->decl)) if (DECL_SAVED_TREE (node->decl))
{ {
bb = bb =
...@@ -787,16 +686,16 @@ ipcp_profile_edge_print (FILE * f) ...@@ -787,16 +686,16 @@ ipcp_profile_edge_print (FILE * f)
} }
} }
/* Print counts and frequencies for all basic blocks of all methods. */ /* Print counts and frequencies for all basic blocks of all functions. */
static void static void
ipcp_profile_bb_print (FILE * f) ipcp_print_bb_profiles (FILE * f)
{ {
basic_block bb; basic_block bb;
struct cgraph_node *node; struct cgraph_node *node;
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
fprintf (f, "method %s: \n", cgraph_node_name (node)); fprintf (f, "function %s: \n", cgraph_node_name (node));
if (node->analyzed) if (node->analyzed)
{ {
bb = bb =
...@@ -826,49 +725,50 @@ ipcp_profile_bb_print (FILE * f) ...@@ -826,49 +725,50 @@ ipcp_profile_bb_print (FILE * f)
/* Print all IPCP data structures to F. */ /* Print all IPCP data structures to F. */
static void static void
ipcp_structures_print (FILE * f) ipcp_print_all_structures (FILE * f)
{ {
ipcp_method_cval_print (f); ipcp_print_all_lattices (f);
ipcp_method_scale_print (f); ipcp_function_scale_print (f);
ipa_print_all_tree_maps (f); ipa_print_all_tree_maps (f);
ipa_print_all_params_modified (f); ipa_print_all_params_modified (f);
ipcp_callsite_param_print (f); ipcp_print_all_jump_functions (f);
} }
/* Print profile info for all methods. */ /* Print profile info for all functions. */
static void static void
ipcp_profile_print (FILE * f) ipcp_print_profile_data (FILE * f)
{ {
fprintf (f, "\nNODE COUNTS :\n"); fprintf (f, "\nNODE COUNTS :\n");
ipcp_profile_mt_count_print (f); ipcp_print_func_profile_counts (f);
fprintf (f, "\nCS COUNTS stage:\n"); fprintf (f, "\nCS COUNTS stage:\n");
ipcp_profile_cs_count_print (f); ipcp_print_call_profile_counts (f);
fprintf (f, "\nBB COUNTS and FREQUENCIES :\n"); fprintf (f, "\nBB COUNTS and FREQUENCIES :\n");
ipcp_profile_bb_print (f); ipcp_print_bb_profiles (f);
fprintf (f, "\nCFG EDGES COUNTS and PROBABILITIES :\n"); fprintf (f, "\nCFG EDGES COUNTS and PROBABILITIES :\n");
ipcp_profile_edge_print (f); ipcp_print_edge_profiles (f);
} }
/* Build and initialize ipa_replace_map struct /* Build and initialize ipa_replace_map struct according to LAT. This struct is
according to TYPE. This struct is read by versioning, which processed by versioning, which operates according to the flags set.
operates according to the flags sent. PARM_TREE is the PARM_TREE is the formal parameter found to be constant. LAT represents the
formal's tree found to be constant. CVALUE represents the constant. */ constant. */
static struct ipa_replace_map * static struct ipa_replace_map *
ipcp_replace_map_create (struct function *func, enum ipa_lattice_type type, ipcp_create_replace_map (struct function *func, tree parm_tree,
tree parm_tree, tree cvalue) struct ipcp_lattice *lat)
{ {
struct ipa_replace_map *replace_map; struct ipa_replace_map *replace_map;
tree const_val; tree const_val;
replace_map = XCNEW (struct ipa_replace_map); replace_map = XCNEW (struct ipa_replace_map);
gcc_assert (ipcp_type_is_const (type)); gcc_assert (ipcp_lat_is_const (lat));
if (type != IPA_CONST_VALUE_REF if (lat->type != IPA_CONST_VALUE_REF
&& is_gimple_reg (parm_tree) && gimple_default_def (func, parm_tree) && is_gimple_reg (parm_tree) && gimple_default_def (func, parm_tree)
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_default_def (func, parm_tree))) && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_default_def (func,
parm_tree)))
{ {
if (dump_file) if (dump_file)
fprintf (dump_file, "replacing param with const\n"); fprintf (dump_file, "replacing param with const\n");
const_val = build_const_val (cvalue, type, TREE_TYPE (parm_tree)); const_val = build_const_val (lat, TREE_TYPE (parm_tree));
replace_map->old_tree =gimple_default_def (func, parm_tree); replace_map->old_tree =gimple_default_def (func, parm_tree);
replace_map->new_tree = const_val; replace_map->new_tree = const_val;
replace_map->replace_p = true; replace_map->replace_p = true;
...@@ -885,30 +785,24 @@ ipcp_replace_map_create (struct function *func, enum ipa_lattice_type type, ...@@ -885,30 +785,24 @@ ipcp_replace_map_create (struct function *func, enum ipa_lattice_type type,
return replace_map; return replace_map;
} }
/* Return true if this callsite should be redirected to /* Return true if this callsite should be redirected to the original callee
the orig callee (instead of the cloned one). */ (instead of the cloned one). */
static bool static bool
ipcp_redirect (struct cgraph_edge *cs) ipcp_need_redirect_p (struct cgraph_edge *cs)
{ {
struct cgraph_node *caller, *callee, *orig_callee; struct ipa_node_params *orig_callee_info;
int i, count; int i, count;
struct ipa_jump_func *jump_func; struct ipa_jump_func *jump_func;
enum jump_func_type type;
enum ipa_lattice_type lattice_type;
caller = cs->caller; orig_callee_info = IPA_NODE_REF (ipcp_get_orig_node (cs->callee));
callee = cs->callee; count = ipa_get_param_count (orig_callee_info);
orig_callee = ipcp_method_orig_node (callee);
count = ipa_get_param_count (IPA_NODE_REF (orig_callee));
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
lattice_type = struct ipcp_lattice *lat = ipcp_get_ith_lattice (orig_callee_info, i);
ipcp_cval_get_cvalue_type (ipcp_method_cval (orig_callee, i)); if (ipcp_lat_is_const (lat))
if (ipcp_type_is_const (lattice_type))
{ {
jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i); jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
type = jump_func->type; if (!ipcp_lat_is_const (lat))
if (type != IPA_CONST && type != IPA_CONST_REF)
return true; return true;
} }
} }
...@@ -916,7 +810,7 @@ ipcp_redirect (struct cgraph_edge *cs) ...@@ -916,7 +810,7 @@ ipcp_redirect (struct cgraph_edge *cs)
return false; return false;
} }
/* Fix the callsites and the callgraph after function cloning was done. */ /* Fix the callsites and the call graph after function cloning was done. */
static void static void
ipcp_update_callgraph (void) ipcp_update_callgraph (void)
{ {
...@@ -926,14 +820,14 @@ ipcp_update_callgraph (void) ...@@ -926,14 +820,14 @@ ipcp_update_callgraph (void)
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
/* want to fix only original nodes */ /* want to fix only original nodes */
if (ipcp_method_is_cloned (node)) if (ipcp_node_is_clone (node))
continue; continue;
for (cs = node->callees; cs; cs = cs->next_callee) for (cs = node->callees; cs; cs = cs->next_callee)
if (ipcp_method_is_cloned (cs->callee)) if (ipcp_node_is_clone (cs->callee))
{ {
/* Callee is a cloned node */ /* Callee is a cloned node */
orig_callee = ipcp_method_orig_node (cs->callee); orig_callee = ipcp_get_orig_node (cs->callee);
if (ipcp_redirect (cs)) if (ipcp_need_redirect_p (cs))
{ {
cgraph_redirect_edge_callee (cs, orig_callee); cgraph_redirect_edge_callee (cs, orig_callee);
TREE_OPERAND (CALL_EXPR_FN (get_call_expr_in (cs->call_stmt)), TREE_OPERAND (CALL_EXPR_FN (get_call_expr_in (cs->call_stmt)),
...@@ -967,8 +861,8 @@ ipcp_update_edges_counts (struct cgraph_node *node, gcov_type scale) ...@@ -967,8 +861,8 @@ ipcp_update_edges_counts (struct cgraph_node *node, gcov_type scale)
e->count = e->count * scale / REG_BR_PROB_BASE; e->count = e->count * scale / REG_BR_PROB_BASE;
} }
/* Update profiling info for versioned methods and the /* Update profiling info for versioned functions and the functions they were
methods they were versioned from. */ versioned from. */
static void static void
ipcp_update_profiling (void) ipcp_update_profiling (void)
{ {
...@@ -978,10 +872,10 @@ ipcp_update_profiling (void) ...@@ -978,10 +872,10 @@ ipcp_update_profiling (void)
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
if (ipcp_method_is_cloned (node)) if (ipcp_node_is_clone (node))
{ {
orig_node = ipcp_method_orig_node (node); orig_node = ipcp_get_orig_node (node);
scale = ipcp_method_get_scale (orig_node); scale = ipcp_get_node_scale (orig_node);
node->count = orig_node->count * scale / REG_BR_PROB_BASE; node->count = orig_node->count * scale / REG_BR_PROB_BASE;
scale_complement = REG_BR_PROB_BASE - scale; scale_complement = REG_BR_PROB_BASE - scale;
orig_node->count = orig_node->count =
...@@ -1005,28 +899,27 @@ ipcp_insert_stage (void) ...@@ -1005,28 +899,27 @@ ipcp_insert_stage (void)
{ {
struct cgraph_node *node, *node1 = NULL; struct cgraph_node *node, *node1 = NULL;
int i, const_param; int i, const_param;
tree cvalue;
VEC (cgraph_edge_p, heap) * redirect_callers; VEC (cgraph_edge_p, heap) * redirect_callers;
varray_type replace_trees; varray_type replace_trees;
struct cgraph_edge *cs; struct cgraph_edge *cs;
int node_callers, count; int node_callers, count;
tree parm_tree; tree parm_tree;
enum ipa_lattice_type type;
struct ipa_replace_map *replace_param; struct ipa_replace_map *replace_param;
for (node = cgraph_nodes; node; node = node->next) for (node = cgraph_nodes; node; node = node->next)
{ {
struct ipa_node_params *info = IPA_NODE_REF (node);
/* Propagation of the constant is forbidden in /* Propagation of the constant is forbidden in
certain conditions. */ certain conditions. */
if (!node->analyzed || ipcp_method_dont_insert_const (node) if (!node->analyzed || ipcp_node_not_modifiable_p (node)
|| ipa_is_called_with_var_arguments (IPA_NODE_REF (node))) || ipa_is_called_with_var_arguments (info))
continue; continue;
const_param = 0; const_param = 0;
count = ipa_get_param_count (IPA_NODE_REF (node)); count = ipa_get_param_count (info);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)); struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
if (ipcp_type_is_const (type)) if (ipcp_lat_is_const (lat))
const_param++; const_param++;
} }
if (const_param == 0) if (const_param == 0)
...@@ -1034,14 +927,13 @@ ipcp_insert_stage (void) ...@@ -1034,14 +927,13 @@ ipcp_insert_stage (void)
VARRAY_GENERIC_PTR_INIT (replace_trees, const_param, "replace_trees"); VARRAY_GENERIC_PTR_INIT (replace_trees, const_param, "replace_trees");
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)); struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
if (ipcp_type_is_const (type)) if (ipcp_lat_is_const (lat))
{ {
cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i)); parm_tree = ipa_get_ith_param (info, i);
parm_tree = ipa_get_ith_param (IPA_NODE_REF (node), i);
replace_param = replace_param =
ipcp_replace_map_create (DECL_STRUCT_FUNCTION (node->decl), ipcp_create_replace_map (DECL_STRUCT_FUNCTION (node->decl),
type, parm_tree, cvalue); parm_tree, lat);
VARRAY_PUSH_GENERIC_PTR (replace_trees, replace_param); VARRAY_PUSH_GENERIC_PTR (replace_trees, replace_param);
} }
} }
...@@ -1063,7 +955,7 @@ ipcp_insert_stage (void) ...@@ -1063,7 +955,7 @@ ipcp_insert_stage (void)
if (dump_file) if (dump_file)
fprintf (dump_file, "versioned function %s\n", fprintf (dump_file, "versioned function %s\n",
cgraph_node_name (node)); cgraph_node_name (node));
ipcp_cloned_create (node, node1); ipcp_init_cloned_node (node, node1);
if (const_param > 0) if (const_param > 0)
{ {
push_cfun (DECL_STRUCT_FUNCTION (node1->decl)); push_cfun (DECL_STRUCT_FUNCTION (node1->decl));
...@@ -1072,13 +964,13 @@ ipcp_insert_stage (void) ...@@ -1072,13 +964,13 @@ ipcp_insert_stage (void)
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
{ {
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)); struct ipcp_lattice *lat = ipcp_get_ith_lattice (info, i);
if (ipcp_type_is_const (type)) if (ipcp_lat_is_const (lat))
{ {
cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i)); parm_tree = ipa_get_ith_param (info, i);
parm_tree = ipa_get_ith_param (IPA_NODE_REF (node), i); if (lat->type != IPA_CONST_VALUE_REF
if (type != IPA_CONST_VALUE_REF && !is_gimple_reg (parm_tree)) && !is_gimple_reg (parm_tree))
ipcp_propagate_const (node1, i, cvalue, type); ipcp_propagate_one_const (node1, i, lat);
} }
} }
if (gimple_in_ssa_p (cfun)) if (gimple_in_ssa_p (cfun))
...@@ -1114,23 +1006,23 @@ ipcp_driver (void) ...@@ -1114,23 +1006,23 @@ ipcp_driver (void)
if (dump_file) if (dump_file)
{ {
fprintf (dump_file, "\nIPA structures before propagation:\n"); fprintf (dump_file, "\nIPA structures before propagation:\n");
ipcp_structures_print (dump_file); ipcp_print_all_structures (dump_file);
} }
/* 2. Do the interprocedural propagation. */ /* 2. Do the interprocedural propagation. */
ipcp_iterate_stage (); ipcp_iterate_stage ();
if (dump_file) if (dump_file)
{ {
fprintf (dump_file, "\nIPA structures after propagation:\n"); fprintf (dump_file, "\nIPA structures after propagation:\n");
ipcp_structures_print (dump_file); ipcp_print_all_structures (dump_file);
fprintf (dump_file, "\nProfiling info before insert stage:\n"); fprintf (dump_file, "\nProfiling info before insert stage:\n");
ipcp_profile_print (dump_file); ipcp_print_profile_data (dump_file);
} }
/* 3. Insert the constants found to the functions. */ /* 3. Insert the constants found to the functions. */
ipcp_insert_stage (); ipcp_insert_stage ();
if (dump_file) if (dump_file)
{ {
fprintf (dump_file, "\nProfiling info after insert stage:\n"); fprintf (dump_file, "\nProfiling info after insert stage:\n");
ipcp_profile_print (dump_file); ipcp_print_profile_data (dump_file);
} }
/* Free all IPCP structures. */ /* Free all IPCP structures. */
ipa_free_all_node_params (); ipa_free_all_node_params ();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment