622e071e10
includes fixes for these 109 GCC PR's: 4520 13685 13983 17519 19505 20256 22209 22313 23454 24367 25211 25468 25519 25636 25636 26435 26504 26570 26719 26764 26881 26969 26983 26991 26991 26993 27075 27184 27226 27287 27287 27291 27334 27363 27428 27489 27490 27537 27558 27565 27566 27616 27639 27681 27697 27721 27724 27768 27793 27793 27795 27827 27878 27889 27893 28029 28075 28136 28148 28150 28162 28170 28187 28207 28207 28218 28221 28238 28243 28247 28257 28259 28267 28283 28286 28299 28386 28402 28403 28418 28473 28490 28493 28621 28634 28636 28649 28651 28677 28683 28726 28814 28825 28862 28900 28924 28946 28952 28960 28980 29006 29091 29119 29132 29154 29198 29230 29290 29323
549 lines
16 KiB
C
549 lines
16 KiB
C
/* Global, SSA-based optimizations using mathematical identities.
|
|
Copyright (C) 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation; either version 2, or (at your option) any
|
|
later version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301, USA. */
|
|
|
|
/* Currently, the only mini-pass in this file tries to CSE reciprocal
|
|
operations. These are common in sequences such as this one:
|
|
|
|
modulus = sqrt(x*x + y*y + z*z);
|
|
x = x / modulus;
|
|
y = y / modulus;
|
|
z = z / modulus;
|
|
|
|
that can be optimized to
|
|
|
|
modulus = sqrt(x*x + y*y + z*z);
|
|
rmodulus = 1.0 / modulus;
|
|
x = x * rmodulus;
|
|
y = y * rmodulus;
|
|
z = z * rmodulus;
|
|
|
|
We do this for loop invariant divisors, and with this pass whenever
|
|
we notice that a division has the same divisor multiple times.
|
|
|
|
Of course, like in PRE, we don't insert a division if a dominator
|
|
already has one. However, this cannot be done as an extension of
|
|
PRE for several reasons.
|
|
|
|
First of all, with some experiments it was found out that the
|
|
transformation is not always useful if there are only two divisions
|
|
hy the same divisor. This is probably because modern processors
|
|
can pipeline the divisions; on older, in-order processors it should
|
|
still be effective to optimize two divisions by the same number.
|
|
We make this a param, and it shall be called N in the remainder of
|
|
this comment.
|
|
|
|
Second, if trapping math is active, we have less freedom on where
|
|
to insert divisions: we can only do so in basic blocks that already
|
|
contain one. (If divisions don't trap, instead, we can insert
|
|
divisions elsewhere, which will be in blocks that are common dominators
|
|
of those that have the division).
|
|
|
|
We really don't want to compute the reciprocal unless a division will
|
|
be found. To do this, we won't insert the division in a basic block
|
|
that has less than N divisions *post-dominating* it.
|
|
|
|
The algorithm constructs a subset of the dominator tree, holding the
|
|
blocks containing the divisions and the common dominators to them,
|
|
and walk it twice. The first walk is in post-order, and it annotates
|
|
each block with the number of divisions that post-dominate it: this
|
|
gives information on where divisions can be inserted profitably.
|
|
The second walk is in pre-order, and it inserts divisions as explained
|
|
above, and replaces divisions by multiplications.
|
|
|
|
In the best case, the cost of the pass is O(n_statements). In the
|
|
worst-case, the cost is due to creating the dominator tree subset,
|
|
with a cost of O(n_basic_blocks ^ 2); however this can only happen
|
|
for n_statements / n_basic_blocks statements. So, the amortized cost
|
|
of creating the dominator tree subset is O(n_basic_blocks) and the
|
|
worst-case cost of the pass is O(n_statements * n_basic_blocks).
|
|
|
|
More practically, the cost will be small because there are few
|
|
divisions, and they tend to be in the same basic block, so insert_bb
|
|
is called very few times.
|
|
|
|
If we did this using domwalk.c, an efficient implementation would have
|
|
to work on all the variables in a single pass, because we could not
|
|
work on just a subset of the dominator tree, as we do now, and the
|
|
cost would also be something like O(n_statements * n_basic_blocks).
|
|
The data structures would be more complex in order to work on all the
|
|
variables in a single pass. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tm.h"
|
|
#include "flags.h"
|
|
#include "tree.h"
|
|
#include "tree-flow.h"
|
|
#include "real.h"
|
|
#include "timevar.h"
|
|
#include "tree-pass.h"
|
|
#include "alloc-pool.h"
|
|
#include "basic-block.h"
|
|
#include "target.h"
|
|
|
|
|
|
/* This structure represents one basic block that either computes a
|
|
division, or is a common dominator for basic block that compute a
|
|
division. */
|
|
struct occurrence {
|
|
/* The basic block represented by this structure. */
|
|
basic_block bb;
|
|
|
|
/* If non-NULL, the SSA_NAME holding the definition for a reciprocal
|
|
inserted in BB. */
|
|
tree recip_def;
|
|
|
|
/* If non-NULL, the MODIFY_EXPR for a reciprocal computation that
|
|
was inserted in BB. */
|
|
tree recip_def_stmt;
|
|
|
|
/* Pointer to a list of "struct occurrence"s for blocks dominated
|
|
by BB. */
|
|
struct occurrence *children;
|
|
|
|
/* Pointer to the next "struct occurrence"s in the list of blocks
|
|
sharing a common dominator. */
|
|
struct occurrence *next;
|
|
|
|
/* The number of divisions that are in BB before compute_merit. The
|
|
number of divisions that are in BB or post-dominate it after
|
|
compute_merit. */
|
|
int num_divisions;
|
|
|
|
/* True if the basic block has a division, false if it is a common
|
|
dominator for basic blocks that do. If it is false and trapping
|
|
math is active, BB is not a candidate for inserting a reciprocal. */
|
|
bool bb_has_division;
|
|
};
|
|
|
|
|
|
/* The instance of "struct occurrence" representing the highest
|
|
interesting block in the dominator tree. */
|
|
static struct occurrence *occ_head;
|
|
|
|
/* Allocation pool for getting instances of "struct occurrence". */
|
|
static alloc_pool occ_pool;
|
|
|
|
|
|
|
|
/* Allocate and return a new struct occurrence for basic block BB, and
|
|
whose children list is headed by CHILDREN. */
|
|
static struct occurrence *
|
|
occ_new (basic_block bb, struct occurrence *children)
|
|
{
|
|
struct occurrence *occ;
|
|
|
|
occ = bb->aux = pool_alloc (occ_pool);
|
|
memset (occ, 0, sizeof (struct occurrence));
|
|
|
|
occ->bb = bb;
|
|
occ->children = children;
|
|
return occ;
|
|
}
|
|
|
|
|
|
/* Insert NEW_OCC into our subset of the dominator tree. P_HEAD points to a
|
|
list of "struct occurrence"s, one per basic block, having IDOM as
|
|
their common dominator.
|
|
|
|
We try to insert NEW_OCC as deep as possible in the tree, and we also
|
|
insert any other block that is a common dominator for BB and one
|
|
block already in the tree. */
|
|
|
|
static void
|
|
insert_bb (struct occurrence *new_occ, basic_block idom,
|
|
struct occurrence **p_head)
|
|
{
|
|
struct occurrence *occ, **p_occ;
|
|
|
|
for (p_occ = p_head; (occ = *p_occ) != NULL; )
|
|
{
|
|
basic_block bb = new_occ->bb, occ_bb = occ->bb;
|
|
basic_block dom = nearest_common_dominator (CDI_DOMINATORS, occ_bb, bb);
|
|
if (dom == bb)
|
|
{
|
|
/* BB dominates OCC_BB. OCC becomes NEW_OCC's child: remove OCC
|
|
from its list. */
|
|
*p_occ = occ->next;
|
|
occ->next = new_occ->children;
|
|
new_occ->children = occ;
|
|
|
|
/* Try the next block (it may as well be dominated by BB). */
|
|
}
|
|
|
|
else if (dom == occ_bb)
|
|
{
|
|
/* OCC_BB dominates BB. Tail recurse to look deeper. */
|
|
insert_bb (new_occ, dom, &occ->children);
|
|
return;
|
|
}
|
|
|
|
else if (dom != idom)
|
|
{
|
|
gcc_assert (!dom->aux);
|
|
|
|
/* There is a dominator between IDOM and BB, add it and make
|
|
two children out of NEW_OCC and OCC. First, remove OCC from
|
|
its list. */
|
|
*p_occ = occ->next;
|
|
new_occ->next = occ;
|
|
occ->next = NULL;
|
|
|
|
/* None of the previous blocks has DOM as a dominator: if we tail
|
|
recursed, we would reexamine them uselessly. Just switch BB with
|
|
DOM, and go on looking for blocks dominated by DOM. */
|
|
new_occ = occ_new (dom, new_occ);
|
|
}
|
|
|
|
else
|
|
{
|
|
/* Nothing special, go on with the next element. */
|
|
p_occ = &occ->next;
|
|
}
|
|
}
|
|
|
|
/* No place was found as a child of IDOM. Make BB a sibling of IDOM. */
|
|
new_occ->next = *p_head;
|
|
*p_head = new_occ;
|
|
}
|
|
|
|
/* Register that we found a division in BB. */
|
|
|
|
static inline void
|
|
register_division_in (basic_block bb)
|
|
{
|
|
struct occurrence *occ;
|
|
|
|
occ = (struct occurrence *) bb->aux;
|
|
if (!occ)
|
|
{
|
|
occ = occ_new (bb, NULL);
|
|
insert_bb (occ, ENTRY_BLOCK_PTR, &occ_head);
|
|
}
|
|
|
|
occ->bb_has_division = true;
|
|
occ->num_divisions++;
|
|
}
|
|
|
|
|
|
/* Compute the number of divisions that postdominate each block in OCC and
|
|
its children. */
|
|
|
|
static void
|
|
compute_merit (struct occurrence *occ)
|
|
{
|
|
struct occurrence *occ_child;
|
|
basic_block dom = occ->bb;
|
|
|
|
for (occ_child = occ->children; occ_child; occ_child = occ_child->next)
|
|
{
|
|
basic_block bb;
|
|
if (occ_child->children)
|
|
compute_merit (occ_child);
|
|
|
|
if (flag_exceptions)
|
|
bb = single_noncomplex_succ (dom);
|
|
else
|
|
bb = dom;
|
|
|
|
if (dominated_by_p (CDI_POST_DOMINATORS, bb, occ_child->bb))
|
|
occ->num_divisions += occ_child->num_divisions;
|
|
}
|
|
}
|
|
|
|
|
|
/* Return whether USE_STMT is a floating-point division by DEF. */
|
|
static inline bool
|
|
is_division_by (tree use_stmt, tree def)
|
|
{
|
|
return TREE_CODE (use_stmt) == MODIFY_EXPR
|
|
&& TREE_CODE (TREE_OPERAND (use_stmt, 1)) == RDIV_EXPR
|
|
&& TREE_OPERAND (TREE_OPERAND (use_stmt, 1), 1) == def;
|
|
}
|
|
|
|
/* Return the LHS of a RDIV_EXPR that computes a reciprocal in type TYPE. */
|
|
static tree
|
|
get_constant_one (tree type)
|
|
{
|
|
tree scalar, cst;
|
|
int i;
|
|
|
|
gcc_assert (FLOAT_TYPE_P (type));
|
|
switch (TREE_CODE (type))
|
|
{
|
|
case REAL_TYPE:
|
|
return build_real (type, dconst1);
|
|
|
|
case VECTOR_TYPE:
|
|
scalar = build_real (TREE_TYPE (type), dconst1);
|
|
|
|
/* Create 'vect_cst_ = {cst,cst,...,cst}' */
|
|
cst = NULL_TREE;
|
|
for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
|
|
cst = tree_cons (NULL_TREE, scalar, cst);
|
|
|
|
return build_vector (type, cst);
|
|
|
|
default:
|
|
/* Complex operations have been split already. */
|
|
gcc_unreachable ();
|
|
}
|
|
}
|
|
|
|
/* Walk the subset of the dominator tree rooted at OCC, setting the
|
|
RECIP_DEF field to a definition of 1.0 / DEF that can be used in
|
|
the given basic block. The field may be left NULL, of course,
|
|
if it is not possible or profitable to do the optimization.
|
|
|
|
DEF_BSI is an iterator pointing at the statement defining DEF.
|
|
If RECIP_DEF is set, a dominator already has a computation that can
|
|
be used. */
|
|
|
|
static void
|
|
insert_reciprocals (block_stmt_iterator *def_bsi, struct occurrence *occ,
|
|
tree def, tree recip_def, int threshold)
|
|
{
|
|
tree type, new_stmt;
|
|
block_stmt_iterator bsi;
|
|
struct occurrence *occ_child;
|
|
|
|
if (!recip_def
|
|
&& (occ->bb_has_division || !flag_trapping_math)
|
|
&& occ->num_divisions >= threshold)
|
|
{
|
|
/* Make a variable with the replacement and substitute it. */
|
|
type = TREE_TYPE (def);
|
|
recip_def = make_rename_temp (type, "reciptmp");
|
|
new_stmt = build2 (MODIFY_EXPR, void_type_node, recip_def,
|
|
fold_build2 (RDIV_EXPR, type, get_constant_one (type),
|
|
def));
|
|
|
|
|
|
if (occ->bb_has_division)
|
|
{
|
|
/* Case 1: insert before an existing division. */
|
|
bsi = bsi_after_labels (occ->bb);
|
|
while (!bsi_end_p (bsi) && !is_division_by (bsi_stmt (bsi), def))
|
|
bsi_next (&bsi);
|
|
|
|
bsi_insert_before (&bsi, new_stmt, BSI_SAME_STMT);
|
|
}
|
|
else if (def_bsi && occ->bb == def_bsi->bb)
|
|
{
|
|
/* Case 2: insert right after the definition. Note that this will
|
|
never happen if the definition statement can throw, because in
|
|
that case the sole successor of the statement's basic block will
|
|
dominate all the uses as well. */
|
|
bsi_insert_after (def_bsi, new_stmt, BSI_NEW_STMT);
|
|
}
|
|
else
|
|
{
|
|
/* Case 3: insert in a basic block not containing defs/uses. */
|
|
bsi = bsi_after_labels (occ->bb);
|
|
bsi_insert_before (&bsi, new_stmt, BSI_SAME_STMT);
|
|
}
|
|
|
|
occ->recip_def_stmt = new_stmt;
|
|
}
|
|
|
|
occ->recip_def = recip_def;
|
|
for (occ_child = occ->children; occ_child; occ_child = occ_child->next)
|
|
insert_reciprocals (def_bsi, occ_child, def, recip_def, threshold);
|
|
}
|
|
|
|
|
|
/* Replace the division at USE_P with a multiplication by the reciprocal, if
|
|
possible. */
|
|
|
|
static inline void
|
|
replace_reciprocal (use_operand_p use_p)
|
|
{
|
|
tree use_stmt = USE_STMT (use_p);
|
|
basic_block bb = bb_for_stmt (use_stmt);
|
|
struct occurrence *occ = (struct occurrence *) bb->aux;
|
|
|
|
if (occ->recip_def && use_stmt != occ->recip_def_stmt)
|
|
{
|
|
TREE_SET_CODE (TREE_OPERAND (use_stmt, 1), MULT_EXPR);
|
|
SET_USE (use_p, occ->recip_def);
|
|
fold_stmt_inplace (use_stmt);
|
|
update_stmt (use_stmt);
|
|
}
|
|
}
|
|
|
|
|
|
/* Free OCC and return one more "struct occurrence" to be freed. */
|
|
|
|
static struct occurrence *
|
|
free_bb (struct occurrence *occ)
|
|
{
|
|
struct occurrence *child, *next;
|
|
|
|
/* First get the two pointers hanging off OCC. */
|
|
next = occ->next;
|
|
child = occ->children;
|
|
occ->bb->aux = NULL;
|
|
pool_free (occ_pool, occ);
|
|
|
|
/* Now ensure that we don't recurse unless it is necessary. */
|
|
if (!child)
|
|
return next;
|
|
else
|
|
{
|
|
while (next)
|
|
next = free_bb (next);
|
|
|
|
return child;
|
|
}
|
|
}
|
|
|
|
|
|
/* Look for floating-point divisions among DEF's uses, and try to
|
|
replace them by multiplications with the reciprocal. Add
|
|
as many statements computing the reciprocal as needed.
|
|
|
|
DEF must be a GIMPLE register of a floating-point type. */
|
|
|
|
static void
|
|
execute_cse_reciprocals_1 (block_stmt_iterator *def_bsi, tree def)
|
|
{
|
|
use_operand_p use_p;
|
|
imm_use_iterator use_iter;
|
|
struct occurrence *occ;
|
|
int count = 0, threshold;
|
|
|
|
gcc_assert (FLOAT_TYPE_P (TREE_TYPE (def)) && is_gimple_reg (def));
|
|
|
|
FOR_EACH_IMM_USE_FAST (use_p, use_iter, def)
|
|
{
|
|
tree use_stmt = USE_STMT (use_p);
|
|
if (is_division_by (use_stmt, def))
|
|
{
|
|
register_division_in (bb_for_stmt (use_stmt));
|
|
count++;
|
|
}
|
|
}
|
|
|
|
/* Do the expensive part only if we can hope to optimize something. */
|
|
threshold = targetm.min_divisions_for_recip_mul (TYPE_MODE (TREE_TYPE (def)));
|
|
if (count >= threshold)
|
|
{
|
|
for (occ = occ_head; occ; occ = occ->next)
|
|
{
|
|
compute_merit (occ);
|
|
insert_reciprocals (def_bsi, occ, def, NULL, threshold);
|
|
}
|
|
|
|
FOR_EACH_IMM_USE_SAFE (use_p, use_iter, def)
|
|
{
|
|
tree use_stmt = USE_STMT (use_p);
|
|
if (is_division_by (use_stmt, def))
|
|
replace_reciprocal (use_p);
|
|
}
|
|
}
|
|
|
|
for (occ = occ_head; occ; )
|
|
occ = free_bb (occ);
|
|
|
|
occ_head = NULL;
|
|
}
|
|
|
|
|
|
static bool
|
|
gate_cse_reciprocals (void)
|
|
{
|
|
return optimize && !optimize_size && flag_unsafe_math_optimizations;
|
|
}
|
|
|
|
|
|
/* Go through all the floating-point SSA_NAMEs, and call
|
|
execute_cse_reciprocals_1 on each of them. */
|
|
static void
|
|
execute_cse_reciprocals (void)
|
|
{
|
|
basic_block bb;
|
|
tree arg;
|
|
|
|
occ_pool = create_alloc_pool ("dominators for recip",
|
|
sizeof (struct occurrence),
|
|
n_basic_blocks / 3 + 1);
|
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
calculate_dominance_info (CDI_POST_DOMINATORS);
|
|
|
|
#ifdef ENABLE_CHECKING
|
|
FOR_EACH_BB (bb)
|
|
gcc_assert (!bb->aux);
|
|
#endif
|
|
|
|
for (arg = DECL_ARGUMENTS (cfun->decl); arg; arg = TREE_CHAIN (arg))
|
|
if (default_def (arg)
|
|
&& FLOAT_TYPE_P (TREE_TYPE (arg))
|
|
&& is_gimple_reg (arg))
|
|
execute_cse_reciprocals_1 (NULL, default_def (arg));
|
|
|
|
FOR_EACH_BB (bb)
|
|
{
|
|
block_stmt_iterator bsi;
|
|
tree phi, def;
|
|
|
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
|
{
|
|
def = PHI_RESULT (phi);
|
|
if (FLOAT_TYPE_P (TREE_TYPE (def))
|
|
&& is_gimple_reg (def))
|
|
execute_cse_reciprocals_1 (NULL, def);
|
|
}
|
|
|
|
for (bsi = bsi_after_labels (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|
|
{
|
|
tree stmt = bsi_stmt (bsi);
|
|
if (TREE_CODE (stmt) == MODIFY_EXPR
|
|
&& (def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF)) != NULL
|
|
&& FLOAT_TYPE_P (TREE_TYPE (def))
|
|
&& TREE_CODE (def) == SSA_NAME)
|
|
execute_cse_reciprocals_1 (&bsi, def);
|
|
}
|
|
}
|
|
|
|
free_dominance_info (CDI_DOMINATORS);
|
|
free_dominance_info (CDI_POST_DOMINATORS);
|
|
free_alloc_pool (occ_pool);
|
|
}
|
|
|
|
struct tree_opt_pass pass_cse_reciprocals =
|
|
{
|
|
"recip", /* name */
|
|
gate_cse_reciprocals, /* gate */
|
|
execute_cse_reciprocals, /* execute */
|
|
NULL, /* sub */
|
|
NULL, /* next */
|
|
0, /* static_pass_number */
|
|
0, /* tv_id */
|
|
PROP_ssa, /* properties_required */
|
|
0, /* properties_provided */
|
|
0, /* properties_destroyed */
|
|
0, /* todo_flags_start */
|
|
TODO_dump_func | TODO_update_ssa | TODO_verify_ssa
|
|
| TODO_verify_stmts, /* todo_flags_finish */
|
|
0 /* letter */
|
|
};
|