2005-08-01 09:26:30 +02:00
|
|
|
/* Interprocedural constant propagation
|
function.c (gimplify_parameters): Call build_gimple_modify_stmt instead of calling build2 with a GIMPLE_MODIFY_STMT.
* function.c (gimplify_parameters): Call build_gimple_modify_stmt
instead of calling build2 with a GIMPLE_MODIFY_STMT.
* gimple-low.c (lower_function_body, lower_builtin_setjmp):
Likewise.
* gimplify.c (build_stack_save_restore, gimplify_return_expr,
gimplify_decl_expr, gimplify_self_mod_expr, gimplify_cond_expr,
gimplify_init_ctor_eval_range, gimple_push_cleanup,
gimplify_omp_for, gimplify_omp_atomic_pipeline,
gimplify_omp_atomic_mutex, gimplify_expr, gimplify_one_sizepos,
force_gimple_operand): Likewise.
* ipa-cp.c (constant_val_insert): Likewise.
* lambda-code.c (lbv_to_gcc_expression, lle_to_gcc_expression,
lambda_loopnest_to_gcc_loopnest, replace_uses_equiv_to_x_with_y,
perfect_nestify): Likewise.
* langhooks.c (lhd_omp_assignment): Likewise.
* omp-low.c (lower_rec_input_clauses, lower_reduction_clauses,
lower_copyprivate_clauses, lower_send_clauses,
lower_send_shared_vars, expand_parallel_call,
expand_omp_for_generic, expand_omp_for_static_nochunk,
expand_omp_for_static_chunk, expand_omp_sections,
lower_omp_single_copy, lower_omp_for_lastprivate,
lower_omp_parallel, init_tmp_var, save_tmp_var): Likewise.
* value-prof.c (tree_divmod_fixed_value, tree_mod_pow2,
tree_mod_subtract, tree_ic, tree_stringop_fixed_value):
Likewise.
From-SVN: r122120
2007-02-19 03:45:34 +01:00
|
|
|
Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
|
2005-08-01 09:26:30 +02:00
|
|
|
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
|
2007-07-26 10:37:01 +02:00
|
|
|
Software Foundation; either version 3, or (at your option) any later
|
2005-08-01 09:26:30 +02:00
|
|
|
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
|
2007-07-26 10:37:01 +02:00
|
|
|
along with GCC; see the file COPYING3. If not see
|
|
|
|
<http://www.gnu.org/licenses/>. */
|
2005-08-01 09:26:30 +02:00
|
|
|
|
|
|
|
/* Interprocedural constant propagation.
|
|
|
|
The aim of interprocedural constant propagation (IPCP) is to find which
|
|
|
|
function's argument has the same constant value in each invocation throughout
|
|
|
|
the whole program. For example, for an application consisting of two files,
|
|
|
|
foo1.c, foo2.c:
|
|
|
|
|
|
|
|
foo1.c contains :
|
|
|
|
|
|
|
|
int f (int x)
|
|
|
|
{
|
|
|
|
g (x);
|
|
|
|
}
|
|
|
|
void main (void)
|
|
|
|
{
|
|
|
|
f (3);
|
|
|
|
h (3);
|
|
|
|
}
|
|
|
|
|
|
|
|
foo2.c contains :
|
|
|
|
|
|
|
|
int h (int y)
|
|
|
|
{
|
|
|
|
g (y);
|
|
|
|
}
|
|
|
|
int g (int y)
|
|
|
|
{
|
|
|
|
printf ("value is %d",y);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 152-161
|
|
|
|
|
|
|
|
The optimization is divided into three stages:
|
|
|
|
|
|
|
|
First stage - intraprocedural analysis
|
|
|
|
=======================================
|
|
|
|
This phase computes jump_function and modify information.
|
|
|
|
|
|
|
|
A jump function for a callsite represents the values passed as actual
|
|
|
|
arguments
|
|
|
|
of the callsite. There are three types of values :
|
|
|
|
Formal - the caller's formal parameter is passed as an actual argument.
|
cfgloop.c, [...]: Fix comment typos.
* cfgloop.c, config/alpha/alpha.c, config/bfin/bfin.c,
config/i386/athlon.md, config/ia64/ia64.md,
config/rs6000/rs6000.c, config/s390/s390.c, config/spu/spu.md,
df-problems.c, df.h, fold-const.c, ipa-cp.c, ipa-inline.c,
ipa-prop.h, see.c, struct-equiv.c, tree-inline.c,
tree-ssa-loop-niter.c, tree-vect-analyze.c,
tree-vect-transform.c: Fix comment typos.
From-SVN: r122080
2007-02-18 01:52:51 +01:00
|
|
|
Constant - a constant is passed as an actual argument.
|
2005-08-01 09:26:30 +02:00
|
|
|
Unknown - neither of the above.
|
|
|
|
|
|
|
|
In order to compute the jump functions, we need the modify information for
|
|
|
|
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)
|
|
|
|
The modify info, ipa_modify, is defined in ipa_node structure
|
|
|
|
(defined in ipa_prop.h and pointed to by cgraph_edge->aux).
|
|
|
|
|
|
|
|
-ipcp_init_stage() is the first stage driver.
|
|
|
|
|
|
|
|
Second stage - interprocedural analysis
|
|
|
|
========================================
|
|
|
|
This phase does the interprocedural constant propagation.
|
|
|
|
It computes for all formal parameters in the program
|
|
|
|
their cval value that may be:
|
|
|
|
TOP - unknown.
|
|
|
|
BOTTOM - non constant.
|
|
|
|
CONSTANT_TYPE - constant value.
|
|
|
|
|
|
|
|
Cval of formal f will have a constant value if all callsites to this
|
|
|
|
function have the same constant value passed to f.
|
|
|
|
|
|
|
|
The cval info, ipcp_formal, is defined in ipa_node structure
|
|
|
|
(defined in ipa_prop.h and pointed to by cgraph_edge->aux).
|
|
|
|
|
|
|
|
-ipcp_iterate_stage() is the second stage driver.
|
|
|
|
|
|
|
|
Third phase - transformation of methods code
|
|
|
|
============================================
|
|
|
|
Propagates the constant-valued formals into the function.
|
|
|
|
For each method mt, whose parameters are consts, we create a clone/version.
|
|
|
|
|
|
|
|
We use two ways to annotate the versioned function with the constant
|
|
|
|
formal information:
|
|
|
|
1. We insert an assignment statement 'parameter = const' at the beginning
|
|
|
|
of the cloned method.
|
|
|
|
2. For read-only formals whose address is not taken, we replace all uses
|
|
|
|
of the formal with the constant (we provide versioning with an
|
|
|
|
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
|
|
|
|
of the original ones. For a callsite passing an argument found to be a
|
|
|
|
constant by IPCP, there are two different cases to handle:
|
|
|
|
1. A constant is passed as an argument.
|
|
|
|
2. A parameter (of the caller) passed as an argument (pass through argument).
|
|
|
|
|
|
|
|
In the first case, the callsite in the original caller should be redirected
|
|
|
|
to call the cloned callee.
|
|
|
|
In the second case, both the caller and the callee have clones
|
|
|
|
and the callsite of the cloned caller would be redirected to call to
|
|
|
|
the cloned callee.
|
|
|
|
|
|
|
|
The callgraph is updated accordingly.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "coretypes.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "target.h"
|
|
|
|
#include "cgraph.h"
|
|
|
|
#include "ipa-prop.h"
|
|
|
|
#include "tree-flow.h"
|
|
|
|
#include "tree-pass.h"
|
|
|
|
#include "flags.h"
|
|
|
|
#include "timevar.h"
|
|
|
|
#include "diagnostic.h"
|
2007-01-28 14:01:53 +01:00
|
|
|
#include "tree-dump.h"
|
|
|
|
#include "tree-inline.h"
|
2005-08-01 09:26:30 +02:00
|
|
|
|
|
|
|
/* Get orig node field of ipa_node associated with method MT. */
|
|
|
|
static inline struct cgraph_node *
|
|
|
|
ipcp_method_orig_node (struct cgraph_node *mt)
|
|
|
|
{
|
|
|
|
return IPA_NODE_REF (mt)->ipcp_orig_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if NODE is a cloned/versioned method. */
|
|
|
|
static inline bool
|
|
|
|
ipcp_method_is_cloned (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;
|
|
|
|
}
|
|
|
|
|
Makefile.in, [...]: Fix comment/doc typos.
* Makefile.in, cfgexpand.c, cfgloop.h, cfgloopmanip.c,
config.gcc, ipa-cp.c, ipa-prop.c, ipa-prop.h, reg-stack.c,
tree-ssa-structalias.c, tree-vrp.c, value-prof.c, vec.h,
config/linux.h, config/alpha/alpha.h, config/alpha/linux.h,
config/alpha/predicates.md, config/arc/arc.h,
config/arm/arm.h, config/arm/ieee754-df.S,
config/arm/ieee754-sf.S, config/bfin/bfin.c,
config/bfin/bfin.h, config/c4x/c4x.h, config/crx/crx.c,
config/fr30/fr30.h, config/frv/frv.h, config/h8300/h8300.h,
config/i386/i386.h, config/ia64/ia64.c, config/ia64/ia64.h,
config/m68hc11/m68hc11.h, config/mips/mips.c,
config/mips/mips.h, config/mips/openbsd.h,
config/mn10300/mn10300.h, config/pa/pa.c, config/pa/pa.h,
config/pdp11/pdp11.h, config/rs6000/linux-unwind.h,
config/rs6000/rs6000.c, config/rs6000/rs6000.h,
config/s390/s390.c, config/sh/sh.c, config/sh/sh.h,
config/sparc/linux.h, config/sparc/linux64.h,
config/sparc/sparc.h, config/v850/v850.h, config/vax/vax.h,
doc/extend.texi, doc/gcov.texi, doc/install.texi,
doc/invoke.texi, doc/rtl.texi, doc/tm.texi: Fix comment/doc
typos. Follow spelling conventions.
From-SVN: r102809
2005-08-06 15:26:35 +02:00
|
|
|
/* Create ipa_node and its data structures for NEW_NODE.
|
2005-08-01 09:26:30 +02:00
|
|
|
Set ORIG_NODE as the orig_node field in ipa_node. */
|
|
|
|
static void
|
|
|
|
ipcp_cloned_create (struct cgraph_node *orig_node,
|
|
|
|
struct cgraph_node *new_node)
|
|
|
|
{
|
|
|
|
ipa_node_create (new_node);
|
|
|
|
ipcp_method_set_orig_node (new_node, orig_node);
|
|
|
|
ipa_method_formal_compute_count (new_node);
|
|
|
|
ipa_method_compute_tree_map (new_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return cval_type field of CVAL. */
|
|
|
|
static inline enum cvalue_type
|
|
|
|
ipcp_cval_get_cvalue_type (struct ipcp_formal *cval)
|
|
|
|
{
|
|
|
|
return cval->cval_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return scale for MT. */
|
|
|
|
static inline gcov_type
|
|
|
|
ipcp_method_get_scale (struct cgraph_node *mt)
|
|
|
|
{
|
|
|
|
return IPA_NODE_REF (mt)->count_scale;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set COUNT as scale for MT. */
|
|
|
|
static inline void
|
|
|
|
ipcp_method_set_scale (struct cgraph_node *node, gcov_type count)
|
|
|
|
{
|
|
|
|
IPA_NODE_REF (node)->count_scale = count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set TYPE as cval_type field of CVAL. */
|
|
|
|
static inline void
|
|
|
|
ipcp_cval_set_cvalue_type (struct ipcp_formal *cval, enum cvalue_type type)
|
|
|
|
{
|
|
|
|
cval->cval_type = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return cvalue field of CVAL. */
|
|
|
|
static inline union parameter_info *
|
|
|
|
ipcp_cval_get_cvalue (struct ipcp_formal *cval)
|
|
|
|
{
|
|
|
|
return &(cval->cvalue);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set VALUE as cvalue field CVAL. */
|
|
|
|
static inline void
|
|
|
|
ipcp_cval_set_cvalue (struct ipcp_formal *cval, union parameter_info *value,
|
|
|
|
enum cvalue_type type)
|
|
|
|
{
|
|
|
|
if (type == CONST_VALUE || type == CONST_VALUE_REF)
|
2007-01-28 14:01:53 +01:00
|
|
|
cval->cvalue.value = value->value;
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return whether TYPE is a constant type. */
|
|
|
|
static bool
|
|
|
|
ipcp_type_is_const (enum cvalue_type type)
|
|
|
|
{
|
|
|
|
if (type == CONST_VALUE || type == CONST_VALUE_REF)
|
|
|
|
return true;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if CONST_VAL1 and CONST_VAL2 are equal. */
|
|
|
|
static inline bool
|
|
|
|
ipcp_cval_equal_cvalues (union parameter_info *const_val1,
|
|
|
|
union parameter_info *const_val2,
|
|
|
|
enum cvalue_type type1, enum cvalue_type type2)
|
|
|
|
{
|
|
|
|
gcc_assert (ipcp_type_is_const (type1) && ipcp_type_is_const (type2));
|
|
|
|
if (type1 != type2)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (operand_equal_p (const_val1->value, const_val2->value, 0))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Compute Meet arithmetics:
|
|
|
|
Meet (BOTTOM, x) = BOTTOM
|
|
|
|
Meet (TOP,x) = x
|
|
|
|
Meet (const_a,const_b) = BOTTOM, if const_a != const_b.
|
|
|
|
MEET (const_a,const_b) = const_a, if const_a == const_b.*/
|
|
|
|
static void
|
|
|
|
ipcp_cval_meet (struct ipcp_formal *cval, struct ipcp_formal *cval1,
|
|
|
|
struct ipcp_formal *cval2)
|
|
|
|
{
|
|
|
|
if (ipcp_cval_get_cvalue_type (cval1) == BOTTOM
|
|
|
|
|| ipcp_cval_get_cvalue_type (cval2) == BOTTOM)
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, BOTTOM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ipcp_cval_get_cvalue_type (cval1) == TOP)
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval2));
|
|
|
|
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval2),
|
|
|
|
ipcp_cval_get_cvalue_type (cval2));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ipcp_cval_get_cvalue_type (cval2) == TOP)
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1));
|
|
|
|
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval1),
|
|
|
|
ipcp_cval_get_cvalue_type (cval1));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!ipcp_cval_equal_cvalues (ipcp_cval_get_cvalue (cval1),
|
|
|
|
ipcp_cval_get_cvalue (cval2),
|
|
|
|
ipcp_cval_get_cvalue_type (cval1),
|
|
|
|
ipcp_cval_get_cvalue_type (cval2)))
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, BOTTOM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ipcp_cval_set_cvalue_type (cval, ipcp_cval_get_cvalue_type (cval1));
|
|
|
|
ipcp_cval_set_cvalue (cval, ipcp_cval_get_cvalue (cval1),
|
|
|
|
ipcp_cval_get_cvalue_type (cval1));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return cval structure for the formal at index INFO_TYPE in MT. */
|
|
|
|
static inline struct ipcp_formal *
|
|
|
|
ipcp_method_cval (struct cgraph_node *mt, int info_type)
|
|
|
|
{
|
|
|
|
return &(IPA_NODE_REF (mt)->ipcp_cval[info_type]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given the jump function (TYPE, INFO_TYPE), compute a new value of CVAL.
|
|
|
|
If TYPE is FORMAL_IPA_TYPE, the cval of the corresponding formal is
|
|
|
|
drawn from MT. */
|
|
|
|
static void
|
|
|
|
ipcp_cval_compute (struct ipcp_formal *cval, struct cgraph_node *mt,
|
|
|
|
enum jump_func_type type, union parameter_info *info_type)
|
|
|
|
{
|
|
|
|
if (type == UNKNOWN_IPATYPE)
|
|
|
|
ipcp_cval_set_cvalue_type (cval, BOTTOM);
|
|
|
|
else if (type == CONST_IPATYPE)
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, CONST_VALUE);
|
|
|
|
ipcp_cval_set_cvalue (cval, info_type, CONST_VALUE);
|
|
|
|
}
|
|
|
|
else if (type == CONST_IPATYPE_REF)
|
|
|
|
{
|
|
|
|
ipcp_cval_set_cvalue_type (cval, CONST_VALUE_REF);
|
|
|
|
ipcp_cval_set_cvalue (cval, info_type, CONST_VALUE_REF);
|
|
|
|
}
|
|
|
|
else if (type == FORMAL_IPATYPE)
|
|
|
|
{
|
|
|
|
enum cvalue_type type =
|
|
|
|
ipcp_cval_get_cvalue_type (ipcp_method_cval
|
|
|
|
(mt, info_type->formal_id));
|
|
|
|
ipcp_cval_set_cvalue_type (cval, type);
|
|
|
|
ipcp_cval_set_cvalue (cval,
|
|
|
|
ipcp_cval_get_cvalue (ipcp_method_cval
|
|
|
|
(mt, info_type->formal_id)),
|
|
|
|
type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* True when CVAL1 and CVAL2 values are not the same. */
|
|
|
|
static bool
|
|
|
|
ipcp_cval_changed (struct ipcp_formal *cval1, struct ipcp_formal *cval2)
|
|
|
|
{
|
|
|
|
if (ipcp_cval_get_cvalue_type (cval1) == ipcp_cval_get_cvalue_type (cval2))
|
|
|
|
{
|
|
|
|
if (ipcp_cval_get_cvalue_type (cval1) != CONST_VALUE &&
|
2007-01-28 14:01:53 +01:00
|
|
|
ipcp_cval_get_cvalue_type (cval1) != CONST_VALUE_REF)
|
2005-08-01 09:26:30 +02:00
|
|
|
return false;
|
|
|
|
if (ipcp_cval_equal_cvalues (ipcp_cval_get_cvalue (cval1),
|
|
|
|
ipcp_cval_get_cvalue (cval2),
|
|
|
|
ipcp_cval_get_cvalue_type (cval1),
|
|
|
|
ipcp_cval_get_cvalue_type (cval2)))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create cval structure for method MT. */
|
|
|
|
static inline void
|
|
|
|
ipcp_formal_create (struct cgraph_node *mt)
|
|
|
|
{
|
|
|
|
IPA_NODE_REF (mt)->ipcp_cval =
|
2006-01-31 20:56:55 +01:00
|
|
|
XCNEWVEC (struct ipcp_formal, ipa_method_formal_count (mt));
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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_formal *cval)
|
|
|
|
{
|
|
|
|
IPA_NODE_REF (mt)->ipcp_cval[i].cval_type = cval->cval_type;
|
|
|
|
ipcp_cval_set_cvalue (ipcp_method_cval (mt, i),
|
|
|
|
ipcp_cval_get_cvalue (cval), 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 cvalue_type cval_type1)
|
|
|
|
{
|
|
|
|
IPA_NODE_REF (mt)->ipcp_cval[i].cval_type = cval_type1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print ipcp_cval data structures to F. */
|
|
|
|
static void
|
|
|
|
ipcp_method_cval_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
int i, count;
|
|
|
|
tree cvalue;
|
2007-01-28 14:01:53 +01:00
|
|
|
|
2005-08-01 09:26:30 +02:00
|
|
|
fprintf (f, "\nCVAL PRINT\n");
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
fprintf (f, "Printing cvals %s:\n", cgraph_node_name (node));
|
|
|
|
count = ipa_method_formal_count (node);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i))
|
|
|
|
== CONST_VALUE
|
|
|
|
|| ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) ==
|
|
|
|
CONST_VALUE_REF)
|
|
|
|
{
|
|
|
|
fprintf (f, " param [%d]: ", i);
|
|
|
|
fprintf (f, "type is CONST ");
|
|
|
|
cvalue =
|
2007-01-28 14:01:53 +01:00
|
|
|
ipcp_cval_get_cvalue (ipcp_method_cval (node, i))->value;
|
|
|
|
print_generic_expr (f, cvalue, 0);
|
|
|
|
fprintf (f, "\n");
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
else if (ipcp_method_cval (node, i)->cval_type == TOP)
|
|
|
|
fprintf (f, "param [%d]: type is TOP \n", i);
|
|
|
|
else
|
|
|
|
fprintf (f, "param [%d]: type is BOTTOM \n", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize ipcp_cval array of MT with TOP values.
|
|
|
|
All cvals for a method's formal parameters are initialized to BOTTOM
|
|
|
|
The currently supported types are integer types, real types and
|
|
|
|
Fortran constants (i.e. references to constants defined as
|
|
|
|
const_decls). All other types are not analyzed and therefore are
|
|
|
|
assigned with BOTTOM. */
|
|
|
|
static void
|
|
|
|
ipcp_method_cval_init (struct cgraph_node *mt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
tree parm_tree;
|
|
|
|
|
|
|
|
ipcp_formal_create (mt);
|
|
|
|
for (i = 0; i < ipa_method_formal_count (mt); i++)
|
|
|
|
{
|
|
|
|
parm_tree = ipa_method_get_tree (mt, i);
|
2007-01-28 14:01:53 +01:00
|
|
|
if (INTEGRAL_TYPE_P (TREE_TYPE (parm_tree))
|
|
|
|
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (parm_tree))
|
2005-08-01 09:26:30 +02:00
|
|
|
|| POINTER_TYPE_P (TREE_TYPE (parm_tree)))
|
|
|
|
ipcp_method_cval_set_cvalue_type (mt, i, TOP);
|
|
|
|
else
|
|
|
|
ipcp_method_cval_set_cvalue_type (mt, i, BOTTOM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a new assignment statment and make
|
Makefile.in, [...]: Fix comment/doc typos.
* Makefile.in, cfgexpand.c, cfgloop.h, cfgloopmanip.c,
config.gcc, ipa-cp.c, ipa-prop.c, ipa-prop.h, reg-stack.c,
tree-ssa-structalias.c, tree-vrp.c, value-prof.c, vec.h,
config/linux.h, config/alpha/alpha.h, config/alpha/linux.h,
config/alpha/predicates.md, config/arc/arc.h,
config/arm/arm.h, config/arm/ieee754-df.S,
config/arm/ieee754-sf.S, config/bfin/bfin.c,
config/bfin/bfin.h, config/c4x/c4x.h, config/crx/crx.c,
config/fr30/fr30.h, config/frv/frv.h, config/h8300/h8300.h,
config/i386/i386.h, config/ia64/ia64.c, config/ia64/ia64.h,
config/m68hc11/m68hc11.h, config/mips/mips.c,
config/mips/mips.h, config/mips/openbsd.h,
config/mn10300/mn10300.h, config/pa/pa.c, config/pa/pa.h,
config/pdp11/pdp11.h, config/rs6000/linux-unwind.h,
config/rs6000/rs6000.c, config/rs6000/rs6000.h,
config/s390/s390.c, config/sh/sh.c, config/sh/sh.h,
config/sparc/linux.h, config/sparc/linux64.h,
config/sparc/sparc.h, config/v850/v850.h, config/vax/vax.h,
doc/extend.texi, doc/gcov.texi, doc/install.texi,
doc/invoke.texi, doc/rtl.texi, doc/tm.texi: Fix comment/doc
typos. Follow spelling conventions.
From-SVN: r102809
2005-08-06 15:26:35 +02:00
|
|
|
it the first statement in the function FN
|
2005-08-01 09:26:30 +02:00
|
|
|
tree.
|
|
|
|
PARM1 is the lhs of the assignment and
|
|
|
|
VAL is the rhs. */
|
|
|
|
static void
|
2007-01-28 14:01:53 +01:00
|
|
|
constant_val_insert (tree parm1, tree val)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
2007-01-28 14:01:53 +01:00
|
|
|
tree init_stmt = NULL;
|
2005-08-01 09:26:30 +02:00
|
|
|
edge e_step;
|
|
|
|
|
function.c (gimplify_parameters): Call build_gimple_modify_stmt instead of calling build2 with a GIMPLE_MODIFY_STMT.
* function.c (gimplify_parameters): Call build_gimple_modify_stmt
instead of calling build2 with a GIMPLE_MODIFY_STMT.
* gimple-low.c (lower_function_body, lower_builtin_setjmp):
Likewise.
* gimplify.c (build_stack_save_restore, gimplify_return_expr,
gimplify_decl_expr, gimplify_self_mod_expr, gimplify_cond_expr,
gimplify_init_ctor_eval_range, gimple_push_cleanup,
gimplify_omp_for, gimplify_omp_atomic_pipeline,
gimplify_omp_atomic_mutex, gimplify_expr, gimplify_one_sizepos,
force_gimple_operand): Likewise.
* ipa-cp.c (constant_val_insert): Likewise.
* lambda-code.c (lbv_to_gcc_expression, lle_to_gcc_expression,
lambda_loopnest_to_gcc_loopnest, replace_uses_equiv_to_x_with_y,
perfect_nestify): Likewise.
* langhooks.c (lhd_omp_assignment): Likewise.
* omp-low.c (lower_rec_input_clauses, lower_reduction_clauses,
lower_copyprivate_clauses, lower_send_clauses,
lower_send_shared_vars, expand_parallel_call,
expand_omp_for_generic, expand_omp_for_static_nochunk,
expand_omp_for_static_chunk, expand_omp_sections,
lower_omp_single_copy, lower_omp_for_lastprivate,
lower_omp_parallel, init_tmp_var, save_tmp_var): Likewise.
* value-prof.c (tree_divmod_fixed_value, tree_mod_pow2,
tree_mod_subtract, tree_ic, tree_stringop_fixed_value):
Likewise.
From-SVN: r122120
2007-02-19 03:45:34 +01:00
|
|
|
init_stmt = build_gimple_modify_stmt (parm1, val);
|
2007-01-28 14:01:53 +01:00
|
|
|
|
|
|
|
if (init_stmt)
|
|
|
|
{
|
|
|
|
e_step = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun));
|
2005-08-01 09:26:30 +02:00
|
|
|
bsi_insert_on_edge_immediate (e_step, init_stmt);
|
2007-01-28 14:01:53 +01:00
|
|
|
}
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* build INTEGER_CST tree with type TREE_TYPE and
|
|
|
|
value according to CVALUE. Return the tree. */
|
|
|
|
static tree
|
|
|
|
build_const_val (union parameter_info *cvalue, enum cvalue_type type,
|
|
|
|
tree tree_type)
|
|
|
|
{
|
|
|
|
tree const_val = NULL;
|
|
|
|
|
|
|
|
gcc_assert (ipcp_type_is_const (type));
|
|
|
|
const_val = fold_convert (tree_type, cvalue->value);
|
|
|
|
return const_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Build the tree representing the constant and call
|
|
|
|
constant_val_insert(). */
|
|
|
|
static void
|
|
|
|
ipcp_propagate_const (struct cgraph_node *mt, int param,
|
2007-01-28 14:01:53 +01:00
|
|
|
union parameter_info *cvalue, enum cvalue_type type)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
|
|
|
tree const_val;
|
|
|
|
tree parm_tree;
|
|
|
|
|
|
|
|
if (dump_file)
|
|
|
|
fprintf (dump_file, "propagating const to %s\n", cgraph_node_name (mt));
|
|
|
|
parm_tree = ipa_method_get_tree (mt, param);
|
|
|
|
const_val = build_const_val (cvalue, type, TREE_TYPE (parm_tree));
|
2007-01-28 14:01:53 +01:00
|
|
|
constant_val_insert (parm_tree, const_val);
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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). */
|
|
|
|
static void
|
|
|
|
ipcp_method_compute_scale (struct cgraph_node *node)
|
|
|
|
{
|
|
|
|
gcov_type sum;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
|
|
|
|
sum = 0;
|
|
|
|
/* Compute sum of all counts of callers. */
|
|
|
|
for (cs = node->callers; cs != NULL; cs = cs->next_caller)
|
|
|
|
sum += cs->count;
|
|
|
|
if (node->count == 0)
|
|
|
|
ipcp_method_set_scale (node, 0);
|
|
|
|
else
|
|
|
|
ipcp_method_set_scale (node, sum * REG_BR_PROB_BASE / node->count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialization and computation of IPCP data structures.
|
|
|
|
It is an intraprocedural
|
|
|
|
analysis of methods, 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)
|
|
|
|
{
|
|
|
|
ipa_method_formal_compute_count (node);
|
|
|
|
ipa_method_compute_tree_map (node);
|
|
|
|
ipcp_method_cval_init (node);
|
|
|
|
ipa_method_compute_modify (node);
|
|
|
|
ipcp_method_compute_scale (node);
|
|
|
|
}
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
/* building jump functions */
|
|
|
|
for (cs = node->callees; cs; cs = cs->next_callee)
|
|
|
|
{
|
|
|
|
ipa_callsite_compute_count (cs);
|
|
|
|
if (ipa_callsite_param_count (cs)
|
|
|
|
!= ipa_method_formal_count (cs->callee))
|
|
|
|
{
|
|
|
|
/* Handle cases of functions with
|
|
|
|
a variable number of parameters. */
|
|
|
|
ipa_callsite_param_count_set (cs, 0);
|
|
|
|
ipa_method_formal_count_set (cs->callee, 0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ipa_callsite_compute_param (cs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if there are some formal parameters whose value is TOP.
|
|
|
|
Change their values to BOTTOM, since they weren't determined. */
|
|
|
|
static bool
|
|
|
|
ipcp_after_propagate (void)
|
|
|
|
{
|
|
|
|
int i, count;
|
|
|
|
struct cgraph_node *node;
|
|
|
|
bool prop_again;
|
|
|
|
|
|
|
|
prop_again = false;
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
count = ipa_method_formal_count (node);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
if (ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i)) == TOP)
|
|
|
|
{
|
|
|
|
prop_again = true;
|
|
|
|
ipcp_method_cval_set_cvalue_type (node, i, BOTTOM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return prop_again;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Interprocedural analysis. The algorithm propagates constants from
|
|
|
|
the caller's parameters to the callee's arguments. */
|
|
|
|
static void
|
|
|
|
ipcp_propagate_stage (void)
|
|
|
|
{
|
|
|
|
int i;
|
2007-06-30 12:52:30 +02:00
|
|
|
struct ipcp_formal cval1 = { BOTTOM, {0} }, cval = { BOTTOM, {0} };
|
2005-08-01 09:26:30 +02:00
|
|
|
struct ipcp_formal *cval2;
|
|
|
|
struct cgraph_node *mt, *callee;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
struct ipa_jump_func *jump_func;
|
|
|
|
enum jump_func_type type;
|
|
|
|
union parameter_info *info_type;
|
|
|
|
ipa_methodlist_p wl;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
/* Initialize worklist to contain all methods. */
|
|
|
|
wl = ipa_methodlist_init ();
|
|
|
|
while (ipa_methodlist_not_empty (wl))
|
|
|
|
{
|
|
|
|
mt = ipa_remove_method (&wl);
|
|
|
|
for (cs = mt->callees; cs; cs = cs->next_callee)
|
|
|
|
{
|
|
|
|
callee = ipa_callsite_callee (cs);
|
|
|
|
count = ipa_callsite_param_count (cs);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
jump_func = ipa_callsite_param (cs, i);
|
|
|
|
type = get_type (jump_func);
|
|
|
|
info_type = ipa_jf_get_info_type (jump_func);
|
|
|
|
ipcp_cval_compute (&cval1, mt, type, info_type);
|
|
|
|
cval2 = ipcp_method_cval (callee, i);
|
|
|
|
ipcp_cval_meet (&cval, &cval1, cval2);
|
|
|
|
if (ipcp_cval_changed (&cval, cval2))
|
|
|
|
{
|
|
|
|
ipcp_method_cval_set (callee, i, &cval);
|
|
|
|
ipa_add_method (&wl, callee);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call the constant propagation algorithm and re-call it if necessary
|
|
|
|
(if there are undetermined values left). */
|
|
|
|
static void
|
|
|
|
ipcp_iterate_stage (void)
|
|
|
|
{
|
|
|
|
ipcp_propagate_stage ();
|
|
|
|
if (ipcp_after_propagate ())
|
|
|
|
/* Some cvals have changed from TOP to BOTTOM.
|
|
|
|
This change should be propagated. */
|
|
|
|
ipcp_propagate_stage ();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check conditions to forbid constant insertion to MT. */
|
|
|
|
static bool
|
|
|
|
ipcp_method_dont_insert_const (struct cgraph_node *mt)
|
|
|
|
{
|
|
|
|
/* ??? Handle pending sizes case. */
|
|
|
|
if (DECL_UNINLINABLE (mt->decl))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print ipa_jump_func data structures to F. */
|
|
|
|
static void
|
|
|
|
ipcp_callsite_param_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
int i, count;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
struct ipa_jump_func *jump_func;
|
|
|
|
enum jump_func_type type;
|
|
|
|
tree info_type;
|
2007-01-28 14:01:53 +01:00
|
|
|
|
2005-08-01 09:26:30 +02:00
|
|
|
fprintf (f, "\nCALLSITE PARAM PRINT\n");
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
for (cs = node->callees; cs; cs = cs->next_callee)
|
|
|
|
{
|
|
|
|
fprintf (f, "callsite %s ", cgraph_node_name (node));
|
|
|
|
fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
|
|
|
|
count = ipa_callsite_param_count (cs);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
jump_func = ipa_callsite_param (cs, i);
|
|
|
|
type = get_type (jump_func);
|
|
|
|
|
|
|
|
fprintf (f, " param %d: ", i);
|
|
|
|
if (type == UNKNOWN_IPATYPE)
|
|
|
|
fprintf (f, "UNKNOWN\n");
|
|
|
|
else if (type == CONST_IPATYPE || type == CONST_IPATYPE_REF)
|
|
|
|
{
|
2007-01-28 14:01:53 +01:00
|
|
|
info_type = ipa_jf_get_info_type (jump_func)->value;
|
|
|
|
fprintf (f, "CONST : ");
|
|
|
|
print_generic_expr (f, info_type, 0);
|
|
|
|
fprintf (f, "\n");
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
else if (type == FORMAL_IPATYPE)
|
|
|
|
{
|
|
|
|
fprintf (f, "FORMAL : ");
|
|
|
|
fprintf (f, "%d\n",
|
|
|
|
ipa_jf_get_info_type (jump_func)->formal_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print count scale data structures. */
|
|
|
|
static void
|
|
|
|
ipcp_method_scale_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
fprintf (f, "printing scale for %s: ", cgraph_node_name (node));
|
|
|
|
fprintf (f, "value is " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" \n", (HOST_WIDE_INT) ipcp_method_get_scale (node));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print counts of all cgraph nodes. */
|
|
|
|
static void
|
|
|
|
ipcp_profile_mt_count_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
fprintf (f, "method %s: ", cgraph_node_name (node));
|
|
|
|
fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" \n", (HOST_WIDE_INT) node->count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Makefile.in, [...]: Fix comment/doc typos.
* Makefile.in, cfgexpand.c, cfgloop.h, cfgloopmanip.c,
config.gcc, ipa-cp.c, ipa-prop.c, ipa-prop.h, reg-stack.c,
tree-ssa-structalias.c, tree-vrp.c, value-prof.c, vec.h,
config/linux.h, config/alpha/alpha.h, config/alpha/linux.h,
config/alpha/predicates.md, config/arc/arc.h,
config/arm/arm.h, config/arm/ieee754-df.S,
config/arm/ieee754-sf.S, config/bfin/bfin.c,
config/bfin/bfin.h, config/c4x/c4x.h, config/crx/crx.c,
config/fr30/fr30.h, config/frv/frv.h, config/h8300/h8300.h,
config/i386/i386.h, config/ia64/ia64.c, config/ia64/ia64.h,
config/m68hc11/m68hc11.h, config/mips/mips.c,
config/mips/mips.h, config/mips/openbsd.h,
config/mn10300/mn10300.h, config/pa/pa.c, config/pa/pa.h,
config/pdp11/pdp11.h, config/rs6000/linux-unwind.h,
config/rs6000/rs6000.c, config/rs6000/rs6000.h,
config/s390/s390.c, config/sh/sh.c, config/sh/sh.h,
config/sparc/linux.h, config/sparc/linux64.h,
config/sparc/sparc.h, config/v850/v850.h, config/vax/vax.h,
doc/extend.texi, doc/gcov.texi, doc/install.texi,
doc/invoke.texi, doc/rtl.texi, doc/tm.texi: Fix comment/doc
typos. Follow spelling conventions.
From-SVN: r102809
2005-08-06 15:26:35 +02:00
|
|
|
/* Print counts of all cgraph edges. */
|
2005-08-01 09:26:30 +02:00
|
|
|
static void
|
|
|
|
ipcp_profile_cs_count_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
for (cs = node->callees; cs; cs = cs->next_callee)
|
|
|
|
{
|
|
|
|
fprintf (f, "%s -> %s ", cgraph_node_name (cs->caller),
|
|
|
|
cgraph_node_name (cs->callee));
|
|
|
|
fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC " \n",
|
|
|
|
(HOST_WIDE_INT) cs->count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print all counts and probabilities of cfg edges of all methods. */
|
|
|
|
static void
|
|
|
|
ipcp_profile_edge_print (FILE * f)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node;
|
|
|
|
basic_block bb;
|
|
|
|
edge_iterator ei;
|
|
|
|
edge e;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
fprintf (f, "method %s: \n", cgraph_node_name (node));
|
|
|
|
if (DECL_SAVED_TREE (node->decl))
|
|
|
|
{
|
|
|
|
bb =
|
|
|
|
ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (node->decl));
|
|
|
|
fprintf (f, "ENTRY: ");
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" %d\n", (HOST_WIDE_INT) bb->count, bb->frequency);
|
|
|
|
|
|
|
|
if (bb->succs)
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
|
{
|
|
|
|
if (e->dest ==
|
|
|
|
EXIT_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION
|
|
|
|
(node->decl)))
|
|
|
|
fprintf (f, "edge ENTRY -> EXIT, Count");
|
|
|
|
else
|
|
|
|
fprintf (f, "edge ENTRY -> %d, Count", e->dest->index);
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" Prob %d\n", (HOST_WIDE_INT) e->count,
|
|
|
|
e->probability);
|
|
|
|
}
|
|
|
|
FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
|
|
|
|
{
|
|
|
|
fprintf (f, "bb[%d]: ", bb->index);
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" %d\n", (HOST_WIDE_INT) bb->count, bb->frequency);
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
|
{
|
|
|
|
if (e->dest ==
|
|
|
|
EXIT_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION
|
|
|
|
(node->decl)))
|
|
|
|
fprintf (f, "edge %d -> EXIT, Count", e->src->index);
|
|
|
|
else
|
|
|
|
fprintf (f, "edge %d -> %d, Count", e->src->index,
|
|
|
|
e->dest->index);
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC " Prob %d\n",
|
|
|
|
(HOST_WIDE_INT) e->count, e->probability);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print counts and frequencies for all basic blocks of all methods. */
|
|
|
|
static void
|
|
|
|
ipcp_profile_bb_print (FILE * f)
|
|
|
|
{
|
|
|
|
basic_block bb;
|
|
|
|
struct cgraph_node *node;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
fprintf (f, "method %s: \n", cgraph_node_name (node));
|
2007-01-28 14:01:53 +01:00
|
|
|
if (node->analyzed)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
|
|
|
bb =
|
|
|
|
ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (node->decl));
|
|
|
|
fprintf (f, "ENTRY: Count");
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
c-typeck.c, [...]: Fix typos and follow spelling conventions in various warning/error/diagnostic...
* c-typeck.c, config/arm/arm.c, config/darwin.c,
config/sh/symbian.c, gcc.c, ipa-cp.c, ipa-inline.c, loop-iv.c,
omega.c, tree-ssa-loop-niter.c, treestruct.def: Fix typos and
follow spelling conventions in various
warning/error/diagnostic messages.
From-SVN: r125089
2007-05-26 14:17:52 +02:00
|
|
|
" Frequency %d\n", (HOST_WIDE_INT) bb->count,
|
2005-08-01 09:26:30 +02:00
|
|
|
bb->frequency);
|
|
|
|
|
|
|
|
FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
|
|
|
|
{
|
|
|
|
fprintf (f, "bb[%d]: Count", bb->index);
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" Frequency %d\n", (HOST_WIDE_INT) bb->count,
|
|
|
|
bb->frequency);
|
|
|
|
}
|
|
|
|
bb =
|
|
|
|
EXIT_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (node->decl));
|
|
|
|
fprintf (f, "EXIT: Count");
|
|
|
|
fprintf (f, " " HOST_WIDE_INT_PRINT_DEC
|
|
|
|
" Frequency %d\n", (HOST_WIDE_INT) bb->count,
|
|
|
|
bb->frequency);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print all IPCP data structures to F. */
|
|
|
|
static void
|
|
|
|
ipcp_structures_print (FILE * f)
|
|
|
|
{
|
|
|
|
ipcp_method_cval_print (f);
|
|
|
|
ipcp_method_scale_print (f);
|
|
|
|
ipa_method_tree_print (f);
|
|
|
|
ipa_method_modify_print (f);
|
|
|
|
ipcp_callsite_param_print (f);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Print profile info for all methods. */
|
|
|
|
static void
|
|
|
|
ipcp_profile_print (FILE * f)
|
|
|
|
{
|
|
|
|
fprintf (f, "\nNODE COUNTS :\n");
|
|
|
|
ipcp_profile_mt_count_print (f);
|
|
|
|
fprintf (f, "\nCS COUNTS stage:\n");
|
|
|
|
ipcp_profile_cs_count_print (f);
|
|
|
|
fprintf (f, "\nBB COUNTS and FREQUENCIES :\n");
|
|
|
|
ipcp_profile_bb_print (f);
|
|
|
|
fprintf (f, "\nCFG EDGES COUNTS and PROBABILITIES :\n");
|
|
|
|
ipcp_profile_edge_print (f);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Build and initialize ipa_replace_map struct
|
|
|
|
according to TYPE. This struct is read by versioning, which
|
|
|
|
operates according to the flags sent. PARM_TREE is the
|
|
|
|
formal's tree found to be constant. CVALUE represents the constant. */
|
|
|
|
static struct ipa_replace_map *
|
2007-01-28 14:01:53 +01:00
|
|
|
ipcp_replace_map_create (struct function *func, enum cvalue_type type,
|
|
|
|
tree parm_tree, union parameter_info *cvalue)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
|
|
|
struct ipa_replace_map *replace_map;
|
|
|
|
tree const_val;
|
|
|
|
|
2006-01-31 20:56:55 +01:00
|
|
|
replace_map = XCNEW (struct ipa_replace_map);
|
2005-08-01 09:26:30 +02:00
|
|
|
gcc_assert (ipcp_type_is_const (type));
|
2007-01-28 14:01:53 +01:00
|
|
|
if (type != CONST_VALUE_REF
|
|
|
|
&& is_gimple_reg (parm_tree) && gimple_default_def (func, parm_tree)
|
|
|
|
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_default_def (func, parm_tree)))
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
2007-01-28 14:01:53 +01:00
|
|
|
if (dump_file)
|
|
|
|
fprintf (dump_file, "replacing param with const\n");
|
2005-08-01 09:26:30 +02:00
|
|
|
const_val = build_const_val (cvalue, type, TREE_TYPE (parm_tree));
|
2007-01-28 14:01:53 +01:00
|
|
|
replace_map->old_tree =gimple_default_def (func, parm_tree);
|
2005-08-01 09:26:30 +02:00
|
|
|
replace_map->new_tree = const_val;
|
|
|
|
replace_map->replace_p = true;
|
|
|
|
replace_map->ref_p = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
replace_map->old_tree = NULL;
|
|
|
|
replace_map->new_tree = NULL;
|
|
|
|
replace_map->replace_p = false;
|
|
|
|
replace_map->ref_p = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return replace_map;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true if this callsite should be redirected to
|
|
|
|
the orig callee (instead of the cloned one). */
|
|
|
|
static bool
|
|
|
|
ipcp_redirect (struct cgraph_edge *cs)
|
|
|
|
{
|
|
|
|
struct cgraph_node *caller, *callee, *orig_callee;
|
|
|
|
int i, count;
|
|
|
|
struct ipa_jump_func *jump_func;
|
|
|
|
enum jump_func_type type;
|
|
|
|
enum cvalue_type cval_type;
|
|
|
|
|
|
|
|
caller = cs->caller;
|
|
|
|
callee = cs->callee;
|
|
|
|
orig_callee = ipcp_method_orig_node (callee);
|
|
|
|
count = ipa_method_formal_count (orig_callee);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
cval_type =
|
|
|
|
ipcp_cval_get_cvalue_type (ipcp_method_cval (orig_callee, i));
|
|
|
|
if (ipcp_type_is_const (cval_type))
|
|
|
|
{
|
|
|
|
jump_func = ipa_callsite_param (cs, i);
|
|
|
|
type = get_type (jump_func);
|
2007-01-28 14:01:53 +01:00
|
|
|
if (type != CONST_IPATYPE && type != CONST_IPATYPE_REF)
|
2005-08-01 09:26:30 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix the callsites and the callgraph after function cloning was done. */
|
|
|
|
static void
|
|
|
|
ipcp_update_callgraph (void)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node, *orig_callee;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
/* want to fix only original nodes */
|
|
|
|
if (ipcp_method_is_cloned (node))
|
|
|
|
continue;
|
|
|
|
for (cs = node->callees; cs; cs = cs->next_callee)
|
|
|
|
if (ipcp_method_is_cloned (cs->callee))
|
|
|
|
{
|
|
|
|
/* Callee is a cloned node */
|
|
|
|
orig_callee = ipcp_method_orig_node (cs->callee);
|
|
|
|
if (ipcp_redirect (cs))
|
|
|
|
{
|
|
|
|
cgraph_redirect_edge_callee (cs, orig_callee);
|
tree.h (enum tree_code_class): Add tcc_vl_exp.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* tree.h (enum tree_code_class): Add tcc_vl_exp.
(VL_EXP_CLASS_P): New.
(TREE_OPERAND_CHECK): Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH.
(TREE_OPERAND_CHECK_CODE): Likewise.
(GIMPLE_STMT_OPERAND_CHECK): Likewise.
(TREE_RTL_OPERAND_CHECK): Likewise.
(tree_operand_check_failed): Make second parameter the whole tree
instead of its code. Fixed callers.
(VL_EXP_CHECK): New.
(TREE_OPERAND_LENGTH): New.
(VL_EXP_OPERAND_LENGTH): New.
(CALL_EXPR_FN): New.
(CALL_EXPR_STATIC_CHAIN): New.
(CALL_EXPR_ARGS): New.
(CALL_EXPR_ARG): New.
(call_expr_nargs): New.
(CALL_EXPR_ARGP): New.
(build_nt_call_list): Declare.
(build_vl_exp_stat): Declare.
(build_vl_exp): New.
(build_call_list): Declare.
(build_call_nary): Declare.
(build_call_valist): Declare.
(build_call_array): Declare.
(call_expr_arg): Declare.
(call_expr_argp): Declare.
(call_expr_arglist): Declare.
(fold_build_call_list): Declare.
(fold_build_call_list_initializer): Declare.
(fold_call_expr): Declare to replace fold_builtin.
(fold_builtin_fputs): Update to agree with modified definition.
(fold_builtin_strcpy): Likewise.
(fold_builtin_strncpy): Likewise.
(fold_builtin_memory_chk): Likewise.
(fold_builtin_stxcpy_chk): Likewise.
(fold_builtin_strncpy_chk): Likewise.
(fold_builtin_next_arg): Likewise.
(fold_build_call_expr): Declare.
(fold_builtin_call_list): Declare.
(fold_builtin_call_valist): Declare.
(build_call_expr): Declare.
(validate_arglist): Update to agree with modified definition.
(tree_operand_length): New.
(call_expr_arg_iterator): New.
(init_call_expr_arg_iterator): New.
(next_call_expr_arg): New.
(first_call_expr_arg): New.
(more_call_expr_args_p): New.
(FOR_EACH_CALL_EXPR_ARG): New.
* tree.c (tree_code_class_string): Add entries for tcc_vl_exp
and tcc_gimple_stmt.
(tree_code_size): Update documentation. Use sizeof (tree) rather
than sizeof (char *).
(tree_size): Likewise. Add case for tcc_vl_exp.
(tree_node_structure): Add case for tcc_vl_exp.
(contains_placeholder_p): Likewise.
(substitute_in_expr): Likewise.
(substitute_placeholder_in_expr): Likewise.
(stabilize_reference_1): Likewise.
(build3_stat): Remove logic for CALL_EXPRs. Replace with assertion
to diagnose breakage of this interface for constructing CALL_EXPRs.
(build_nt): Add similar assertion here.
(build_nt_call_list): New.
(simple_cst_equal) <CALL_EXPR>: Rewrite to use new accessors.
(iterative_hash_expr): Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH.
(get_callee_fndecl): Use new CALL_EXPR accessors.
(tree_operand_check_failed): Change parameters to pass entire node
instead of its code, so that we can call TREE_OPERAND_LENGTH on it.
(process_call_operands): New.
(build_vl_exp_stat): New.
(build_call_list): New.
(build_call_nary): New.
(build_call_valist): New.
(build_call_array): New.
(walk_tree): Use TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
(call_expr_arglist): New.
* tree.def (CALL_EXPR): Change representation of CALL_EXPRs to use
tcc_vl_exp instead of a fixed-size tcc_expression.
* doc/c-tree.texi (CALL_EXPR): Document new representation and
accessors for CALL_EXPRs.
(AGGR_INIT_EXPR): Likewise.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* builtins.c (c_strlen): Return NULL_TREE instead of 0.
(expand_builtin_nonlocal_goto): Change parameter to be entire
CALL_EXPR instead of an arglist. Use new CALL_EXPR accessors.
(expand_builtin_prefetch): Likewise.
(expand_builtin_classify_type): Likewise.
(mathfn_built_in): Return NULL_TREE instead of 0.
(expand_errno_check): Use new CALL_EXPR accessors.
(expand_builtin_mathfn): Use new CALL_EXPR accessors and constructors.
Return NULL_RTX instead of 0.
(expand_builtin_mathfn_2): Likewise.
(expand_builtin_mathfn_3): Likewise.
(expand_builtin_interclass_mathfn): Likewise.
(expand_builtin_sincos): Likewise.
(expand_builtin_cexpi): Likewise.
(expand_builtin_int_roundingfn): Likewise.
(expand_builtin_int_roundingfn_2): Likewise.
(expand_builtin_pow): Likewise.
(expand_builtin_powi): Likewise.
(expand_builtin_strlen): Pass entire CALL_EXPR as parameter instead
of arglist, fixing callers appropriately. Use new CALL_EXPR
accessors and constructors. Return NULL_RTX instead of 0.
(expand_builtin_strstr): Likewise.
(expand_builtin_strchr): Likewise.
(expand_builtin_strrchr): Likewise.
(expand_builtin_strpbrk): Likewise.
(expand_builtin_memcpy): Likewise.
(expand_builtin_mempcpy): Likewise.
(expand_builtin_mempcpy_args): New.
(expand_builtin_memmove): Similarly to expand_builtin_mempcpy.
(expand_builtin_memmove_args): New.
(expand_builtin_bcopy): Similarly to expand_builtin_mempcpy.
(expand_movstr): Likewise.
(expand_builtin_strcpy): Likewise.
(expand_builtin_strcpy_args): New.
(expand_builtin_stpcpy): Similarly to expand_builtin_strcpy.
(expand_builtin_strncpy): Likewise.
(expand_builtin_memset): Likewise.
(expand_builtin_memset_args): New.
(expand_builtin_bzero): Similarly to expand_builtin_memset.
(expand_builtin_memcmp): Likewise.
(expand_builtin_strcmp): Likewise.
(expand_builtin_strncmp): Likewise.
(expand_builtin_strcat): Likewise.
(expand_builtin_strncat): Likewise.
(expand_builtin_strspn): Likewise.
(expand_builtin_strcspn): Likewise.
(expand_builtin_args_info): Likewise.
(expand_builtin_va_start): Likewise.
(gimplify_va_arg_expr): Likewise.
(expand_builtin_va_end): Likewise.
(expand_builtin_va_copy): Likewise.
(expand_builtin_frame_address): Likewise.
(expand_builtin_alloca): Likewise.
(expand_builtin_bswap): Likewise.
(expand_builtin_unop): Likewise.
(expand_builtin_fputs): Likewise.
(expand_builtin_expect): Likewise.
(expand_builtin_fabs): Likewise.
(expand_builtin_copysign): Likewise.
(expand_builtin_printf): Likewise.
(expand_builtin_fprintf): Likewise.
(expand_builtin_sprintf): Likewise.
(expand_builtin_init_trampoline): Likewise.
(expand_builtin_signbit): Likewise.
(expand_builtin_fork_or_exec): Likewise.
(expand_builtin_sync_operation): Likewise.
(expand_builtin_compare_and_swap): Likewise.
(expand_builtin_lock_test_and_set): Likewise.
(expand_builtin_lock_release): Likewise.
(expand_builtin): Likewise.
(builtin_mathfn_code): Likewise.
(fold_builtin_constant_p): Pass call arguments individually instead
of as an arglist, fixing callers appropriately. Use new CALL_EXPR
accessors and constructors. Return NULL_TREE instead of 0.
(fold_builtin_expect): Likewise.
(fold_builtin_classify_type): Likewise.
(fold_builtin_strlen): Likewise.
(fold_builtin_nan): Likewise.
(integer_valued_real_p): Likewise.
(fold_trunc_transparent_mathfn): Likewise.
(fold_fixed_mathfn): Likewise.
(fold_builtin_cabs): Likewise.
(fold_builtin_sqrt): Likewise.
(fold_builtin_cbrt): Likewise.
(fold_builtin_cos): Likewise.
(fold_builtin_cosh): Likewise.
(fold_builtin_tan): Likewise.
(fold_builtin_sincos): Likewise.
(fold_builtin_cexp): Likewise.
(fold_builtin_trunc): Likewise.
(fold_builtin_floor): Likewise.
(fold_builtin_ceil): Likewise.
(fold_builtin_round): Likewise.
(fold_builtin_int_roundingfn): Likewise.
(fold_builtin_bitop): Likewise.
(fold_builtin_bswap): Likewise.
(fold_builtin_logarithm): Likewise.
(fold_builtin_hypot): Likewise.
(fold_builtin_pow): Likewise.
(fold_builtin_powi): Likewise.
(fold_builtin_exponent): Likewise.
(fold_builtin_memset): Likewise.
(fold_builtin_bzero): Likewise.
(fold_builtin_memory_op): Likewise.
(fold_builtin_bcopy): Deleted; call site changed to invoke
fold_builtin_memory_op directly.
(fold_builtin_strcpy): Similarly as for fold_builtin_memory_op.
(fold_builtin_strncpy): Likewise.
(fold_builtin_memcmp): Likewise.
(fold_builtin_strcmp): Likewise.
(fold_builtin_strncmp): Likewise.
(fold_builtin_signbit): Likewise.
(fold_builtin_copysign): Likewise.
(fold_builtin_isascii): Likewise.
(fold_builtin_toascii): Likewise.
(fold_builtin_isdigit): Likewise.
(fold_builtin_fabs): Likewise.
(fold_builtin_abs): Likewise.
(fold_builtin_fmin_fmax): Likewise.
(fold_builtin_carg): Likewise.
(fold_builtin_classify): Likewise.
(fold_builtin_unordered_cmp): Likewise.
(fold_builtin_0, fold_builtin_2, fold_builtin_3, fold_builtin_4):
New functions split out from fold_builtin_1.
(fold_builtin_n): New.
(fold_builtin_varargs): New.
(fold_builtin): Deleted. Most callers changed to use fold_call_expr
instead.
(fold_call_expr): New.
(build_function_call_expr): Rewrite to use new helper function.
(fold_builtin_call_list): New.
(build_call_expr): New.
(fold_builtin_call_valist): New.
(rewrite_call_expr): New.
(validate_arg): New.
(validate_arglist): Change parameter to be entire CALL_EXPR instead
of an arglist. Change return type to bool. Use new CALL_EXPR
accessors.
(fold_builtin_strstr): Pass call arguments individually instead
of as an arglist, fixing callers appropriately. Use new CALL_EXPR
accessors and constructors. Return NULL_TREE instead of 0.
(fold_builtin_strchr): Likewise.
(fold_builtin_strrchr): Likewise.
(fold_builtin_strpbrk): Likewise.
(fold_builtin_strcat): Likewise.
(fold_builtin_strncat): Likewise.
(fold_builtin_strspn): Likewise.
(fold_builtin_strcspn): Likewise.
(fold_builtin_fputs): Likewise.
(fold_builtin_next_arg): Likewise.
(fold_builtin_sprintf): Likewise.
(expand_builtin_object_size): Use new CALL_EXPR accessors. Use
NULL_RTX instead of 0.
(expand_builtin_memory_chk): Likewise.
(maybe_emit_chk_warning): Likewise.
(maybe_emit_sprintf_chk_warning): Likewise.
(fold_builtin_object_size): Pass call arguments individually instead
of as an arglist, fixing callers appropriately. Use new CALL_EXPR
accessors and constructors. Return NULL_TREE instead of 0.
(fold_builtin_memory_chk): Likewise.
(fold_builtin_stxcpy_chk): Likewise.
(fold_builtin_strncpy_chk): Likewise.
(fold_builtin_strcat_chk): Likewise.
(fold_builtin_strcat_chk): Likewise.
(fold_builtin_strncat_chk): Likewise.
(fold_builtin_sprintf_chk): Likewise.
(fold_builtin_snprintf_chk): Likewise.
(fold_builtin_printf): Likewise.
(fold_builtin_vprintf): Likewise.
* fold-const.c (negate_expr_p): Use new CALL_EXPR accessors and
constructors.
(operand_equal_p): Add separate tcc_vl_exp/CALL_EXPR case.
(make_range): Use TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
(extract_muldiv_1): Add VL_EXP_CLASS_P case.
(fold_mathfn_compare): Use new CALL_EXPR accessors and constructors.
(fold_unary): Likewise.
(fold_binary): Likewise.
(fold_ternary): Remove CALL_EXPR case, since they are no longer
ternary expressions.
(fold): Add logic for tcc_vl_exp.
(fold_checksum_tree): Make it know about tcc_vl_exp. Use
TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
(fold_build3_stat): Add assertion to flag broken interface for
constructing CALL_EXPRs.
(fold_build_call_list): New.
(fold_build_call_list_initializer): New.
(tree_expr_nonnegative_p): Use new CALL_EXPR accessors and
constructors.
(fold_strip_sign_ops): Likewise.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* tree-dump.c (dequeue_and_dump) <CALL_EXPR>: Use new CALL_EXPR
accessors and dump arguments explicitly.
* tree-pretty-print.c (do_niy): Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH.
(dump_generic_node): Use new CALL_EXPR accessors and walk arguments
explicitly.
(print_call_name): Use new CALL_EXPR accessors.
* print-tree.c (print_node): Add case tcc_vl_exp. Print
CALL_EXPR arguments explicitly instead of as a list. Use
TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
* tree-vrp.c (stmt_interesting_for_vrp): Use new CALL_EXPR accessors.
(vrp_visit_stmt): Likewise.
* tree-ssa-loop-im.c (outermost_invariant_loop_expr): Make it
know about tcc_vl_exp. Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH.
(force_move_till_expr): Likewise.
* targhooks.c (default_external_stack_protect_fail): Use
build_call_expr instead of build_function_call_expr.
(default_hidden_stack_protect_fail): Likewise.
* tree-complex.c (expand_complex_libcall): Use build_call_expr to
build the call.
* cgraphbuild.c (build_cgraph_edges): Use new CALL_EXPR accessors
and walk arguments explicitly.
* tree-ssa-loop-niter.c (simplify_replace_tree): Use
TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
(expand_simple_operations): Likewise.
(infer_loop_bounds_from_array): Use new CALL_EXPR accessors.
* gengtype.c (adjust_field_tree_exp): Use TREE_OPERAND_LENGTH instead
of TREE_CODE_LENGTH.
(walk_type): Tweak walking of arrays not to blow up on CALL_EXPRs.
* optabs.c (expand_widen_pattern-expr): Use TREE_OPERAND_LENGTH
instead of TREE_CODE_LENGTH.
* value_prof.c (tree_ic): Use new CALL_EXPR accessors.
(tree_ic_transform): Likewise.
(interesting_stringop_to_profile_p): Pass entire CALL_EXPR as
parameter instead of arglist. Fix callers.
(tree_stringop_fixed_value): Use new CALL_EXPR accessors.
(tree_stringops_transform): Likewise.
(tree_indirect_call_to_profile): Likewise.
(tree_stringops_values_to_profile): Likewise.
* tree-tailcall.c (find_tail_calls): Use new CALL_EXPR iterator.
(eliminate_tail_call): Likewise.
* ipa-cp.c (ipcp_update_callgraph): Use new CALL_EXPR accessors.
* tree-scalar-evolution.c (chrec_contains_symbols_defined_in_loop):
Use TREE_OPERAND_LENGTH and generalize to handle any number of
operands.
(instantiate_parameters_1): Can't handle tcc_vl_exp here.
* omp-low.c (build_omp_barrier): Use build_call_expr.
(lower_rec_input_clauses): Likewise.
(lower_reduction_clauses): Likewise.
(expand_parallel_call): Likewise.
(maybe_catch_exception): Likewise.
(expand_omp_for_generic): Likewise.
(expand_omp_for_static_nochunk): Likewise.
(expand_omp_sections): Likewise.
(lower_omp_single_simple): Likewise.
(lower_omp_single_copy): Likewise.
(lower_omp_master): Likewise.
(lower_omp_ordered): Likewise.
(lower_omp_critical): Likewise.
* ipa-reference.c (check-call): Use new CALL_EXPR iterator.
(scan_for_static_refs): Create tcc_vl_exp case for CALL_EXPR.
* tree-gimple.c (is_gimple_call_addr): Fix doc.
(recalculate_side_effects): Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH. Add tcc_vl_exp case.
* tree-chrec.c (chrec_contains_symbols): Use TREE_OPERAND_LENGTH
and generalize to handle any number of operands.
(chrec_contains_undetermined): Likewise.
(tree_contains_chrecs): Likewise.
(evolution_function_is_invariant_rec_p): Use TREE_OPERAND_LENGTH.
* cgraphunit.c (update_call_expr): Use new CALL_EXPR accessors.
* tree-ssa-ccp.c (ccp_fold): Use new CALL_EXPR accessors. Use
fold_call_expr instead of fold_builtin.
(ccp_fold_builtin): Likewise. Update calls into builtins.c to
match declarations there.
(fold_stmt): Use new CALL_EXPR constructor and accessors. Doc
updates.
* tree-ssa-loop-ivopts.c (expr_invariant_in_loop_p): Use
TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
* ipa-pure-const.c (check_call): Use new CALL_EXPR accessors.
(scan_function): Add case tcc_vl_exp for CALL_EXPR.
* tree-stdarg.c (execute_optimize_stdarg): Use new CALL_EXPR
accessors.
* tree-ssa-math-opts.c (execute_cse_sincos_1): Use build_call_expr.
(execute_cse_sincos): Use new CALL_EXPR accessors.
* tree-ssa-alias.c (find_used_portions): Use new CALL_EXPR iterator.
* gimple-low.c (lower_function_body): Use build_call_expr.
(lower_builtin_setjmp): Likewise.
* expr.c (emit_block_move_via_libcall): Use build_call_expr.
(set_storage_via_libcall): Likewise.
(safe_from_p): Add tcc_vl_exp case. Use TREE_OPERAND_LENGTH
instead of TREE_CODE_LENGTH.
(expand_expr_real_1): Use new CALL_EXPR accessors.
* tree-browser.c (store_child_info): Use TREE_OPERAND_LENGTH and
generalize to handle any number of operands.
(TB_parent_eq): Likewise.
* predict.c (expr_expected_value): Use new CALL_EXPR accessors.
(strip_builtin_expect): Likewise.
* function.c (gimplify_parameters): Use build_call_expr.
* tree-vectorizer.c (vect_is_simple_reduction): Use TREE_OPERAND_LENGTH
instead of TREE_CODE_LENGTH.
* ipa-type-escape.c (check_call): Use new CALL_EXPR iterators.
(scan_for_refs): Add case tcc_vl_exp for CALL_EXPR.
* tree-data-ref.c (get_references_in_stmt): Use new CALL_EXPR
iterators.
* gimplify.c (build_stack_save_restore): Use build_call_expr.
(gimplify_decl_expr): Likewise.
(gimplify_call_expr): Use fold_call_expr instead of fold_builtin.
Use new CALL_EXPR iterators.
(gimplify_modify_expr_to_memcpy): Use build_call_expr.
(gimplify_modify_expr_to_memset): Likewise.
(gimplify_variable_sized_compare): Likewise.
(gimplify_omp_atomic_fetch_op): Likewise.
(gimplify_omp_atomic_pipeline): Likewise.
(gimplify_omp_atomic_mutex): Likewise.
(gimplify_function_tree): Likewise.
* calls.c (alloca_call_p): Use new CALL_EXPR accessors.
(call_expr_flags): Likewise.
(expand_call): Likewise.
* except.c (expand_builtin_eh_return_data_regno): Pass entire
CALL_EXPR as parameter instead of arglist. Use new CALL_EXPR
accessors.
* coverage.c (create_coverage): Use build_call_expr.
* tree-ssa-pre.c (expression_node_pool, list_node_pool): Delete.
(temp_call_expr_obstack): New.
(pool_copy_list): Delete.
(temp_copy_call_expr): New.
(phi_translate): Add case tcc_vl_exp for CALL_EXPR. Use new
CALL_EXPR accessors. Get rid of special goo for copying argument
lists and use temp_copy_call_expr instead.
(valid_in_sets): Add case tcc_vl_exp for CALL_EXPR. Use new
CALL_EXPR accessors.
(create_expression_by_pieces): Likewise. Use build_call_array
to construct the result instead of fold_build3.
(create_value_expr_from): Add tcc_vl_exp. Delete special goo for
dealing with argument lists.
(init_pre): Remove references to expression_node_pool and
list_node_pool. Init temp_call_expr_obstack instead.
(fini_pre): Remove references to expression_node_pool and
list_node_pool.
* tree-sra.c (sra_walk_call_expr): Use new CALL_EXPR accessors
and walk arguments explicitly instead of as a list.
* tree-mudflap.c (mf_build_check_statement_for): Use build_call_expr.
(mx_register_decls): Likewise.
(mudflap_register_call): Likewise.
(mudflap_finish_file): Likewise.
* ipa-prop.c (ipa_callsite_compute_count): Use new CALL_EXPR accessors.
(ipa_callsite_compute_param): Likewise.
* tree-vect-patterns.c (vect_recog_pow_pattern): Use new CALL_EXPR
accessors and constructor.
* tree-nested.c (convert_nl_goto_reference): Use new CALL_EXPR
accessors and constructor.
(convert_tramp_reference): Likewise.
(convert_call_expr): Likewise.
(finalize_nesting_tree_1): Likewise.
* tree-ssa.c (tree_ssa_useless_type_conversion): Use new CALL_EXPR
accessors.
* tree-ssa-loop-prefetch.c (issue_prefetch_ref): Use build_call_expr.
* tree-inline.c (initialize_inlined_parameters): Pass entire
CALL_EXPR as parameter instead of arglist. Use new CALL_EXPR
accessors.
(estimate_num_insns_1): Use new CALL_EXPR accessors.
(expand_call_inline): Tidy up call to initialize_inlined_parameters.
* tree-vect-transform.c (vect_create_epilog_for_reduction): Use
TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
(vectorizable_reduction): Likewise.
(vectorizable_call): Use new CALL_EXPR iterators.
(vectorizable_conversion): Use build_call_expr.
(vectorizable_operation): Use TREE_OPERAND_LENGTH.
(vect_gen_widened_results_half): Use build_call_expr.
(vect_setup_realignment): Likewise.
(vectorizable_live_operation): Use TREE_OPERAND_LENGTH.
* tree-object-size.c (alloc_object_size): Use new CALL_EXPR accessors.
(pass_through_call): Likewise.
(compute_object_sizes): Likewise. Use fold_call_expr instead of
fold_builtin.
* tree-profile.c (tree_gen_interval_profiler): Use build_call_expr.
(tree_gen_pow2_profiler): Likewise.
(tree_gen_one_value_profiler): Likewise.
(tree_gen_ic_func_profiler): Likewise.
(tree_gen_average_profiler): Likewise.
(tree_gen_ior_profiler): Likewise.
* tree-ssa-structalias.c (get_constraint_for): Add case tcc_vl_exp.
(find_func_aliases): Use new CALL_EXPR accessors. Add case
tcc_vl_exp. Use TREE_OPERAND_LENGTH instead of TREE_CODE_LENGTH.
* tree-ssa-reassoc.c (get_rank): Use TREE_OPERAND_LENGTH instead
of TREE_CODE_LENGTH.
* stmt.c (warn_if_unused_value): Use TREE_OPERAND_LENGTH instead
of TREE_CODE_LENGTH.
* convert.c (convert_to_real): Use new CALL_EXPR accessors and
constructor.
(convert_to_integer): Likewise.
* tree-ssa-operands.c (get_call_expr_operands): Use new CALL_EXPR
accessors.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* config/alpha/alpha.c (alpha_expand_builtin): Use new CALL_EXPR
accessors.
* config/frv/frv.c (frv_expand_builtin): Likewise.
* config/s390/s390.c (s390_expand_builtin): Likewise.
* config/sparc/sparc.c (sparc_gimplify_va_arg): Use build_call_expr.
(sparc_expand_builtin): Use new CALL_EXPR accessors.
* config/i386/i386.c (ix86_function_ok_for_sibcall): Likewise.
(ix86_expand_binop_builtin): Pass entire CALL_EXPR as parameter
instead of arglist. Use new CALL_EXPR accessors on it. Fix callers.
(ix86_expand_store_builtin): Likewise.
(ix86_expand_unop_builtin): Likewise.
(ix86_expand_unop1_builtin): Likewise.
(ix86_expand_sse_compare): Likewise.
(ix86_expand_sse_comi): Likewise.
(ix86_expand_vec_init_builtin): Likewise.
(ix86_expand_vec_ext_builtin): Likewise.
(ix86_expand_vec_set_builtin): Likewise.
(ix86_expand_builtin): Use new CALL_EXPR accessors.
* config/sh/sh.c (sh_expand_builtin): Use new CALL_EXPR accessors.
* config/c4x/c4x.c (c4x_expand_builtin): Likewise.
* config/iq2000/iq2000.c (expand_one_builtin): Pass entire CALL_EXPR
instead of arglist. Use new CALL_EXPR accessors. Fix callers.
(iq2000_expand_builtin): Use new CALL_EXPR accessors.
* config/rs6000/rs6000-c.c (altivec_build_resolved_builtin): Use
build_call_expr.
* config/rs6000/rs6000.c (rs6000_gimplify_va_arg): Likewise.
(rs6000_expand_unop_builtin): Pass entire CALL_EXPR instead of
arglist. Use new CALL_EXPR accessors. Fix callers.
(altivec_expand_abs_builtin): Likewise.
(rs6000_expand_binop_builtin): Likewise.
(altivec_expand_predicate_builtin): Likewise.
(altivec_expand_lv_builtin): Likewise.
(spe_expand_stv_builtin): Likewise.
(altivec_expand_stv_builtin): Likewise.
(rs6000_expand_ternop_builtin): Likewise.
(altivec_expand_ld_builtin): Use new CALL_EXPR accessors.
(altivec_expand_st_builtin): Likewise.
(altivec_expand_dst_builtin): Likewise.
(altivec_expand_vec_init_builtin): Pass entire CALL_EXPR instead of
arglist. Use new CALL_EXPR accessors. Fix callers.
(altivec_expand_vec_set_builtin): Likewise.
(altivec_expand_vec_ext_builtin): Likewise.
(altivec_expand_builtin): Use new CALL_EXPR accessors.
(spe_expand_builtin): Likewise.
(spe_expand_predicate_builtin): Pass entire CALL_EXPR instead of
arglist. Use new CALL_EXPR accessors. Fix callers.
(spe_expand_evsel_builtin): Likewise.
(rs6000_expand_builtin): Use new CALL_EXPR accessors. VCFUX and
FCFSX cases must construct whole new CALL_EXPR, not just arglist.
* config/arm/arm.c (arm_expand_binop_builtin): Pass entire CALL_EXPR
instead of arglist. Use new CALL_EXPR accessors. Fix callers.
(arm_expand_unop_builtin): Likewise.
(arm_expand_builtin): Use new CALL_EXPR accessors.
* config/mips/mips.c (mips_expand_builtin): Use new CALL_EXPR
accessors.
* config/bfin/bfin.c (bfin_expand_binop_builtin): Pass entire CALL_EXPR
instead of arglist. Use new CALL_EXPR accessors. Fix callers.
(bfin_expand_unop_builtin): Likewise.
(bfin_expand_builtin): Use new CALL_EXPR accessors.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* c-semantics.c (build_stmt): Add internal diagnostic check.
* c-pretty-print.c (pp_c_postfix_expression): Use new CALL_EXPR
accessors. Print arguments explicitly instead of as a list.
* c-typeck.c (build_function_call): Use new CALL_EXPR constructors.
* c-omp.c (c_finish_omp_barrier): Use build_call_expr.
(c_finish_omp_flish): Likewise.
* c-common.c (verify_tree): Use new CALL_EXPR accessors. Traverse
arguments explicitly instead of as a list. Use TREE_OPERAND_LENGTH
instead of TREE_CODE_LENGTH.
(check_function_arguments_recurse): Use new CALL_EXPR accessors.
(c_warn_unused_result): Likewise.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* cp-tree.def (AGGR_INIT_EXPR): Adjust documentation.
Change class to tcc_vl_exp.
* call.c (build_call): Use build_call_list instead
of build3.
(build_over_call): Likewise.
(build_new_method_call): Use build_min_non_dep_call_list
instead of build_min_non_dep.
* error.c (dump_call_expr_args): New function.
(dump_aggr_init_expr_args): New function.
(dump_expr) <AGGR_INIT_EXPR, CALL_EXPR, INDIRECT_REF>: Use them.
Update to use new CALL_EXPR and AGGR_INIT_EXPR accessor macros.
* cvt.c (convert_to_void): Use build_call_array instead
of build3; use new AGGR_INIT_EXPR accessor macros.
* mangle.c (write_expression): Use TREE_OPERAND_LENGTH
instead of TREE_CODE_LENGTH.
* dump.c (cp_dump_tree) <AGGR_INIT_EXPR>: Update to use new
AGGR_INIT_EXPR accessor macros.
* cp-gimplify.c (cp_gimplify_init_expr): Use
AGGR_INIT_EXPR_SLOT to set the slot operand.
* cp-tree.h (AGGR_INIT_EXPR_FN): New macro.
(AGGR_INIT_EXPR_SLOT): New macro.
(AGGR_INIT_EXPR_ARG): New macro.
(aggr_init_expr_nargs): New macro.
(AGGR_INIT_EXPR_ARGP): New macro.
(aggr_init_expr_arg_iterator): New.
(init_aggr_init_expr_arg_iterator): New.
(next_aggr_init_expr_arg): New.
(first_aggr_init_expr_arg): New.
(more_aggr_init_expr_args_p): New.
(FOR_EACH_AGGR_INIT_EXPR_ARG): New.
(stabilize_aggr_init): New declaration.
(build_min_non_dep_call_list): Likewise.
* tree.c (process_aggr_init_operands): New function.
(build_aggr_init_array) New function.
(build_cplus_new): Update to use new CALL_EXPR and
AGGR_INIT_EXPR accessor macros. Replace use of build3 with
build_aggr_init_array.
(build_min_non_dep_call_list) New function.
(build_min_nt): Assert input code parameter is not a variable
length expression class.
(build_min, build_min_non_dep): Likewise.
(cp_tree_equal) <CALL_EXPR>: Iterate through the arguments
to check for equality instead of recursing. Handle tcc_vl_exp
tree code classes.
(stabilize_call): Update to only handle CALL_EXPRs, not
AGGR_INIT_EXPRs; use new CALL_EXPR accessor macros.
(stabilize_aggr_init): New function.
(stabilize_init): Use it.
* cxx-pretty-print.c (pp_cxx_postfix_expression)
<AGGR_INIT_EXPR, CALL_EXPR>: Update to use new CALL_EXPR and
AGGR_INIT_EXPR accessor macros and argument iterators.
* pt.c (tsubst_copy) <CALL_EXPR>: Replace build_nt with
build_vl_exp. Iterate through the operands, recursively
processing each one.
(tsubst_copy_and_build) <CALL_EXPR>: Update to use new
CALL_EXPR accessor macros.
(value_dependent_expression_p) <default>: Handle tcc_vl_exp
tree code classes. Use TREE_OPERAND_LENGTH instead of
TREE_CODE_LENGTH.
* semantics.c (finish_call_expr): Use build_nt_call_list
instead of build_nt.
(simplify_aggr_init_expr): Update to use new AGGR_INIT_EXPR
accessor macros. Use build_call_array to construct the
CALL_EXPR node instead of build3
* decl2.c (build_offset_ref_call_from_tree): Use
build_nt_call_list and build_min_non_dep_call_list instead
of build_min_nt and build_min_non_dep.
* parser.c (cp_parser_postfix_expression) <CPP_OPEN_PAREN>:
Use build_nt_call_list instead of build_min_nt.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* java-tree.h (BUILD_MONITOR_ENTER): Use build_call_nary instead
of build3.
(BUILD_MONITOR_EXIT): Likewise.
* java-gimplify.c (java_gimplify_component_ref): Use build_call_expr.
(java_gimplify_modify_expr): Likewise.
* class.c (cache_this_class_ref): Use build_call_expr.
(build_static_field_ref): Likewise.
(emit_indirect_register_classes): Likewise.
(emit_register_classes): Likewise.
* resource.c (write_resource_constructor): Use build_call_expr.
* builtins.c (builtin_creator_function): Change interpretation of
the second parameter to be the whole CALL_EXPR instead of the arglist.
(max_builtin): Tweak parameter list. Use new CALL_EXPR accessors.
(min_builtin): Likewise.
(abs_builtin): Likewise.
(java_build_function_call_expr): Likewise.
(convert_real): Likewise.
(UNMARSHAL3): Likewise.
(UNMARSHAL4): Likewise.
(UNMARSHAL5): Likewise.
(build_arglist_for_builtin): Delete. Fix callers to use
build_call_expr instead.
(putObject_builtin): Tweak parameter list. Use new CALL_EXPR
accessors.
(compareAndSwapInt_builtin): Likewise.
(compareAndSwapLong_builtin): Likewise.
(compareAndSwapObject_builtin): Likewise.
(putVolatile_builtin): Likewise.
(getVolatile_builtin): Likewise.
(VMSupportsCS8_builtin): Likewise.
(check_for_builtin): Pass entire CALL_EXPR to builtin expander
instead of arglist.
* expr.c (build_java_athrow): Use build_call_nary instead of build3.
(build_java_throw_out_of_bounds_exception): Likewise.
(java_check_reference): Likewise.
(build_java_arraystore_check): Likewise.
(build_newarray): Likewise.
(build_anewarray): Likewise.
(expand_java_multinewarray): Use build_call_list instead of build3.
(build_java_monitor): Use build_call_nary instead of build3.
(java_create_object): Likewise.
(expand_java_NEW): Likewise.
(build_instanceof): Likewise.
(expand_java_CHECKCAST): Likewise.
(build_java_soft_divmod): Likewise.
(build_java_binop): Likewise.
(build_field_ref): Likewise.
(build_class_init): Likewise.
(rewrite_arglist_getcaller): Use build_call_expr.
(build_invokeinterface): Use build_call_nary instead of build3.
(expand_invoke): Use build_call_list instead of build3.
(build_jni_stub): Use build_call_nary, build_call_list, or
build_call_expr instead of build3.
(expand_java_field_op): Use build_call_expr instead of build3.
(force_evaluation_order): Use new CALL_EXPR accessors.
* lang.c (java_get_callee_fndecl): Use new CALL_EXPR accessors.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* objc-act.c (receiver_is_class_object): Use new CALL_EXPR accessors.
(objc_get_callee_fndecl): Likewise.
2007-02-15 Sandra Loosemore <sandra@codesourcery.com>
Brooks Moses <brooks.moses@codesourcery.com>
Lee Millward <lee.millward@codesourcery.com>
* trans-expr.c (gfc_conv_power_op): Use build_call_expr.
(gfc_conv_string_tmp): Likewise.
(gfc_conv_concat_op): Likewise.
(gfc_build_compare_string): Likewise.
(gfc_conv_function_call): Use build_call_list instead of build3.
* trans-array.c (gfc_trans_allocate_array_storage): Use
build_call_expr.
(gfc_grow_array): Likewise.
(gfc_trans_array_ctor_element): Likewise.
(gfc_trans_array_constructor_value): Likewise.
(gfc_array_allocate): Likewise.
(gfc_array_deallocate): Likewise.
(gfc_trans_auto_array_allocation): Likewise.
(gfc_trans_dummy_array_bias): Likewise.
(gfc_conv_array_parameter): Likewise.
(gfc_trans_dealloc_allocated): Likewise.
(gfc_duplicate_allocatable): Likewise.
* trans-openmp.c (gfc_trans_omp_barrier): Use build_call_expr.
(gfc_trans_omp_flush): Likewise.
* trans-stmt.c (gfc_conv_elementel_dependencies): Use build_call_expr.
(gfc_trans_pause): Likewise.
(gfc_trans_stop): Likewise.
(gfc_trans_character_select): Likewise.
(gfc_do_allocate): Likewise.
(gfc_trans_assign_need_temp): Likewise.
(gfc_trans_pointer_assign_need_temp): Likewise.
(gfc_trans_forall_1): Likewise.
(gfc_trans_where_2): Likewise.
(gfc_trans_allocate): Likewise.
(gfc_trans_deallocate): Likewise.
* trans.c (gfc_trans_runtime_check): Use build_call_expr.
* trans-io.c (gfc_trans_open): Use build_call_expr.
(gfc_trans_close): Likewise.
(build_filepos): Likewise.
(gfc_trans_inquire): Likewise.
(NML_FIRST_ARG): Delete.
(NML_ADD_ARG): Delete.
(transfer_namelist_element): Use build_call_expr.
(build_dt): Likewise.
(gfc_trans_dt_end): Likewise.
(transfer_expr): Likewise.
(transfer_array-desc): Likewise.
* trans-decl.c (gfc_generate_function_code): Use build_call_expr.
(gfc_generate_constructors): Likewise.
* trans-intrinsic.c (gfc_conv_intrinsic_ctime): Use build_call_expr.
(gfc_conv_intrinsic_fdate): Likewise.
(gfc_conv_intrinsic_ttynam): Likewise.
(gfc_conv_intrinsic_array_transfer): Likewise.
(gfc_conv_associated): Likewise.
(gfc_conv_intrinsic_si_kind): Likewise.
(gfc_conv_intrinsic_trim): Likewise.
(gfc_conv_intrinsic_repeat: Likewise.
(gfc_conv_intrinsic_iargc): Likewise.
Co-Authored-By: Brooks Moses <brooks.moses@codesourcery.com>
Co-Authored-By: Lee Millward <lee.millward@codesourcery.com>
From-SVN: r122018
2007-02-16 00:50:49 +01:00
|
|
|
TREE_OPERAND (CALL_EXPR_FN (get_call_expr_in (cs->call_stmt)),
|
|
|
|
0) =
|
2005-08-01 09:26:30 +02:00
|
|
|
orig_callee->decl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update all cfg basic blocks in NODE according to SCALE. */
|
|
|
|
static void
|
|
|
|
ipcp_update_bb_counts (struct cgraph_node *node, gcov_type scale)
|
|
|
|
{
|
|
|
|
basic_block bb;
|
|
|
|
|
|
|
|
FOR_ALL_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
|
|
|
|
bb->count = bb->count * scale / REG_BR_PROB_BASE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update all cfg edges in NODE according to SCALE. */
|
|
|
|
static void
|
|
|
|
ipcp_update_edges_counts (struct cgraph_node *node, gcov_type scale)
|
|
|
|
{
|
|
|
|
basic_block bb;
|
|
|
|
edge_iterator ei;
|
|
|
|
edge e;
|
|
|
|
|
|
|
|
FOR_ALL_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
|
e->count = e->count * scale / REG_BR_PROB_BASE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update profiling info for versioned methods and the
|
|
|
|
methods they were versioned from. */
|
|
|
|
static void
|
|
|
|
ipcp_update_profiling (void)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node, *orig_node;
|
|
|
|
gcov_type scale, scale_complement;
|
|
|
|
struct cgraph_edge *cs;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
if (ipcp_method_is_cloned (node))
|
|
|
|
{
|
|
|
|
orig_node = ipcp_method_orig_node (node);
|
|
|
|
scale = ipcp_method_get_scale (orig_node);
|
|
|
|
node->count = orig_node->count * scale / REG_BR_PROB_BASE;
|
|
|
|
scale_complement = REG_BR_PROB_BASE - scale;
|
|
|
|
orig_node->count =
|
|
|
|
orig_node->count * scale_complement / REG_BR_PROB_BASE;
|
|
|
|
for (cs = node->callees; cs; cs = cs->next_callee)
|
|
|
|
cs->count = cs->count * scale / REG_BR_PROB_BASE;
|
|
|
|
for (cs = orig_node->callees; cs; cs = cs->next_callee)
|
|
|
|
cs->count = cs->count * scale_complement / REG_BR_PROB_BASE;
|
|
|
|
ipcp_update_bb_counts (node, scale);
|
|
|
|
ipcp_update_bb_counts (orig_node, scale_complement);
|
|
|
|
ipcp_update_edges_counts (node, scale);
|
|
|
|
ipcp_update_edges_counts (orig_node, scale_complement);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Propagate the constant parameters found by ipcp_iterate_stage()
|
|
|
|
to the function's code. */
|
|
|
|
static void
|
|
|
|
ipcp_insert_stage (void)
|
|
|
|
{
|
|
|
|
struct cgraph_node *node, *node1 = NULL;
|
|
|
|
int i, const_param;
|
|
|
|
union parameter_info *cvalue;
|
2007-01-28 14:01:53 +01:00
|
|
|
VEC (cgraph_edge_p, heap) * redirect_callers;
|
2006-04-17 14:45:25 +02:00
|
|
|
varray_type replace_trees;
|
2005-08-01 09:26:30 +02:00
|
|
|
struct cgraph_edge *cs;
|
|
|
|
int node_callers, count;
|
|
|
|
tree parm_tree;
|
|
|
|
enum cvalue_type type;
|
|
|
|
struct ipa_replace_map *replace_param;
|
|
|
|
|
|
|
|
for (node = cgraph_nodes; node; node = node->next)
|
|
|
|
{
|
|
|
|
/* Propagation of the constant is forbidden in
|
|
|
|
certain conditions. */
|
2007-01-28 14:01:53 +01:00
|
|
|
if (!node->analyzed || ipcp_method_dont_insert_const (node))
|
2005-08-01 09:26:30 +02:00
|
|
|
continue;
|
|
|
|
const_param = 0;
|
|
|
|
count = ipa_method_formal_count (node);
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i));
|
|
|
|
if (ipcp_type_is_const (type))
|
|
|
|
const_param++;
|
|
|
|
}
|
|
|
|
if (const_param == 0)
|
|
|
|
continue;
|
|
|
|
VARRAY_GENERIC_PTR_INIT (replace_trees, const_param, "replace_trees");
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
{
|
|
|
|
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i));
|
|
|
|
if (ipcp_type_is_const (type))
|
|
|
|
{
|
|
|
|
cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
|
|
|
|
parm_tree = ipa_method_get_tree (node, i);
|
|
|
|
replace_param =
|
2007-01-28 14:01:53 +01:00
|
|
|
ipcp_replace_map_create (DECL_STRUCT_FUNCTION (node->decl),
|
|
|
|
type, parm_tree, cvalue);
|
2005-08-01 09:26:30 +02:00
|
|
|
VARRAY_PUSH_GENERIC_PTR (replace_trees, replace_param);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Compute how many callers node has. */
|
|
|
|
node_callers = 0;
|
|
|
|
for (cs = node->callers; cs != NULL; cs = cs->next_caller)
|
|
|
|
node_callers++;
|
2006-04-17 14:45:25 +02:00
|
|
|
redirect_callers = VEC_alloc (cgraph_edge_p, heap, node_callers);
|
2005-08-01 09:26:30 +02:00
|
|
|
for (cs = node->callers; cs != NULL; cs = cs->next_caller)
|
2006-04-17 14:45:25 +02:00
|
|
|
VEC_quick_push (cgraph_edge_p, redirect_callers, cs);
|
2005-08-01 09:26:30 +02:00
|
|
|
/* Redirecting all the callers of the node to the
|
|
|
|
new versioned node. */
|
|
|
|
node1 =
|
|
|
|
cgraph_function_versioning (node, redirect_callers, replace_trees);
|
2006-04-17 14:45:25 +02:00
|
|
|
VEC_free (cgraph_edge_p, heap, redirect_callers);
|
2005-08-01 09:26:30 +02:00
|
|
|
VARRAY_CLEAR (replace_trees);
|
|
|
|
if (node1 == NULL)
|
|
|
|
continue;
|
|
|
|
if (dump_file)
|
|
|
|
fprintf (dump_file, "versioned function %s\n",
|
|
|
|
cgraph_node_name (node));
|
|
|
|
ipcp_cloned_create (node, node1);
|
2007-01-28 14:01:53 +01:00
|
|
|
if (const_param > 0)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
2007-01-28 14:01:53 +01:00
|
|
|
push_cfun (DECL_STRUCT_FUNCTION (node1->decl));
|
|
|
|
tree_register_cfg_hooks ();
|
|
|
|
current_function_decl = node1->decl;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
2005-08-01 09:26:30 +02:00
|
|
|
{
|
2007-01-28 14:01:53 +01:00
|
|
|
type = ipcp_cval_get_cvalue_type (ipcp_method_cval (node, i));
|
|
|
|
if (ipcp_type_is_const (type))
|
|
|
|
{
|
|
|
|
cvalue = ipcp_cval_get_cvalue (ipcp_method_cval (node, i));
|
|
|
|
parm_tree = ipa_method_get_tree (node, i);
|
|
|
|
if (type != CONST_VALUE_REF && !is_gimple_reg (parm_tree))
|
|
|
|
ipcp_propagate_const (node1, i, cvalue, type);
|
|
|
|
}
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
2007-01-28 14:01:53 +01:00
|
|
|
if (gimple_in_ssa_p (cfun))
|
|
|
|
{
|
|
|
|
update_ssa (TODO_update_ssa);
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
|
|
verify_ssa (true);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
free_dominance_info (CDI_DOMINATORS);
|
|
|
|
free_dominance_info (CDI_POST_DOMINATORS);
|
|
|
|
pop_cfun ();
|
|
|
|
current_function_decl = NULL;
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
2007-01-28 14:01:53 +01:00
|
|
|
if (dump_file)
|
|
|
|
dump_function_to_file (node1->decl, dump_file, dump_flags);
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
ipcp_update_callgraph ();
|
|
|
|
ipcp_update_profiling ();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The IPCP driver. */
|
2007-01-28 14:01:53 +01:00
|
|
|
static unsigned int
|
2005-08-01 09:26:30 +02:00
|
|
|
ipcp_driver (void)
|
|
|
|
{
|
|
|
|
if (dump_file)
|
|
|
|
fprintf (dump_file, "\nIPA constant propagation start:\n");
|
|
|
|
ipa_nodes_create ();
|
|
|
|
ipa_edges_create ();
|
|
|
|
/* 1. Call the init stage to initialize
|
|
|
|
the ipa_node and ipa_edge structures. */
|
|
|
|
ipcp_init_stage ();
|
|
|
|
if (dump_file)
|
|
|
|
{
|
|
|
|
fprintf (dump_file, "\nIPA structures before propagation:\n");
|
|
|
|
ipcp_structures_print (dump_file);
|
|
|
|
}
|
|
|
|
/* 2. Do the interprocedural propagation. */
|
|
|
|
ipcp_iterate_stage ();
|
|
|
|
if (dump_file)
|
|
|
|
{
|
|
|
|
fprintf (dump_file, "\nIPA structures after propagation:\n");
|
|
|
|
ipcp_structures_print (dump_file);
|
|
|
|
fprintf (dump_file, "\nProfiling info before insert stage:\n");
|
|
|
|
ipcp_profile_print (dump_file);
|
|
|
|
}
|
|
|
|
/* 3. Insert the constants found to the functions. */
|
|
|
|
ipcp_insert_stage ();
|
|
|
|
if (dump_file)
|
|
|
|
{
|
|
|
|
fprintf (dump_file, "\nProfiling info after insert stage:\n");
|
|
|
|
ipcp_profile_print (dump_file);
|
|
|
|
}
|
|
|
|
/* Free all IPCP structures. */
|
|
|
|
ipa_free ();
|
|
|
|
ipa_nodes_free ();
|
|
|
|
ipa_edges_free ();
|
|
|
|
if (dump_file)
|
|
|
|
fprintf (dump_file, "\nIPA constant propagation end\n");
|
|
|
|
cgraph_remove_unreachable_nodes (true, NULL);
|
2006-03-02 20:00:11 +01:00
|
|
|
return 0;
|
2005-08-01 09:26:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Gate for IPCP optimization. */
|
|
|
|
static bool
|
|
|
|
cgraph_gate_cp (void)
|
|
|
|
{
|
|
|
|
return flag_ipa_cp;
|
|
|
|
}
|
|
|
|
|
re PR other/35094 (RTL dump file letters hosed and partly undocumented)
* gcc.dg/20050811-2.c: Update dumping flags.
* gcc.dg/sms-2.c: Update dumping flags.
* gcc.dg/var-expand1.c: Update dumping flags.
* gcc.dg/var-expand3.c: Update dumping flags.
* gcc.dg/pr30957-1.c: Update dumping flags.
* gcc.dg/20050811-1.c: Update dumping flags.
* gcc.dg/cpp/cmdlne-dI-M.C: Do not xfail.
* gcc.dg/cpp/cmdlne-dM-M.C: Do not xfail.
PR other/35094
* toplev.c (decode_d_option): Handle all CPP flags.
* tree-vrp.c: Update tree_pass descriptors.
* regrename.c: Update tree_pass descriptors.
* fwprop.c: Update tree_pass descriptors.
* doc/invoke.texi: Remove documentation of dropped -d? flags.
* tree-into-ssa.c: Update tree_pass descriptors.
* tree-dump.c: Update tree_pass descriptors.
* tree-complex.c: Update tree_pass descriptors.
* tree-dump.h: Update tree_pass descriptors.
* see.c: Update tree_pass descriptors.
* cgraphbuild.c: Update tree_pass descriptors.
* tracer.c: Update tree_pass descriptors.
* tree-loop-distribution.c: Update tree_pass descriptors.
* cgraph.c: Update tree_pass descriptors.
* postreload-gcse.c: Update tree_pass descriptors.
* postreload.c: Update tree_pass descriptors.
* tree-ssa-loop-ch.c: Update tree_pass descriptors.
* tree-tailcall.c: Update tree_pass descriptors.
* tree-pass.h (tree_opt_pass): Rename to ...
(opt_pass) ... this one; add "type" field and remove letter field.
(gimple_opt_pass, rtl_opt_pass, simple_ipa_opt_pass): New.
(execute_pass_list, execute_ipa_pass_list, all_passes, all_ipa_passes,
all_lowering_passes): Update declaration.
* ipa-cp.c: Update tree_pass descriptors.
* final.c: Update tree_pass descriptors.
* omp-low.c: Update tree_pass descriptors.
* tree-ssa-dse.c: Update tree_pass descriptors.
* ipa-reference.c: Update tree_pass descriptors.
* tree-ssa-uncprop.c: Update tree_pass descriptors.
* auto-inc-dec.c: Update tree_pass descriptors.
* reorg.c: Update tree_pass descriptors.
* cgraphunit.c: Update tree_pass descriptors.
* tree-ssa-copyrename.c: Update tree_pass descriptors.
* tree-ssa-ccp.c: Update tree_pass descriptors.
* df-core.c: Update tree_pass descriptors.
* mode-switching.c: Update tree_pass descriptors.
* tree-nomudflap.c: Update tree_pass descriptors.
* modulo-sched.c: Update tree_pass descriptors.
* ipa-pure-const.c: Update tree_pass descriptors.
* cse.c: Update tree_pass descriptors.
* web.c: Update tree_pass descriptors.
* tree-stdarg.c: Update tree_pass descriptors.
* tree-ssa-math-opts.c: Update tree_pass descriptors.
* tree-ssa-dom.c: Update tree_pass descriptors.
* tree-nrv.c: Update tree_pass descriptors.
* tree-ssa-alias.c: Update tree_pass descriptors.
* loop-init.c: Update tree_pass descriptors.
* gimple-low.c: Update tree_pass descriptors.
* ipa-inline.c: Update tree_pass descriptors.
* tree-ssa-sink.c: Update tree_pass descriptors.
* global.c: Update tree_pass descriptors.
* ifcvt.c: Update tree_pass descriptors.
* jump.c: Update tree_pass descriptors.
* predict.c: Update tree_pass descriptors.
* tree-ssa-loop.c: Update tree_pass descriptors.
* recog.c: Update tree_pass descriptors.
* dse.c: Update tree_pass descriptors.
* tree-ssa-ifcombine.c: Update tree_pass descriptors.
* tree-eh.c: Update tree_pass descriptors.
* regmove.c: Update tree_pass descriptors.
* local-alloc.c
* function.c: Update tree_pass descriptors.
* tree-vectorizer.c: Update tree_pass descriptors.
* gcse.c: Update tree_pass descriptors.
* ipa-type-escape.c: Update tree_pass descriptors.
* tree-if-conv.c: Update tree_pass descriptors.
* init-regs.c: Update tree_pass descriptors.
* ipa.c: Update tree_pass descriptors.
* tree-ssa-phiopt.c: Update tree_pass descriptors.
* rtl-factoring.c: Update tree_pass descriptors.
* lower-subreg.c: Update tree_pass descriptors.
* bt-load.c: Update tree_pass descriptors.
* tree-dfa.c: Update tree_pass descriptors.
* except.c: Update tree_pass descriptors.
* emit-rtl.c: Update tree_pass descriptors.
* cfgexpand.c: Update tree_pass descriptors.
* tree-cfgcleanup.c: Update tree_pass descriptors.
* cfgcleanup.c: Update tree_pass descriptors.
* tree-ssa-pre.c: Update tree_pass descriptors.
* tree-sra.c: Update tree_pass descriptors.
* tree-mudflap.c: Update tree_pass descriptors.
* tree-ssa-copy.c: Update tree_pass descriptors.
* cfglayout.c: Update tree_pass descriptors.
* tree-ssa-forwprop.c: Update tree_pass descriptors.
* tree-ssa-dce.c: Update tree_pass descriptors.
* tree-ssa.c: Update tree_pass descriptors.
* regclass.c: Update tree_pass descriptors.
* integrate.c: Update tree_pass descriptors.
* tree-optimize.c: Update tree_pass descriptors.
* tree-ssa-phiprop.c: Update tree_pass descriptors.
* tree-object-size.c: Update tree_pass descriptors.
* combine.c: Update tree_pass descriptors.
* tree-outof-ssa.c: Update tree_pass descriptors.
* bb-reorder.c: Update tree_pass descriptors.
* stack-ptr-mod.c: Update tree_pass descriptors.
* var-tracking.c: Update tree_pass descriptors.
* tree-profile.c: Update tree_pass descriptors.
* tree-vect-generic.c: Update tree_pass descriptors.
* reg-stack.c: Update tree_pass descriptors.
* sched-rgn.c: Update tree_pass descriptors.
* tree-ssa-structalias.c: Update tree_pass descriptors.
* tree-cfg.c: Update tree_pass descriptors.
* passes.c (current_pass): Update declaration.
(finish_optimization_passes): Update.
(all_passes, all_ipa_passes, all_lowering_passes): Update declaration.
(register_one_dump_file, register_dump_files_1, next_pass_1):
Update arguments.
(init_optimization_passes): Update handling of new types.
(execute_one_pass, execute_pass_list, execute_ipa_pass_list): Update.
* ipa-struct-reorg.c: Update tree_pass descriptors.
* tree-ssa-reassoc.c: Update tree_pass descriptors.
* combine-stack-adj.c: Update tree_pass descriptors.
* cfgrtl.c: Update tree_pass descriptors.
* dce.c: Update tree_pass descriptors.
* tree-ssanames.c: Update tree_pass descriptors.
From-SVN: r133342
2008-03-19 12:22:40 +01:00
|
|
|
struct simple_ipa_opt_pass pass_ipa_cp =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
SIMPLE_IPA_PASS,
|
2005-08-01 09:26:30 +02:00
|
|
|
"cp", /* name */
|
|
|
|
cgraph_gate_cp, /* gate */
|
|
|
|
ipcp_driver, /* execute */
|
|
|
|
NULL, /* sub */
|
|
|
|
NULL, /* next */
|
|
|
|
0, /* static_pass_number */
|
|
|
|
TV_IPA_CONSTANT_PROP, /* tv_id */
|
|
|
|
0, /* properties_required */
|
|
|
|
PROP_trees, /* properties_provided */
|
|
|
|
0, /* properties_destroyed */
|
|
|
|
0, /* todo_flags_start */
|
re PR other/35094 (RTL dump file letters hosed and partly undocumented)
* gcc.dg/20050811-2.c: Update dumping flags.
* gcc.dg/sms-2.c: Update dumping flags.
* gcc.dg/var-expand1.c: Update dumping flags.
* gcc.dg/var-expand3.c: Update dumping flags.
* gcc.dg/pr30957-1.c: Update dumping flags.
* gcc.dg/20050811-1.c: Update dumping flags.
* gcc.dg/cpp/cmdlne-dI-M.C: Do not xfail.
* gcc.dg/cpp/cmdlne-dM-M.C: Do not xfail.
PR other/35094
* toplev.c (decode_d_option): Handle all CPP flags.
* tree-vrp.c: Update tree_pass descriptors.
* regrename.c: Update tree_pass descriptors.
* fwprop.c: Update tree_pass descriptors.
* doc/invoke.texi: Remove documentation of dropped -d? flags.
* tree-into-ssa.c: Update tree_pass descriptors.
* tree-dump.c: Update tree_pass descriptors.
* tree-complex.c: Update tree_pass descriptors.
* tree-dump.h: Update tree_pass descriptors.
* see.c: Update tree_pass descriptors.
* cgraphbuild.c: Update tree_pass descriptors.
* tracer.c: Update tree_pass descriptors.
* tree-loop-distribution.c: Update tree_pass descriptors.
* cgraph.c: Update tree_pass descriptors.
* postreload-gcse.c: Update tree_pass descriptors.
* postreload.c: Update tree_pass descriptors.
* tree-ssa-loop-ch.c: Update tree_pass descriptors.
* tree-tailcall.c: Update tree_pass descriptors.
* tree-pass.h (tree_opt_pass): Rename to ...
(opt_pass) ... this one; add "type" field and remove letter field.
(gimple_opt_pass, rtl_opt_pass, simple_ipa_opt_pass): New.
(execute_pass_list, execute_ipa_pass_list, all_passes, all_ipa_passes,
all_lowering_passes): Update declaration.
* ipa-cp.c: Update tree_pass descriptors.
* final.c: Update tree_pass descriptors.
* omp-low.c: Update tree_pass descriptors.
* tree-ssa-dse.c: Update tree_pass descriptors.
* ipa-reference.c: Update tree_pass descriptors.
* tree-ssa-uncprop.c: Update tree_pass descriptors.
* auto-inc-dec.c: Update tree_pass descriptors.
* reorg.c: Update tree_pass descriptors.
* cgraphunit.c: Update tree_pass descriptors.
* tree-ssa-copyrename.c: Update tree_pass descriptors.
* tree-ssa-ccp.c: Update tree_pass descriptors.
* df-core.c: Update tree_pass descriptors.
* mode-switching.c: Update tree_pass descriptors.
* tree-nomudflap.c: Update tree_pass descriptors.
* modulo-sched.c: Update tree_pass descriptors.
* ipa-pure-const.c: Update tree_pass descriptors.
* cse.c: Update tree_pass descriptors.
* web.c: Update tree_pass descriptors.
* tree-stdarg.c: Update tree_pass descriptors.
* tree-ssa-math-opts.c: Update tree_pass descriptors.
* tree-ssa-dom.c: Update tree_pass descriptors.
* tree-nrv.c: Update tree_pass descriptors.
* tree-ssa-alias.c: Update tree_pass descriptors.
* loop-init.c: Update tree_pass descriptors.
* gimple-low.c: Update tree_pass descriptors.
* ipa-inline.c: Update tree_pass descriptors.
* tree-ssa-sink.c: Update tree_pass descriptors.
* global.c: Update tree_pass descriptors.
* ifcvt.c: Update tree_pass descriptors.
* jump.c: Update tree_pass descriptors.
* predict.c: Update tree_pass descriptors.
* tree-ssa-loop.c: Update tree_pass descriptors.
* recog.c: Update tree_pass descriptors.
* dse.c: Update tree_pass descriptors.
* tree-ssa-ifcombine.c: Update tree_pass descriptors.
* tree-eh.c: Update tree_pass descriptors.
* regmove.c: Update tree_pass descriptors.
* local-alloc.c
* function.c: Update tree_pass descriptors.
* tree-vectorizer.c: Update tree_pass descriptors.
* gcse.c: Update tree_pass descriptors.
* ipa-type-escape.c: Update tree_pass descriptors.
* tree-if-conv.c: Update tree_pass descriptors.
* init-regs.c: Update tree_pass descriptors.
* ipa.c: Update tree_pass descriptors.
* tree-ssa-phiopt.c: Update tree_pass descriptors.
* rtl-factoring.c: Update tree_pass descriptors.
* lower-subreg.c: Update tree_pass descriptors.
* bt-load.c: Update tree_pass descriptors.
* tree-dfa.c: Update tree_pass descriptors.
* except.c: Update tree_pass descriptors.
* emit-rtl.c: Update tree_pass descriptors.
* cfgexpand.c: Update tree_pass descriptors.
* tree-cfgcleanup.c: Update tree_pass descriptors.
* cfgcleanup.c: Update tree_pass descriptors.
* tree-ssa-pre.c: Update tree_pass descriptors.
* tree-sra.c: Update tree_pass descriptors.
* tree-mudflap.c: Update tree_pass descriptors.
* tree-ssa-copy.c: Update tree_pass descriptors.
* cfglayout.c: Update tree_pass descriptors.
* tree-ssa-forwprop.c: Update tree_pass descriptors.
* tree-ssa-dce.c: Update tree_pass descriptors.
* tree-ssa.c: Update tree_pass descriptors.
* regclass.c: Update tree_pass descriptors.
* integrate.c: Update tree_pass descriptors.
* tree-optimize.c: Update tree_pass descriptors.
* tree-ssa-phiprop.c: Update tree_pass descriptors.
* tree-object-size.c: Update tree_pass descriptors.
* combine.c: Update tree_pass descriptors.
* tree-outof-ssa.c: Update tree_pass descriptors.
* bb-reorder.c: Update tree_pass descriptors.
* stack-ptr-mod.c: Update tree_pass descriptors.
* var-tracking.c: Update tree_pass descriptors.
* tree-profile.c: Update tree_pass descriptors.
* tree-vect-generic.c: Update tree_pass descriptors.
* reg-stack.c: Update tree_pass descriptors.
* sched-rgn.c: Update tree_pass descriptors.
* tree-ssa-structalias.c: Update tree_pass descriptors.
* tree-cfg.c: Update tree_pass descriptors.
* passes.c (current_pass): Update declaration.
(finish_optimization_passes): Update.
(all_passes, all_ipa_passes, all_lowering_passes): Update declaration.
(register_one_dump_file, register_dump_files_1, next_pass_1):
Update arguments.
(init_optimization_passes): Update handling of new types.
(execute_one_pass, execute_pass_list, execute_ipa_pass_list): Update.
* ipa-struct-reorg.c: Update tree_pass descriptors.
* tree-ssa-reassoc.c: Update tree_pass descriptors.
* combine-stack-adj.c: Update tree_pass descriptors.
* cfgrtl.c: Update tree_pass descriptors.
* dce.c: Update tree_pass descriptors.
* tree-ssanames.c: Update tree_pass descriptors.
From-SVN: r133342
2008-03-19 12:22:40 +01:00
|
|
|
TODO_dump_cgraph | TODO_dump_func /* todo_flags_finish */
|
|
|
|
}
|
2005-08-01 09:26:30 +02:00
|
|
|
};
|