/* Forward propagation of expressions for single use variables.
|
/* Forward propagation of expressions for single use variables.
|
Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011
|
Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010, 2011
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "gimple-pretty-print.h"
|
#include "gimple-pretty-print.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "expr.h"
|
#include "expr.h"
|
|
|
/* This pass propagates the RHS of assignment statements into use
|
/* This pass propagates the RHS of assignment statements into use
|
sites of the LHS of the assignment. It's basically a specialized
|
sites of the LHS of the assignment. It's basically a specialized
|
form of tree combination. It is hoped all of this can disappear
|
form of tree combination. It is hoped all of this can disappear
|
when we have a generalized tree combiner.
|
when we have a generalized tree combiner.
|
|
|
One class of common cases we handle is forward propagating a single use
|
One class of common cases we handle is forward propagating a single use
|
variable into a COND_EXPR.
|
variable into a COND_EXPR.
|
|
|
bb0:
|
bb0:
|
x = a COND b;
|
x = a COND b;
|
if (x) goto ... else goto ...
|
if (x) goto ... else goto ...
|
|
|
Will be transformed into:
|
Will be transformed into:
|
|
|
bb0:
|
bb0:
|
if (a COND b) goto ... else goto ...
|
if (a COND b) goto ... else goto ...
|
|
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
|
|
Or (assuming c1 and c2 are constants):
|
Or (assuming c1 and c2 are constants):
|
|
|
bb0:
|
bb0:
|
x = a + c1;
|
x = a + c1;
|
if (x EQ/NEQ c2) goto ... else goto ...
|
if (x EQ/NEQ c2) goto ... else goto ...
|
|
|
Will be transformed into:
|
Will be transformed into:
|
|
|
bb0:
|
bb0:
|
if (a EQ/NEQ (c2 - c1)) goto ... else goto ...
|
if (a EQ/NEQ (c2 - c1)) goto ... else goto ...
|
|
|
Similarly for x = a - c1.
|
Similarly for x = a - c1.
|
|
|
Or
|
Or
|
|
|
bb0:
|
bb0:
|
x = !a
|
x = !a
|
if (x) goto ... else goto ...
|
if (x) goto ... else goto ...
|
|
|
Will be transformed into:
|
Will be transformed into:
|
|
|
bb0:
|
bb0:
|
if (a == 0) goto ... else goto ...
|
if (a == 0) goto ... else goto ...
|
|
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
For these cases, we propagate A into all, possibly more than one,
|
For these cases, we propagate A into all, possibly more than one,
|
COND_EXPRs that use X.
|
COND_EXPRs that use X.
|
|
|
Or
|
Or
|
|
|
bb0:
|
bb0:
|
x = (typecast) a
|
x = (typecast) a
|
if (x) goto ... else goto ...
|
if (x) goto ... else goto ...
|
|
|
Will be transformed into:
|
Will be transformed into:
|
|
|
bb0:
|
bb0:
|
if (a != 0) goto ... else goto ...
|
if (a != 0) goto ... else goto ...
|
|
|
(Assuming a is an integral type and x is a boolean or x is an
|
(Assuming a is an integral type and x is a boolean or x is an
|
integral and a is a boolean.)
|
integral and a is a boolean.)
|
|
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
Similarly for the tests (x == 0), (x != 0), (x == 1) and (x != 1).
|
For these cases, we propagate A into all, possibly more than one,
|
For these cases, we propagate A into all, possibly more than one,
|
COND_EXPRs that use X.
|
COND_EXPRs that use X.
|
|
|
In addition to eliminating the variable and the statement which assigns
|
In addition to eliminating the variable and the statement which assigns
|
a value to the variable, we may be able to later thread the jump without
|
a value to the variable, we may be able to later thread the jump without
|
adding insane complexity in the dominator optimizer.
|
adding insane complexity in the dominator optimizer.
|
|
|
Also note these transformations can cascade. We handle this by having
|
Also note these transformations can cascade. We handle this by having
|
a worklist of COND_EXPR statements to examine. As we make a change to
|
a worklist of COND_EXPR statements to examine. As we make a change to
|
a statement, we put it back on the worklist to examine on the next
|
a statement, we put it back on the worklist to examine on the next
|
iteration of the main loop.
|
iteration of the main loop.
|
|
|
A second class of propagation opportunities arises for ADDR_EXPR
|
A second class of propagation opportunities arises for ADDR_EXPR
|
nodes.
|
nodes.
|
|
|
ptr = &x->y->z;
|
ptr = &x->y->z;
|
res = *ptr;
|
res = *ptr;
|
|
|
Will get turned into
|
Will get turned into
|
|
|
res = x->y->z;
|
res = x->y->z;
|
|
|
Or
|
Or
|
ptr = (type1*)&type2var;
|
ptr = (type1*)&type2var;
|
res = *ptr
|
res = *ptr
|
|
|
Will get turned into (if type1 and type2 are the same size
|
Will get turned into (if type1 and type2 are the same size
|
and neither have volatile on them):
|
and neither have volatile on them):
|
res = VIEW_CONVERT_EXPR<type1>(type2var)
|
res = VIEW_CONVERT_EXPR<type1>(type2var)
|
|
|
Or
|
Or
|
|
|
ptr = &x[0];
|
ptr = &x[0];
|
ptr2 = ptr + <constant>;
|
ptr2 = ptr + <constant>;
|
|
|
Will get turned into
|
Will get turned into
|
|
|
ptr2 = &x[constant/elementsize];
|
ptr2 = &x[constant/elementsize];
|
|
|
Or
|
Or
|
|
|
ptr = &x[0];
|
ptr = &x[0];
|
offset = index * element_size;
|
offset = index * element_size;
|
offset_p = (pointer) offset;
|
offset_p = (pointer) offset;
|
ptr2 = ptr + offset_p
|
ptr2 = ptr + offset_p
|
|
|
Will get turned into:
|
Will get turned into:
|
|
|
ptr2 = &x[index];
|
ptr2 = &x[index];
|
|
|
Or
|
Or
|
ssa = (int) decl
|
ssa = (int) decl
|
res = ssa & 1
|
res = ssa & 1
|
|
|
Provided that decl has known alignment >= 2, will get turned into
|
Provided that decl has known alignment >= 2, will get turned into
|
|
|
res = 0
|
res = 0
|
|
|
We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to
|
We also propagate casts into SWITCH_EXPR and COND_EXPR conditions to
|
allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent
|
allow us to remove the cast and {NOT_EXPR,NEG_EXPR} into a subsequent
|
{NOT_EXPR,NEG_EXPR}.
|
{NOT_EXPR,NEG_EXPR}.
|
|
|
This will (of course) be extended as other needs arise. */
|
This will (of course) be extended as other needs arise. */
|
|
|
static bool forward_propagate_addr_expr (tree name, tree rhs);
|
static bool forward_propagate_addr_expr (tree name, tree rhs);
|
|
|
/* Set to true if we delete EH edges during the optimization. */
|
/* Set to true if we delete EH edges during the optimization. */
|
static bool cfg_changed;
|
static bool cfg_changed;
|
|
|
static tree rhs_to_tree (tree type, gimple stmt);
|
static tree rhs_to_tree (tree type, gimple stmt);
|
|
|
/* Get the next statement we can propagate NAME's value into skipping
|
/* Get the next statement we can propagate NAME's value into skipping
|
trivial copies. Returns the statement that is suitable as a
|
trivial copies. Returns the statement that is suitable as a
|
propagation destination or NULL_TREE if there is no such one.
|
propagation destination or NULL_TREE if there is no such one.
|
This only returns destinations in a single-use chain. FINAL_NAME_P
|
This only returns destinations in a single-use chain. FINAL_NAME_P
|
if non-NULL is written to the ssa name that represents the use. */
|
if non-NULL is written to the ssa name that represents the use. */
|
|
|
static gimple
|
static gimple
|
get_prop_dest_stmt (tree name, tree *final_name_p)
|
get_prop_dest_stmt (tree name, tree *final_name_p)
|
{
|
{
|
use_operand_p use;
|
use_operand_p use;
|
gimple use_stmt;
|
gimple use_stmt;
|
|
|
do {
|
do {
|
/* If name has multiple uses, bail out. */
|
/* If name has multiple uses, bail out. */
|
if (!single_imm_use (name, &use, &use_stmt))
|
if (!single_imm_use (name, &use, &use_stmt))
|
return NULL;
|
return NULL;
|
|
|
/* If this is not a trivial copy, we found it. */
|
/* If this is not a trivial copy, we found it. */
|
if (!gimple_assign_ssa_name_copy_p (use_stmt)
|
if (!gimple_assign_ssa_name_copy_p (use_stmt)
|
|| gimple_assign_rhs1 (use_stmt) != name)
|
|| gimple_assign_rhs1 (use_stmt) != name)
|
break;
|
break;
|
|
|
/* Continue searching uses of the copy destination. */
|
/* Continue searching uses of the copy destination. */
|
name = gimple_assign_lhs (use_stmt);
|
name = gimple_assign_lhs (use_stmt);
|
} while (1);
|
} while (1);
|
|
|
if (final_name_p)
|
if (final_name_p)
|
*final_name_p = name;
|
*final_name_p = name;
|
|
|
return use_stmt;
|
return use_stmt;
|
}
|
}
|
|
|
/* Get the statement we can propagate from into NAME skipping
|
/* Get the statement we can propagate from into NAME skipping
|
trivial copies. Returns the statement which defines the
|
trivial copies. Returns the statement which defines the
|
propagation source or NULL_TREE if there is no such one.
|
propagation source or NULL_TREE if there is no such one.
|
If SINGLE_USE_ONLY is set considers only sources which have
|
If SINGLE_USE_ONLY is set considers only sources which have
|
a single use chain up to NAME. If SINGLE_USE_P is non-null,
|
a single use chain up to NAME. If SINGLE_USE_P is non-null,
|
it is set to whether the chain to NAME is a single use chain
|
it is set to whether the chain to NAME is a single use chain
|
or not. SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set. */
|
or not. SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set. */
|
|
|
static gimple
|
static gimple
|
get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
|
get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
|
{
|
{
|
bool single_use = true;
|
bool single_use = true;
|
|
|
do {
|
do {
|
gimple def_stmt = SSA_NAME_DEF_STMT (name);
|
gimple def_stmt = SSA_NAME_DEF_STMT (name);
|
|
|
if (!has_single_use (name))
|
if (!has_single_use (name))
|
{
|
{
|
single_use = false;
|
single_use = false;
|
if (single_use_only)
|
if (single_use_only)
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* If name is defined by a PHI node or is the default def, bail out. */
|
/* If name is defined by a PHI node or is the default def, bail out. */
|
if (!is_gimple_assign (def_stmt))
|
if (!is_gimple_assign (def_stmt))
|
return NULL;
|
return NULL;
|
|
|
/* If def_stmt is not a simple copy, we possibly found it. */
|
/* If def_stmt is not a simple copy, we possibly found it. */
|
if (!gimple_assign_ssa_name_copy_p (def_stmt))
|
if (!gimple_assign_ssa_name_copy_p (def_stmt))
|
{
|
{
|
tree rhs;
|
tree rhs;
|
|
|
if (!single_use_only && single_use_p)
|
if (!single_use_only && single_use_p)
|
*single_use_p = single_use;
|
*single_use_p = single_use;
|
|
|
/* We can look through pointer conversions in the search
|
/* We can look through pointer conversions in the search
|
for a useful stmt for the comparison folding. */
|
for a useful stmt for the comparison folding. */
|
rhs = gimple_assign_rhs1 (def_stmt);
|
rhs = gimple_assign_rhs1 (def_stmt);
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))
|
&& TREE_CODE (rhs) == SSA_NAME
|
&& TREE_CODE (rhs) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (gimple_assign_lhs (def_stmt)))
|
&& POINTER_TYPE_P (TREE_TYPE (gimple_assign_lhs (def_stmt)))
|
&& POINTER_TYPE_P (TREE_TYPE (rhs)))
|
&& POINTER_TYPE_P (TREE_TYPE (rhs)))
|
name = rhs;
|
name = rhs;
|
else
|
else
|
return def_stmt;
|
return def_stmt;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Continue searching the def of the copy source name. */
|
/* Continue searching the def of the copy source name. */
|
name = gimple_assign_rhs1 (def_stmt);
|
name = gimple_assign_rhs1 (def_stmt);
|
}
|
}
|
} while (1);
|
} while (1);
|
}
|
}
|
|
|
/* Checks if the destination ssa name in DEF_STMT can be used as
|
/* Checks if the destination ssa name in DEF_STMT can be used as
|
propagation source. Returns true if so, otherwise false. */
|
propagation source. Returns true if so, otherwise false. */
|
|
|
static bool
|
static bool
|
can_propagate_from (gimple def_stmt)
|
can_propagate_from (gimple def_stmt)
|
{
|
{
|
gcc_assert (is_gimple_assign (def_stmt));
|
gcc_assert (is_gimple_assign (def_stmt));
|
|
|
/* If the rhs has side-effects we cannot propagate from it. */
|
/* If the rhs has side-effects we cannot propagate from it. */
|
if (gimple_has_volatile_ops (def_stmt))
|
if (gimple_has_volatile_ops (def_stmt))
|
return false;
|
return false;
|
|
|
/* If the rhs is a load we cannot propagate from it. */
|
/* If the rhs is a load we cannot propagate from it. */
|
if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_reference
|
if (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_reference
|
|| TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_declaration)
|
|| TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)) == tcc_declaration)
|
return false;
|
return false;
|
|
|
/* Constants can be always propagated. */
|
/* Constants can be always propagated. */
|
if (gimple_assign_single_p (def_stmt)
|
if (gimple_assign_single_p (def_stmt)
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
|
&& is_gimple_min_invariant (gimple_assign_rhs1 (def_stmt)))
|
return true;
|
return true;
|
|
|
/* We cannot propagate ssa names that occur in abnormal phi nodes. */
|
/* We cannot propagate ssa names that occur in abnormal phi nodes. */
|
if (stmt_references_abnormal_ssa_name (def_stmt))
|
if (stmt_references_abnormal_ssa_name (def_stmt))
|
return false;
|
return false;
|
|
|
/* If the definition is a conversion of a pointer to a function type,
|
/* If the definition is a conversion of a pointer to a function type,
|
then we can not apply optimizations as some targets require
|
then we can not apply optimizations as some targets require
|
function pointers to be canonicalized and in this case this
|
function pointers to be canonicalized and in this case this
|
optimization could eliminate a necessary canonicalization. */
|
optimization could eliminate a necessary canonicalization. */
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
|
{
|
{
|
tree rhs = gimple_assign_rhs1 (def_stmt);
|
tree rhs = gimple_assign_rhs1 (def_stmt);
|
if (POINTER_TYPE_P (TREE_TYPE (rhs))
|
if (POINTER_TYPE_P (TREE_TYPE (rhs))
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == FUNCTION_TYPE)
|
&& TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == FUNCTION_TYPE)
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Remove a chain of dead statements starting at the definition of
|
/* Remove a chain of dead statements starting at the definition of
|
NAME. The chain is linked via the first operand of the defining statements.
|
NAME. The chain is linked via the first operand of the defining statements.
|
If NAME was replaced in its only use then this function can be used
|
If NAME was replaced in its only use then this function can be used
|
to clean up dead stmts. The function handles already released SSA
|
to clean up dead stmts. The function handles already released SSA
|
names gracefully.
|
names gracefully.
|
Returns true if cleanup-cfg has to run. */
|
Returns true if cleanup-cfg has to run. */
|
|
|
static bool
|
static bool
|
remove_prop_source_from_use (tree name)
|
remove_prop_source_from_use (tree name)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple stmt;
|
gimple stmt;
|
bool cfg_changed = false;
|
bool cfg_changed = false;
|
|
|
do {
|
do {
|
basic_block bb;
|
basic_block bb;
|
|
|
if (SSA_NAME_IN_FREE_LIST (name)
|
if (SSA_NAME_IN_FREE_LIST (name)
|
|| SSA_NAME_IS_DEFAULT_DEF (name)
|
|| SSA_NAME_IS_DEFAULT_DEF (name)
|
|| !has_zero_uses (name))
|
|| !has_zero_uses (name))
|
return cfg_changed;
|
return cfg_changed;
|
|
|
stmt = SSA_NAME_DEF_STMT (name);
|
stmt = SSA_NAME_DEF_STMT (name);
|
if (gimple_code (stmt) == GIMPLE_PHI
|
if (gimple_code (stmt) == GIMPLE_PHI
|
|| gimple_has_side_effects (stmt))
|
|| gimple_has_side_effects (stmt))
|
return cfg_changed;
|
return cfg_changed;
|
|
|
bb = gimple_bb (stmt);
|
bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
unlink_stmt_vdef (stmt);
|
unlink_stmt_vdef (stmt);
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
release_defs (stmt);
|
release_defs (stmt);
|
cfg_changed |= gimple_purge_dead_eh_edges (bb);
|
cfg_changed |= gimple_purge_dead_eh_edges (bb);
|
|
|
name = is_gimple_assign (stmt) ? gimple_assign_rhs1 (stmt) : NULL_TREE;
|
name = is_gimple_assign (stmt) ? gimple_assign_rhs1 (stmt) : NULL_TREE;
|
} while (name && TREE_CODE (name) == SSA_NAME);
|
} while (name && TREE_CODE (name) == SSA_NAME);
|
|
|
return cfg_changed;
|
return cfg_changed;
|
}
|
}
|
|
|
/* Return the rhs of a gimple_assign STMT in a form of a single tree,
|
/* Return the rhs of a gimple_assign STMT in a form of a single tree,
|
converted to type TYPE.
|
converted to type TYPE.
|
|
|
This should disappear, but is needed so we can combine expressions and use
|
This should disappear, but is needed so we can combine expressions and use
|
the fold() interfaces. Long term, we need to develop folding and combine
|
the fold() interfaces. Long term, we need to develop folding and combine
|
routines that deal with gimple exclusively . */
|
routines that deal with gimple exclusively . */
|
|
|
static tree
|
static tree
|
rhs_to_tree (tree type, gimple stmt)
|
rhs_to_tree (tree type, gimple stmt)
|
{
|
{
|
location_t loc = gimple_location (stmt);
|
location_t loc = gimple_location (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
if (get_gimple_rhs_class (code) == GIMPLE_TERNARY_RHS)
|
if (get_gimple_rhs_class (code) == GIMPLE_TERNARY_RHS)
|
return fold_build3_loc (loc, code, type, gimple_assign_rhs1 (stmt),
|
return fold_build3_loc (loc, code, type, gimple_assign_rhs1 (stmt),
|
gimple_assign_rhs2 (stmt),
|
gimple_assign_rhs2 (stmt),
|
gimple_assign_rhs3 (stmt));
|
gimple_assign_rhs3 (stmt));
|
else if (get_gimple_rhs_class (code) == GIMPLE_BINARY_RHS)
|
else if (get_gimple_rhs_class (code) == GIMPLE_BINARY_RHS)
|
return fold_build2_loc (loc, code, type, gimple_assign_rhs1 (stmt),
|
return fold_build2_loc (loc, code, type, gimple_assign_rhs1 (stmt),
|
gimple_assign_rhs2 (stmt));
|
gimple_assign_rhs2 (stmt));
|
else if (get_gimple_rhs_class (code) == GIMPLE_UNARY_RHS)
|
else if (get_gimple_rhs_class (code) == GIMPLE_UNARY_RHS)
|
return build1 (code, type, gimple_assign_rhs1 (stmt));
|
return build1 (code, type, gimple_assign_rhs1 (stmt));
|
else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
|
else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
|
return gimple_assign_rhs1 (stmt);
|
return gimple_assign_rhs1 (stmt);
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Combine OP0 CODE OP1 in the context of a COND_EXPR. Returns
|
/* Combine OP0 CODE OP1 in the context of a COND_EXPR. Returns
|
the folded result in a form suitable for COND_EXPR_COND or
|
the folded result in a form suitable for COND_EXPR_COND or
|
NULL_TREE, if there is no suitable simplified form. If
|
NULL_TREE, if there is no suitable simplified form. If
|
INVARIANT_ONLY is true only gimple_min_invariant results are
|
INVARIANT_ONLY is true only gimple_min_invariant results are
|
considered simplified. */
|
considered simplified. */
|
|
|
static tree
|
static tree
|
combine_cond_expr_cond (gimple stmt, enum tree_code code, tree type,
|
combine_cond_expr_cond (gimple stmt, enum tree_code code, tree type,
|
tree op0, tree op1, bool invariant_only)
|
tree op0, tree op1, bool invariant_only)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
|
gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
|
|
|
fold_defer_overflow_warnings ();
|
fold_defer_overflow_warnings ();
|
t = fold_binary_loc (gimple_location (stmt), code, type, op0, op1);
|
t = fold_binary_loc (gimple_location (stmt), code, type, op0, op1);
|
if (!t)
|
if (!t)
|
{
|
{
|
fold_undefer_overflow_warnings (false, NULL, 0);
|
fold_undefer_overflow_warnings (false, NULL, 0);
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Require that we got a boolean type out if we put one in. */
|
/* Require that we got a boolean type out if we put one in. */
|
gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type));
|
gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type));
|
|
|
/* Canonicalize the combined condition for use in a COND_EXPR. */
|
/* Canonicalize the combined condition for use in a COND_EXPR. */
|
t = canonicalize_cond_expr_cond (t);
|
t = canonicalize_cond_expr_cond (t);
|
|
|
/* Bail out if we required an invariant but didn't get one. */
|
/* Bail out if we required an invariant but didn't get one. */
|
if (!t || (invariant_only && !is_gimple_min_invariant (t)))
|
if (!t || (invariant_only && !is_gimple_min_invariant (t)))
|
{
|
{
|
fold_undefer_overflow_warnings (false, NULL, 0);
|
fold_undefer_overflow_warnings (false, NULL, 0);
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt), stmt, 0);
|
fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt), stmt, 0);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Combine the comparison OP0 CODE OP1 at LOC with the defining statements
|
/* Combine the comparison OP0 CODE OP1 at LOC with the defining statements
|
of its operand. Return a new comparison tree or NULL_TREE if there
|
of its operand. Return a new comparison tree or NULL_TREE if there
|
were no simplifying combines. */
|
were no simplifying combines. */
|
|
|
static tree
|
static tree
|
forward_propagate_into_comparison_1 (gimple stmt,
|
forward_propagate_into_comparison_1 (gimple stmt,
|
enum tree_code code, tree type,
|
enum tree_code code, tree type,
|
tree op0, tree op1)
|
tree op0, tree op1)
|
{
|
{
|
tree tmp = NULL_TREE;
|
tree tmp = NULL_TREE;
|
tree rhs0 = NULL_TREE, rhs1 = NULL_TREE;
|
tree rhs0 = NULL_TREE, rhs1 = NULL_TREE;
|
bool single_use0_p = false, single_use1_p = false;
|
bool single_use0_p = false, single_use1_p = false;
|
|
|
/* For comparisons use the first operand, that is likely to
|
/* For comparisons use the first operand, that is likely to
|
simplify comparisons against constants. */
|
simplify comparisons against constants. */
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
{
|
{
|
gimple def_stmt = get_prop_source_stmt (op0, false, &single_use0_p);
|
gimple def_stmt = get_prop_source_stmt (op0, false, &single_use0_p);
|
if (def_stmt && can_propagate_from (def_stmt))
|
if (def_stmt && can_propagate_from (def_stmt))
|
{
|
{
|
rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt);
|
rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt);
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
rhs0, op1, !single_use0_p);
|
rhs0, op1, !single_use0_p);
|
if (tmp)
|
if (tmp)
|
return tmp;
|
return tmp;
|
}
|
}
|
}
|
}
|
|
|
/* If that wasn't successful, try the second operand. */
|
/* If that wasn't successful, try the second operand. */
|
if (TREE_CODE (op1) == SSA_NAME)
|
if (TREE_CODE (op1) == SSA_NAME)
|
{
|
{
|
gimple def_stmt = get_prop_source_stmt (op1, false, &single_use1_p);
|
gimple def_stmt = get_prop_source_stmt (op1, false, &single_use1_p);
|
if (def_stmt && can_propagate_from (def_stmt))
|
if (def_stmt && can_propagate_from (def_stmt))
|
{
|
{
|
rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt);
|
rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt);
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
op0, rhs1, !single_use1_p);
|
op0, rhs1, !single_use1_p);
|
if (tmp)
|
if (tmp)
|
return tmp;
|
return tmp;
|
}
|
}
|
}
|
}
|
|
|
/* If that wasn't successful either, try both operands. */
|
/* If that wasn't successful either, try both operands. */
|
if (rhs0 != NULL_TREE
|
if (rhs0 != NULL_TREE
|
&& rhs1 != NULL_TREE)
|
&& rhs1 != NULL_TREE)
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
tmp = combine_cond_expr_cond (stmt, code, type,
|
rhs0, rhs1,
|
rhs0, rhs1,
|
!(single_use0_p && single_use1_p));
|
!(single_use0_p && single_use1_p));
|
|
|
return tmp;
|
return tmp;
|
}
|
}
|
|
|
/* Propagate from the ssa name definition statements of the assignment
|
/* Propagate from the ssa name definition statements of the assignment
|
from a comparison at *GSI into the conditional if that simplifies it.
|
from a comparison at *GSI into the conditional if that simplifies it.
|
Returns 1 if the stmt was modified and 2 if the CFG needs cleanup,
|
Returns 1 if the stmt was modified and 2 if the CFG needs cleanup,
|
otherwise returns 0. */
|
otherwise returns 0. */
|
|
|
static int
|
static int
|
forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
|
forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
tree tmp;
|
tree tmp;
|
bool cfg_changed = false;
|
bool cfg_changed = false;
|
tree type = TREE_TYPE (gimple_assign_lhs (stmt));
|
tree type = TREE_TYPE (gimple_assign_lhs (stmt));
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
tree rhs2 = gimple_assign_rhs2 (stmt);
|
tree rhs2 = gimple_assign_rhs2 (stmt);
|
|
|
/* Combine the comparison with defining statements. */
|
/* Combine the comparison with defining statements. */
|
tmp = forward_propagate_into_comparison_1 (stmt,
|
tmp = forward_propagate_into_comparison_1 (stmt,
|
gimple_assign_rhs_code (stmt),
|
gimple_assign_rhs_code (stmt),
|
type, rhs1, rhs2);
|
type, rhs1, rhs2);
|
if (tmp && useless_type_conversion_p (type, TREE_TYPE (tmp)))
|
if (tmp && useless_type_conversion_p (type, TREE_TYPE (tmp)))
|
{
|
{
|
gimple_assign_set_rhs_from_tree (gsi, tmp);
|
gimple_assign_set_rhs_from_tree (gsi, tmp);
|
fold_stmt (gsi);
|
fold_stmt (gsi);
|
update_stmt (gsi_stmt (*gsi));
|
update_stmt (gsi_stmt (*gsi));
|
|
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
cfg_changed |= remove_prop_source_from_use (rhs1);
|
cfg_changed |= remove_prop_source_from_use (rhs1);
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
cfg_changed |= remove_prop_source_from_use (rhs2);
|
cfg_changed |= remove_prop_source_from_use (rhs2);
|
return cfg_changed ? 2 : 1;
|
return cfg_changed ? 2 : 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Propagate from the ssa name definition statements of COND_EXPR
|
/* Propagate from the ssa name definition statements of COND_EXPR
|
in GIMPLE_COND statement STMT into the conditional if that simplifies it.
|
in GIMPLE_COND statement STMT into the conditional if that simplifies it.
|
Returns zero if no statement was changed, one if there were
|
Returns zero if no statement was changed, one if there were
|
changes and two if cfg_cleanup needs to run.
|
changes and two if cfg_cleanup needs to run.
|
|
|
This must be kept in sync with forward_propagate_into_cond. */
|
This must be kept in sync with forward_propagate_into_cond. */
|
|
|
static int
|
static int
|
forward_propagate_into_gimple_cond (gimple stmt)
|
forward_propagate_into_gimple_cond (gimple stmt)
|
{
|
{
|
tree tmp;
|
tree tmp;
|
enum tree_code code = gimple_cond_code (stmt);
|
enum tree_code code = gimple_cond_code (stmt);
|
bool cfg_changed = false;
|
bool cfg_changed = false;
|
tree rhs1 = gimple_cond_lhs (stmt);
|
tree rhs1 = gimple_cond_lhs (stmt);
|
tree rhs2 = gimple_cond_rhs (stmt);
|
tree rhs2 = gimple_cond_rhs (stmt);
|
|
|
/* We can do tree combining on SSA_NAME and comparison expressions. */
|
/* We can do tree combining on SSA_NAME and comparison expressions. */
|
if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
|
if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
|
return 0;
|
return 0;
|
|
|
tmp = forward_propagate_into_comparison_1 (stmt, code,
|
tmp = forward_propagate_into_comparison_1 (stmt, code,
|
boolean_type_node,
|
boolean_type_node,
|
rhs1, rhs2);
|
rhs1, rhs2);
|
if (tmp)
|
if (tmp)
|
{
|
{
|
if (dump_file && tmp)
|
if (dump_file && tmp)
|
{
|
{
|
fprintf (dump_file, " Replaced '");
|
fprintf (dump_file, " Replaced '");
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
fprintf (dump_file, "' with '");
|
fprintf (dump_file, "' with '");
|
print_generic_expr (dump_file, tmp, 0);
|
print_generic_expr (dump_file, tmp, 0);
|
fprintf (dump_file, "'\n");
|
fprintf (dump_file, "'\n");
|
}
|
}
|
|
|
gimple_cond_set_condition_from_tree (stmt, unshare_expr (tmp));
|
gimple_cond_set_condition_from_tree (stmt, unshare_expr (tmp));
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
cfg_changed |= remove_prop_source_from_use (rhs1);
|
cfg_changed |= remove_prop_source_from_use (rhs1);
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
cfg_changed |= remove_prop_source_from_use (rhs2);
|
cfg_changed |= remove_prop_source_from_use (rhs2);
|
return (cfg_changed || is_gimple_min_invariant (tmp)) ? 2 : 1;
|
return (cfg_changed || is_gimple_min_invariant (tmp)) ? 2 : 1;
|
}
|
}
|
|
|
/* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges. */
|
/* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges. */
|
if ((TREE_CODE (TREE_TYPE (rhs1)) == BOOLEAN_TYPE
|
if ((TREE_CODE (TREE_TYPE (rhs1)) == BOOLEAN_TYPE
|
|| (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
|
|| (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
|
&& TYPE_PRECISION (TREE_TYPE (rhs1)) == 1))
|
&& TYPE_PRECISION (TREE_TYPE (rhs1)) == 1))
|
&& ((code == EQ_EXPR
|
&& ((code == EQ_EXPR
|
&& integer_zerop (rhs2))
|
&& integer_zerop (rhs2))
|
|| (code == NE_EXPR
|
|| (code == NE_EXPR
|
&& integer_onep (rhs2))))
|
&& integer_onep (rhs2))))
|
{
|
{
|
basic_block bb = gimple_bb (stmt);
|
basic_block bb = gimple_bb (stmt);
|
gimple_cond_set_code (stmt, NE_EXPR);
|
gimple_cond_set_code (stmt, NE_EXPR);
|
gimple_cond_set_rhs (stmt, build_zero_cst (TREE_TYPE (rhs1)));
|
gimple_cond_set_rhs (stmt, build_zero_cst (TREE_TYPE (rhs1)));
|
EDGE_SUCC (bb, 0)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
|
EDGE_SUCC (bb, 0)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
|
EDGE_SUCC (bb, 1)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
|
EDGE_SUCC (bb, 1)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Propagate from the ssa name definition statements of COND_EXPR
|
/* Propagate from the ssa name definition statements of COND_EXPR
|
in the rhs of statement STMT into the conditional if that simplifies it.
|
in the rhs of statement STMT into the conditional if that simplifies it.
|
Returns true zero if the stmt was changed. */
|
Returns true zero if the stmt was changed. */
|
|
|
static bool
|
static bool
|
forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
|
forward_propagate_into_cond (gimple_stmt_iterator *gsi_p)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi_p);
|
gimple stmt = gsi_stmt (*gsi_p);
|
tree tmp = NULL_TREE;
|
tree tmp = NULL_TREE;
|
tree cond = gimple_assign_rhs1 (stmt);
|
tree cond = gimple_assign_rhs1 (stmt);
|
bool swap = false;
|
bool swap = false;
|
|
|
/* We can do tree combining on SSA_NAME and comparison expressions. */
|
/* We can do tree combining on SSA_NAME and comparison expressions. */
|
if (COMPARISON_CLASS_P (cond))
|
if (COMPARISON_CLASS_P (cond))
|
tmp = forward_propagate_into_comparison_1 (stmt, TREE_CODE (cond),
|
tmp = forward_propagate_into_comparison_1 (stmt, TREE_CODE (cond),
|
boolean_type_node,
|
boolean_type_node,
|
TREE_OPERAND (cond, 0),
|
TREE_OPERAND (cond, 0),
|
TREE_OPERAND (cond, 1));
|
TREE_OPERAND (cond, 1));
|
else if (TREE_CODE (cond) == SSA_NAME)
|
else if (TREE_CODE (cond) == SSA_NAME)
|
{
|
{
|
enum tree_code code;
|
enum tree_code code;
|
tree name = cond;
|
tree name = cond;
|
gimple def_stmt = get_prop_source_stmt (name, true, NULL);
|
gimple def_stmt = get_prop_source_stmt (name, true, NULL);
|
if (!def_stmt || !can_propagate_from (def_stmt))
|
if (!def_stmt || !can_propagate_from (def_stmt))
|
return 0;
|
return 0;
|
|
|
code = gimple_assign_rhs_code (def_stmt);
|
code = gimple_assign_rhs_code (def_stmt);
|
if (TREE_CODE_CLASS (code) == tcc_comparison)
|
if (TREE_CODE_CLASS (code) == tcc_comparison)
|
tmp = fold_build2_loc (gimple_location (def_stmt),
|
tmp = fold_build2_loc (gimple_location (def_stmt),
|
code,
|
code,
|
boolean_type_node,
|
boolean_type_node,
|
gimple_assign_rhs1 (def_stmt),
|
gimple_assign_rhs1 (def_stmt),
|
gimple_assign_rhs2 (def_stmt));
|
gimple_assign_rhs2 (def_stmt));
|
else if ((code == BIT_NOT_EXPR
|
else if ((code == BIT_NOT_EXPR
|
&& TYPE_PRECISION (TREE_TYPE (cond)) == 1)
|
&& TYPE_PRECISION (TREE_TYPE (cond)) == 1)
|
|| (code == BIT_XOR_EXPR
|
|| (code == BIT_XOR_EXPR
|
&& integer_onep (gimple_assign_rhs2 (def_stmt))))
|
&& integer_onep (gimple_assign_rhs2 (def_stmt))))
|
{
|
{
|
tmp = gimple_assign_rhs1 (def_stmt);
|
tmp = gimple_assign_rhs1 (def_stmt);
|
swap = true;
|
swap = true;
|
}
|
}
|
}
|
}
|
|
|
if (tmp
|
if (tmp
|
&& is_gimple_condexpr (tmp))
|
&& is_gimple_condexpr (tmp))
|
{
|
{
|
if (dump_file && tmp)
|
if (dump_file && tmp)
|
{
|
{
|
fprintf (dump_file, " Replaced '");
|
fprintf (dump_file, " Replaced '");
|
print_generic_expr (dump_file, cond, 0);
|
print_generic_expr (dump_file, cond, 0);
|
fprintf (dump_file, "' with '");
|
fprintf (dump_file, "' with '");
|
print_generic_expr (dump_file, tmp, 0);
|
print_generic_expr (dump_file, tmp, 0);
|
fprintf (dump_file, "'\n");
|
fprintf (dump_file, "'\n");
|
}
|
}
|
|
|
if (integer_onep (tmp))
|
if (integer_onep (tmp))
|
gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs2 (stmt));
|
gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs2 (stmt));
|
else if (integer_zerop (tmp))
|
else if (integer_zerop (tmp))
|
gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs3 (stmt));
|
gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs3 (stmt));
|
else
|
else
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, unshare_expr (tmp));
|
gimple_assign_set_rhs1 (stmt, unshare_expr (tmp));
|
if (swap)
|
if (swap)
|
{
|
{
|
tree t = gimple_assign_rhs2 (stmt);
|
tree t = gimple_assign_rhs2 (stmt);
|
gimple_assign_set_rhs2 (stmt, gimple_assign_rhs3 (stmt));
|
gimple_assign_set_rhs2 (stmt, gimple_assign_rhs3 (stmt));
|
gimple_assign_set_rhs3 (stmt, t);
|
gimple_assign_set_rhs3 (stmt, t);
|
}
|
}
|
}
|
}
|
stmt = gsi_stmt (*gsi_p);
|
stmt = gsi_stmt (*gsi_p);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* We've just substituted an ADDR_EXPR into stmt. Update all the
|
/* We've just substituted an ADDR_EXPR into stmt. Update all the
|
relevant data structures to match. */
|
relevant data structures to match. */
|
|
|
static void
|
static void
|
tidy_after_forward_propagate_addr (gimple stmt)
|
tidy_after_forward_propagate_addr (gimple stmt)
|
{
|
{
|
/* We may have turned a trapping insn into a non-trapping insn. */
|
/* We may have turned a trapping insn into a non-trapping insn. */
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
|
&& gimple_purge_dead_eh_edges (gimple_bb (stmt)))
|
&& gimple_purge_dead_eh_edges (gimple_bb (stmt)))
|
cfg_changed = true;
|
cfg_changed = true;
|
|
|
if (TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
|
if (TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
|
recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
|
recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
|
}
|
}
|
|
|
/* DEF_RHS contains the address of the 0th element in an array.
|
/* DEF_RHS contains the address of the 0th element in an array.
|
USE_STMT uses type of DEF_RHS to compute the address of an
|
USE_STMT uses type of DEF_RHS to compute the address of an
|
arbitrary element within the array. The (variable) byte offset
|
arbitrary element within the array. The (variable) byte offset
|
of the element is contained in OFFSET.
|
of the element is contained in OFFSET.
|
|
|
We walk back through the use-def chains of OFFSET to verify that
|
We walk back through the use-def chains of OFFSET to verify that
|
it is indeed computing the offset of an element within the array
|
it is indeed computing the offset of an element within the array
|
and extract the index corresponding to the given byte offset.
|
and extract the index corresponding to the given byte offset.
|
|
|
We then try to fold the entire address expression into a form
|
We then try to fold the entire address expression into a form
|
&array[index].
|
&array[index].
|
|
|
If we are successful, we replace the right hand side of USE_STMT
|
If we are successful, we replace the right hand side of USE_STMT
|
with the new address computation. */
|
with the new address computation. */
|
|
|
static bool
|
static bool
|
forward_propagate_addr_into_variable_array_index (tree offset,
|
forward_propagate_addr_into_variable_array_index (tree offset,
|
tree def_rhs,
|
tree def_rhs,
|
gimple_stmt_iterator *use_stmt_gsi)
|
gimple_stmt_iterator *use_stmt_gsi)
|
{
|
{
|
tree index, tunit;
|
tree index, tunit;
|
gimple offset_def, use_stmt = gsi_stmt (*use_stmt_gsi);
|
gimple offset_def, use_stmt = gsi_stmt (*use_stmt_gsi);
|
tree new_rhs, tmp;
|
tree new_rhs, tmp;
|
|
|
if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF)
|
if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF)
|
tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (def_rhs)));
|
tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (def_rhs)));
|
else if (TREE_CODE (TREE_TYPE (TREE_OPERAND (def_rhs, 0))) == ARRAY_TYPE)
|
else if (TREE_CODE (TREE_TYPE (TREE_OPERAND (def_rhs, 0))) == ARRAY_TYPE)
|
tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs))));
|
tunit = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs))));
|
else
|
else
|
return false;
|
return false;
|
if (!host_integerp (tunit, 1))
|
if (!host_integerp (tunit, 1))
|
return false;
|
return false;
|
|
|
/* Get the offset's defining statement. */
|
/* Get the offset's defining statement. */
|
offset_def = SSA_NAME_DEF_STMT (offset);
|
offset_def = SSA_NAME_DEF_STMT (offset);
|
|
|
/* Try to find an expression for a proper index. This is either a
|
/* Try to find an expression for a proper index. This is either a
|
multiplication expression by the element size or just the ssa name we came
|
multiplication expression by the element size or just the ssa name we came
|
along in case the element size is one. In that case, however, we do not
|
along in case the element size is one. In that case, however, we do not
|
allow multiplications because they can be computing index to a higher
|
allow multiplications because they can be computing index to a higher
|
level dimension (PR 37861). */
|
level dimension (PR 37861). */
|
if (integer_onep (tunit))
|
if (integer_onep (tunit))
|
{
|
{
|
if (is_gimple_assign (offset_def)
|
if (is_gimple_assign (offset_def)
|
&& gimple_assign_rhs_code (offset_def) == MULT_EXPR)
|
&& gimple_assign_rhs_code (offset_def) == MULT_EXPR)
|
return false;
|
return false;
|
|
|
index = offset;
|
index = offset;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* The statement which defines OFFSET before type conversion
|
/* The statement which defines OFFSET before type conversion
|
must be a simple GIMPLE_ASSIGN. */
|
must be a simple GIMPLE_ASSIGN. */
|
if (!is_gimple_assign (offset_def))
|
if (!is_gimple_assign (offset_def))
|
return false;
|
return false;
|
|
|
/* The RHS of the statement which defines OFFSET must be a
|
/* The RHS of the statement which defines OFFSET must be a
|
multiplication of an object by the size of the array elements.
|
multiplication of an object by the size of the array elements.
|
This implicitly verifies that the size of the array elements
|
This implicitly verifies that the size of the array elements
|
is constant. */
|
is constant. */
|
if (gimple_assign_rhs_code (offset_def) == MULT_EXPR
|
if (gimple_assign_rhs_code (offset_def) == MULT_EXPR
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
|
&& tree_int_cst_equal (gimple_assign_rhs2 (offset_def), tunit))
|
&& tree_int_cst_equal (gimple_assign_rhs2 (offset_def), tunit))
|
{
|
{
|
/* The first operand to the MULT_EXPR is the desired index. */
|
/* The first operand to the MULT_EXPR is the desired index. */
|
index = gimple_assign_rhs1 (offset_def);
|
index = gimple_assign_rhs1 (offset_def);
|
}
|
}
|
/* If we have idx * tunit + CST * tunit re-associate that. */
|
/* If we have idx * tunit + CST * tunit re-associate that. */
|
else if ((gimple_assign_rhs_code (offset_def) == PLUS_EXPR
|
else if ((gimple_assign_rhs_code (offset_def) == PLUS_EXPR
|
|| gimple_assign_rhs_code (offset_def) == MINUS_EXPR)
|
|| gimple_assign_rhs_code (offset_def) == MINUS_EXPR)
|
&& TREE_CODE (gimple_assign_rhs1 (offset_def)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_rhs1 (offset_def)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
|
&& (tmp = div_if_zero_remainder (EXACT_DIV_EXPR,
|
&& (tmp = div_if_zero_remainder (EXACT_DIV_EXPR,
|
gimple_assign_rhs2 (offset_def),
|
gimple_assign_rhs2 (offset_def),
|
tunit)) != NULL_TREE)
|
tunit)) != NULL_TREE)
|
{
|
{
|
gimple offset_def2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (offset_def));
|
gimple offset_def2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (offset_def));
|
if (is_gimple_assign (offset_def2)
|
if (is_gimple_assign (offset_def2)
|
&& gimple_assign_rhs_code (offset_def2) == MULT_EXPR
|
&& gimple_assign_rhs_code (offset_def2) == MULT_EXPR
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def2)) == INTEGER_CST
|
&& TREE_CODE (gimple_assign_rhs2 (offset_def2)) == INTEGER_CST
|
&& tree_int_cst_equal (gimple_assign_rhs2 (offset_def2), tunit))
|
&& tree_int_cst_equal (gimple_assign_rhs2 (offset_def2), tunit))
|
{
|
{
|
index = fold_build2 (gimple_assign_rhs_code (offset_def),
|
index = fold_build2 (gimple_assign_rhs_code (offset_def),
|
TREE_TYPE (offset),
|
TREE_TYPE (offset),
|
gimple_assign_rhs1 (offset_def2), tmp);
|
gimple_assign_rhs1 (offset_def2), tmp);
|
}
|
}
|
else
|
else
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Replace the pointer addition with array indexing. */
|
/* Replace the pointer addition with array indexing. */
|
index = force_gimple_operand_gsi (use_stmt_gsi, index, true, NULL_TREE,
|
index = force_gimple_operand_gsi (use_stmt_gsi, index, true, NULL_TREE,
|
true, GSI_SAME_STMT);
|
true, GSI_SAME_STMT);
|
if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF)
|
if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == ARRAY_REF)
|
{
|
{
|
new_rhs = unshare_expr (def_rhs);
|
new_rhs = unshare_expr (def_rhs);
|
TREE_OPERAND (TREE_OPERAND (new_rhs, 0), 1) = index;
|
TREE_OPERAND (TREE_OPERAND (new_rhs, 0), 1) = index;
|
}
|
}
|
else
|
else
|
{
|
{
|
new_rhs = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs))),
|
new_rhs = build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (TREE_TYPE (def_rhs))),
|
unshare_expr (TREE_OPERAND (def_rhs, 0)),
|
unshare_expr (TREE_OPERAND (def_rhs, 0)),
|
index, integer_zero_node, NULL_TREE);
|
index, integer_zero_node, NULL_TREE);
|
new_rhs = build_fold_addr_expr (new_rhs);
|
new_rhs = build_fold_addr_expr (new_rhs);
|
if (!useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
if (!useless_type_conversion_p (TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
TREE_TYPE (new_rhs)))
|
TREE_TYPE (new_rhs)))
|
{
|
{
|
new_rhs = force_gimple_operand_gsi (use_stmt_gsi, new_rhs, true,
|
new_rhs = force_gimple_operand_gsi (use_stmt_gsi, new_rhs, true,
|
NULL_TREE, true, GSI_SAME_STMT);
|
NULL_TREE, true, GSI_SAME_STMT);
|
new_rhs = fold_convert (TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
new_rhs = fold_convert (TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
new_rhs);
|
new_rhs);
|
}
|
}
|
}
|
}
|
gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
|
gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
|
fold_stmt (use_stmt_gsi);
|
fold_stmt (use_stmt_gsi);
|
tidy_after_forward_propagate_addr (gsi_stmt (*use_stmt_gsi));
|
tidy_after_forward_propagate_addr (gsi_stmt (*use_stmt_gsi));
|
return true;
|
return true;
|
}
|
}
|
|
|
/* NAME is a SSA_NAME representing DEF_RHS which is of the form
|
/* NAME is a SSA_NAME representing DEF_RHS which is of the form
|
ADDR_EXPR <whatever>.
|
ADDR_EXPR <whatever>.
|
|
|
Try to forward propagate the ADDR_EXPR into the use USE_STMT.
|
Try to forward propagate the ADDR_EXPR into the use USE_STMT.
|
Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
|
Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
|
node or for recovery of array indexing from pointer arithmetic.
|
node or for recovery of array indexing from pointer arithmetic.
|
|
|
Return true if the propagation was successful (the propagation can
|
Return true if the propagation was successful (the propagation can
|
be not totally successful, yet things may have been changed). */
|
be not totally successful, yet things may have been changed). */
|
|
|
static bool
|
static bool
|
forward_propagate_addr_expr_1 (tree name, tree def_rhs,
|
forward_propagate_addr_expr_1 (tree name, tree def_rhs,
|
gimple_stmt_iterator *use_stmt_gsi,
|
gimple_stmt_iterator *use_stmt_gsi,
|
bool single_use_p)
|
bool single_use_p)
|
{
|
{
|
tree lhs, rhs, rhs2, array_ref;
|
tree lhs, rhs, rhs2, array_ref;
|
gimple use_stmt = gsi_stmt (*use_stmt_gsi);
|
gimple use_stmt = gsi_stmt (*use_stmt_gsi);
|
enum tree_code rhs_code;
|
enum tree_code rhs_code;
|
bool res = true;
|
bool res = true;
|
|
|
gcc_assert (TREE_CODE (def_rhs) == ADDR_EXPR);
|
gcc_assert (TREE_CODE (def_rhs) == ADDR_EXPR);
|
|
|
lhs = gimple_assign_lhs (use_stmt);
|
lhs = gimple_assign_lhs (use_stmt);
|
rhs_code = gimple_assign_rhs_code (use_stmt);
|
rhs_code = gimple_assign_rhs_code (use_stmt);
|
rhs = gimple_assign_rhs1 (use_stmt);
|
rhs = gimple_assign_rhs1 (use_stmt);
|
|
|
/* Trivial cases. The use statement could be a trivial copy or a
|
/* Trivial cases. The use statement could be a trivial copy or a
|
useless conversion. Recurse to the uses of the lhs as copyprop does
|
useless conversion. Recurse to the uses of the lhs as copyprop does
|
not copy through different variant pointers and FRE does not catch
|
not copy through different variant pointers and FRE does not catch
|
all useless conversions. Treat the case of a single-use name and
|
all useless conversions. Treat the case of a single-use name and
|
a conversion to def_rhs type separate, though. */
|
a conversion to def_rhs type separate, though. */
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& ((rhs_code == SSA_NAME && rhs == name)
|
&& ((rhs_code == SSA_NAME && rhs == name)
|
|| CONVERT_EXPR_CODE_P (rhs_code)))
|
|| CONVERT_EXPR_CODE_P (rhs_code)))
|
{
|
{
|
/* Only recurse if we don't deal with a single use or we cannot
|
/* Only recurse if we don't deal with a single use or we cannot
|
do the propagation to the current statement. In particular
|
do the propagation to the current statement. In particular
|
we can end up with a conversion needed for a non-invariant
|
we can end up with a conversion needed for a non-invariant
|
address which we cannot do in a single statement. */
|
address which we cannot do in a single statement. */
|
if (!single_use_p
|
if (!single_use_p
|
|| (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs))
|
|| (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs))
|
&& (!is_gimple_min_invariant (def_rhs)
|
&& (!is_gimple_min_invariant (def_rhs)
|
|| (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
|| (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
&& POINTER_TYPE_P (TREE_TYPE (def_rhs))
|
&& POINTER_TYPE_P (TREE_TYPE (def_rhs))
|
&& (TYPE_PRECISION (TREE_TYPE (lhs))
|
&& (TYPE_PRECISION (TREE_TYPE (lhs))
|
> TYPE_PRECISION (TREE_TYPE (def_rhs)))))))
|
> TYPE_PRECISION (TREE_TYPE (def_rhs)))))))
|
return forward_propagate_addr_expr (lhs, def_rhs);
|
return forward_propagate_addr_expr (lhs, def_rhs);
|
|
|
gimple_assign_set_rhs1 (use_stmt, unshare_expr (def_rhs));
|
gimple_assign_set_rhs1 (use_stmt, unshare_expr (def_rhs));
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
|
gimple_assign_set_rhs_code (use_stmt, TREE_CODE (def_rhs));
|
gimple_assign_set_rhs_code (use_stmt, TREE_CODE (def_rhs));
|
else
|
else
|
gimple_assign_set_rhs_code (use_stmt, NOP_EXPR);
|
gimple_assign_set_rhs_code (use_stmt, NOP_EXPR);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Propagate through constant pointer adjustments. */
|
/* Propagate through constant pointer adjustments. */
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& rhs_code == POINTER_PLUS_EXPR
|
&& rhs_code == POINTER_PLUS_EXPR
|
&& rhs == name
|
&& rhs == name
|
&& TREE_CODE (gimple_assign_rhs2 (use_stmt)) == INTEGER_CST)
|
&& TREE_CODE (gimple_assign_rhs2 (use_stmt)) == INTEGER_CST)
|
{
|
{
|
tree new_def_rhs;
|
tree new_def_rhs;
|
/* As we come here with non-invariant addresses in def_rhs we need
|
/* As we come here with non-invariant addresses in def_rhs we need
|
to make sure we can build a valid constant offsetted address
|
to make sure we can build a valid constant offsetted address
|
for further propagation. Simply rely on fold building that
|
for further propagation. Simply rely on fold building that
|
and check after the fact. */
|
and check after the fact. */
|
new_def_rhs = fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (rhs)),
|
new_def_rhs = fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (rhs)),
|
def_rhs,
|
def_rhs,
|
fold_convert (ptr_type_node,
|
fold_convert (ptr_type_node,
|
gimple_assign_rhs2 (use_stmt)));
|
gimple_assign_rhs2 (use_stmt)));
|
if (TREE_CODE (new_def_rhs) == MEM_REF
|
if (TREE_CODE (new_def_rhs) == MEM_REF
|
&& !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs, 0)))
|
&& !is_gimple_mem_ref_addr (TREE_OPERAND (new_def_rhs, 0)))
|
return false;
|
return false;
|
new_def_rhs = build_fold_addr_expr_with_type (new_def_rhs,
|
new_def_rhs = build_fold_addr_expr_with_type (new_def_rhs,
|
TREE_TYPE (rhs));
|
TREE_TYPE (rhs));
|
|
|
/* Recurse. If we could propagate into all uses of lhs do not
|
/* Recurse. If we could propagate into all uses of lhs do not
|
bother to replace into the current use but just pretend we did. */
|
bother to replace into the current use but just pretend we did. */
|
if (TREE_CODE (new_def_rhs) == ADDR_EXPR
|
if (TREE_CODE (new_def_rhs) == ADDR_EXPR
|
&& forward_propagate_addr_expr (lhs, new_def_rhs))
|
&& forward_propagate_addr_expr (lhs, new_def_rhs))
|
return true;
|
return true;
|
|
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (new_def_rhs)))
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (new_def_rhs)))
|
gimple_assign_set_rhs_with_ops (use_stmt_gsi, TREE_CODE (new_def_rhs),
|
gimple_assign_set_rhs_with_ops (use_stmt_gsi, TREE_CODE (new_def_rhs),
|
new_def_rhs, NULL_TREE);
|
new_def_rhs, NULL_TREE);
|
else if (is_gimple_min_invariant (new_def_rhs))
|
else if (is_gimple_min_invariant (new_def_rhs))
|
gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR,
|
gimple_assign_set_rhs_with_ops (use_stmt_gsi, NOP_EXPR,
|
new_def_rhs, NULL_TREE);
|
new_def_rhs, NULL_TREE);
|
else
|
else
|
return false;
|
return false;
|
gcc_assert (gsi_stmt (*use_stmt_gsi) == use_stmt);
|
gcc_assert (gsi_stmt (*use_stmt_gsi) == use_stmt);
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
|
/* Now strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS.
|
ADDR_EXPR will not appear on the LHS. */
|
ADDR_EXPR will not appear on the LHS. */
|
lhs = gimple_assign_lhs (use_stmt);
|
lhs = gimple_assign_lhs (use_stmt);
|
while (handled_component_p (lhs))
|
while (handled_component_p (lhs))
|
lhs = TREE_OPERAND (lhs, 0);
|
lhs = TREE_OPERAND (lhs, 0);
|
|
|
/* Now see if the LHS node is a MEM_REF using NAME. If so,
|
/* Now see if the LHS node is a MEM_REF using NAME. If so,
|
propagate the ADDR_EXPR into the use of NAME and fold the result. */
|
propagate the ADDR_EXPR into the use of NAME and fold the result. */
|
if (TREE_CODE (lhs) == MEM_REF
|
if (TREE_CODE (lhs) == MEM_REF
|
&& TREE_OPERAND (lhs, 0) == name)
|
&& TREE_OPERAND (lhs, 0) == name)
|
{
|
{
|
tree def_rhs_base;
|
tree def_rhs_base;
|
HOST_WIDE_INT def_rhs_offset;
|
HOST_WIDE_INT def_rhs_offset;
|
/* If the address is invariant we can always fold it. */
|
/* If the address is invariant we can always fold it. */
|
if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
|
if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
|
&def_rhs_offset)))
|
&def_rhs_offset)))
|
{
|
{
|
double_int off = mem_ref_offset (lhs);
|
double_int off = mem_ref_offset (lhs);
|
tree new_ptr;
|
tree new_ptr;
|
off = double_int_add (off,
|
off = double_int_add (off,
|
shwi_to_double_int (def_rhs_offset));
|
shwi_to_double_int (def_rhs_offset));
|
if (TREE_CODE (def_rhs_base) == MEM_REF)
|
if (TREE_CODE (def_rhs_base) == MEM_REF)
|
{
|
{
|
off = double_int_add (off, mem_ref_offset (def_rhs_base));
|
off = double_int_add (off, mem_ref_offset (def_rhs_base));
|
new_ptr = TREE_OPERAND (def_rhs_base, 0);
|
new_ptr = TREE_OPERAND (def_rhs_base, 0);
|
}
|
}
|
else
|
else
|
new_ptr = build_fold_addr_expr (def_rhs_base);
|
new_ptr = build_fold_addr_expr (def_rhs_base);
|
TREE_OPERAND (lhs, 0) = new_ptr;
|
TREE_OPERAND (lhs, 0) = new_ptr;
|
TREE_OPERAND (lhs, 1)
|
TREE_OPERAND (lhs, 1)
|
= double_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs, 1)), off);
|
= double_int_to_tree (TREE_TYPE (TREE_OPERAND (lhs, 1)), off);
|
tidy_after_forward_propagate_addr (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
/* Continue propagating into the RHS if this was not the only use. */
|
/* Continue propagating into the RHS if this was not the only use. */
|
if (single_use_p)
|
if (single_use_p)
|
return true;
|
return true;
|
}
|
}
|
/* If the LHS is a plain dereference and the value type is the same as
|
/* If the LHS is a plain dereference and the value type is the same as
|
that of the pointed-to type of the address we can put the
|
that of the pointed-to type of the address we can put the
|
dereferenced address on the LHS preserving the original alias-type. */
|
dereferenced address on the LHS preserving the original alias-type. */
|
else if (gimple_assign_lhs (use_stmt) == lhs
|
else if (gimple_assign_lhs (use_stmt) == lhs
|
&& useless_type_conversion_p
|
&& useless_type_conversion_p
|
(TREE_TYPE (TREE_OPERAND (def_rhs, 0)),
|
(TREE_TYPE (TREE_OPERAND (def_rhs, 0)),
|
TREE_TYPE (gimple_assign_rhs1 (use_stmt))))
|
TREE_TYPE (gimple_assign_rhs1 (use_stmt))))
|
{
|
{
|
tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
|
tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
|
tree new_offset, new_base, saved, new_lhs;
|
tree new_offset, new_base, saved, new_lhs;
|
while (handled_component_p (*def_rhs_basep))
|
while (handled_component_p (*def_rhs_basep))
|
def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
|
def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
|
saved = *def_rhs_basep;
|
saved = *def_rhs_basep;
|
if (TREE_CODE (*def_rhs_basep) == MEM_REF)
|
if (TREE_CODE (*def_rhs_basep) == MEM_REF)
|
{
|
{
|
new_base = TREE_OPERAND (*def_rhs_basep, 0);
|
new_base = TREE_OPERAND (*def_rhs_basep, 0);
|
new_offset
|
new_offset
|
= int_const_binop (PLUS_EXPR, TREE_OPERAND (lhs, 1),
|
= int_const_binop (PLUS_EXPR, TREE_OPERAND (lhs, 1),
|
TREE_OPERAND (*def_rhs_basep, 1));
|
TREE_OPERAND (*def_rhs_basep, 1));
|
}
|
}
|
else
|
else
|
{
|
{
|
new_base = build_fold_addr_expr (*def_rhs_basep);
|
new_base = build_fold_addr_expr (*def_rhs_basep);
|
new_offset = TREE_OPERAND (lhs, 1);
|
new_offset = TREE_OPERAND (lhs, 1);
|
}
|
}
|
*def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
|
*def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
|
new_base, new_offset);
|
new_base, new_offset);
|
TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (lhs);
|
TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (lhs);
|
TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (lhs);
|
TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (lhs);
|
TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (lhs);
|
TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (lhs);
|
new_lhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
|
new_lhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
|
gimple_assign_set_lhs (use_stmt, new_lhs);
|
gimple_assign_set_lhs (use_stmt, new_lhs);
|
TREE_THIS_VOLATILE (new_lhs) = TREE_THIS_VOLATILE (lhs);
|
TREE_THIS_VOLATILE (new_lhs) = TREE_THIS_VOLATILE (lhs);
|
TREE_SIDE_EFFECTS (new_lhs) = TREE_SIDE_EFFECTS (lhs);
|
TREE_SIDE_EFFECTS (new_lhs) = TREE_SIDE_EFFECTS (lhs);
|
*def_rhs_basep = saved;
|
*def_rhs_basep = saved;
|
tidy_after_forward_propagate_addr (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
/* Continue propagating into the RHS if this was not the
|
/* Continue propagating into the RHS if this was not the
|
only use. */
|
only use. */
|
if (single_use_p)
|
if (single_use_p)
|
return true;
|
return true;
|
}
|
}
|
else
|
else
|
/* We can have a struct assignment dereferencing our name twice.
|
/* We can have a struct assignment dereferencing our name twice.
|
Note that we didn't propagate into the lhs to not falsely
|
Note that we didn't propagate into the lhs to not falsely
|
claim we did when propagating into the rhs. */
|
claim we did when propagating into the rhs. */
|
res = false;
|
res = false;
|
}
|
}
|
|
|
/* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
|
/* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
|
nodes from the RHS. */
|
nodes from the RHS. */
|
rhs = gimple_assign_rhs1 (use_stmt);
|
rhs = gimple_assign_rhs1 (use_stmt);
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
rhs = TREE_OPERAND (rhs, 0);
|
rhs = TREE_OPERAND (rhs, 0);
|
while (handled_component_p (rhs))
|
while (handled_component_p (rhs))
|
rhs = TREE_OPERAND (rhs, 0);
|
rhs = TREE_OPERAND (rhs, 0);
|
|
|
/* Now see if the RHS node is a MEM_REF using NAME. If so,
|
/* Now see if the RHS node is a MEM_REF using NAME. If so,
|
propagate the ADDR_EXPR into the use of NAME and fold the result. */
|
propagate the ADDR_EXPR into the use of NAME and fold the result. */
|
if (TREE_CODE (rhs) == MEM_REF
|
if (TREE_CODE (rhs) == MEM_REF
|
&& TREE_OPERAND (rhs, 0) == name)
|
&& TREE_OPERAND (rhs, 0) == name)
|
{
|
{
|
tree def_rhs_base;
|
tree def_rhs_base;
|
HOST_WIDE_INT def_rhs_offset;
|
HOST_WIDE_INT def_rhs_offset;
|
if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
|
if ((def_rhs_base = get_addr_base_and_unit_offset (TREE_OPERAND (def_rhs, 0),
|
&def_rhs_offset)))
|
&def_rhs_offset)))
|
{
|
{
|
double_int off = mem_ref_offset (rhs);
|
double_int off = mem_ref_offset (rhs);
|
tree new_ptr;
|
tree new_ptr;
|
off = double_int_add (off,
|
off = double_int_add (off,
|
shwi_to_double_int (def_rhs_offset));
|
shwi_to_double_int (def_rhs_offset));
|
if (TREE_CODE (def_rhs_base) == MEM_REF)
|
if (TREE_CODE (def_rhs_base) == MEM_REF)
|
{
|
{
|
off = double_int_add (off, mem_ref_offset (def_rhs_base));
|
off = double_int_add (off, mem_ref_offset (def_rhs_base));
|
new_ptr = TREE_OPERAND (def_rhs_base, 0);
|
new_ptr = TREE_OPERAND (def_rhs_base, 0);
|
}
|
}
|
else
|
else
|
new_ptr = build_fold_addr_expr (def_rhs_base);
|
new_ptr = build_fold_addr_expr (def_rhs_base);
|
TREE_OPERAND (rhs, 0) = new_ptr;
|
TREE_OPERAND (rhs, 0) = new_ptr;
|
TREE_OPERAND (rhs, 1)
|
TREE_OPERAND (rhs, 1)
|
= double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs, 1)), off);
|
= double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs, 1)), off);
|
fold_stmt_inplace (use_stmt_gsi);
|
fold_stmt_inplace (use_stmt_gsi);
|
tidy_after_forward_propagate_addr (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
return res;
|
return res;
|
}
|
}
|
/* If the RHS is a plain dereference and the value type is the same as
|
/* If the RHS is a plain dereference and the value type is the same as
|
that of the pointed-to type of the address we can put the
|
that of the pointed-to type of the address we can put the
|
dereferenced address on the RHS preserving the original alias-type. */
|
dereferenced address on the RHS preserving the original alias-type. */
|
else if (gimple_assign_rhs1 (use_stmt) == rhs
|
else if (gimple_assign_rhs1 (use_stmt) == rhs
|
&& useless_type_conversion_p
|
&& useless_type_conversion_p
|
(TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
(TREE_TYPE (gimple_assign_lhs (use_stmt)),
|
TREE_TYPE (TREE_OPERAND (def_rhs, 0))))
|
TREE_TYPE (TREE_OPERAND (def_rhs, 0))))
|
{
|
{
|
tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
|
tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0);
|
tree new_offset, new_base, saved, new_rhs;
|
tree new_offset, new_base, saved, new_rhs;
|
while (handled_component_p (*def_rhs_basep))
|
while (handled_component_p (*def_rhs_basep))
|
def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
|
def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0);
|
saved = *def_rhs_basep;
|
saved = *def_rhs_basep;
|
if (TREE_CODE (*def_rhs_basep) == MEM_REF)
|
if (TREE_CODE (*def_rhs_basep) == MEM_REF)
|
{
|
{
|
new_base = TREE_OPERAND (*def_rhs_basep, 0);
|
new_base = TREE_OPERAND (*def_rhs_basep, 0);
|
new_offset
|
new_offset
|
= int_const_binop (PLUS_EXPR, TREE_OPERAND (rhs, 1),
|
= int_const_binop (PLUS_EXPR, TREE_OPERAND (rhs, 1),
|
TREE_OPERAND (*def_rhs_basep, 1));
|
TREE_OPERAND (*def_rhs_basep, 1));
|
}
|
}
|
else
|
else
|
{
|
{
|
new_base = build_fold_addr_expr (*def_rhs_basep);
|
new_base = build_fold_addr_expr (*def_rhs_basep);
|
new_offset = TREE_OPERAND (rhs, 1);
|
new_offset = TREE_OPERAND (rhs, 1);
|
}
|
}
|
*def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
|
*def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep),
|
new_base, new_offset);
|
new_base, new_offset);
|
TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (rhs);
|
TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (rhs);
|
TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (rhs);
|
TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (rhs);
|
TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (rhs);
|
TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (rhs);
|
new_rhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
|
new_rhs = unshare_expr (TREE_OPERAND (def_rhs, 0));
|
gimple_assign_set_rhs1 (use_stmt, new_rhs);
|
gimple_assign_set_rhs1 (use_stmt, new_rhs);
|
TREE_THIS_VOLATILE (new_rhs) = TREE_THIS_VOLATILE (rhs);
|
TREE_THIS_VOLATILE (new_rhs) = TREE_THIS_VOLATILE (rhs);
|
TREE_SIDE_EFFECTS (new_rhs) = TREE_SIDE_EFFECTS (rhs);
|
TREE_SIDE_EFFECTS (new_rhs) = TREE_SIDE_EFFECTS (rhs);
|
*def_rhs_basep = saved;
|
*def_rhs_basep = saved;
|
fold_stmt_inplace (use_stmt_gsi);
|
fold_stmt_inplace (use_stmt_gsi);
|
tidy_after_forward_propagate_addr (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
return res;
|
return res;
|
}
|
}
|
}
|
}
|
|
|
/* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
|
/* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
|
is nothing to do. */
|
is nothing to do. */
|
if (gimple_assign_rhs_code (use_stmt) != POINTER_PLUS_EXPR
|
if (gimple_assign_rhs_code (use_stmt) != POINTER_PLUS_EXPR
|
|| gimple_assign_rhs1 (use_stmt) != name)
|
|| gimple_assign_rhs1 (use_stmt) != name)
|
return false;
|
return false;
|
|
|
/* The remaining cases are all for turning pointer arithmetic into
|
/* The remaining cases are all for turning pointer arithmetic into
|
array indexing. They only apply when we have the address of
|
array indexing. They only apply when we have the address of
|
element zero in an array. If that is not the case then there
|
element zero in an array. If that is not the case then there
|
is nothing to do. */
|
is nothing to do. */
|
array_ref = TREE_OPERAND (def_rhs, 0);
|
array_ref = TREE_OPERAND (def_rhs, 0);
|
if ((TREE_CODE (array_ref) != ARRAY_REF
|
if ((TREE_CODE (array_ref) != ARRAY_REF
|
|| TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref, 0))) != ARRAY_TYPE
|
|| TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref, 0))) != ARRAY_TYPE
|
|| TREE_CODE (TREE_OPERAND (array_ref, 1)) != INTEGER_CST)
|
|| TREE_CODE (TREE_OPERAND (array_ref, 1)) != INTEGER_CST)
|
&& TREE_CODE (TREE_TYPE (array_ref)) != ARRAY_TYPE)
|
&& TREE_CODE (TREE_TYPE (array_ref)) != ARRAY_TYPE)
|
return false;
|
return false;
|
|
|
rhs2 = gimple_assign_rhs2 (use_stmt);
|
rhs2 = gimple_assign_rhs2 (use_stmt);
|
/* Optimize &x[C1] p+ C2 to &x p+ C3 with C3 = C1 * element_size + C2. */
|
/* Optimize &x[C1] p+ C2 to &x p+ C3 with C3 = C1 * element_size + C2. */
|
if (TREE_CODE (rhs2) == INTEGER_CST)
|
if (TREE_CODE (rhs2) == INTEGER_CST)
|
{
|
{
|
tree new_rhs = build1_loc (gimple_location (use_stmt),
|
tree new_rhs = build1_loc (gimple_location (use_stmt),
|
ADDR_EXPR, TREE_TYPE (def_rhs),
|
ADDR_EXPR, TREE_TYPE (def_rhs),
|
fold_build2 (MEM_REF,
|
fold_build2 (MEM_REF,
|
TREE_TYPE (TREE_TYPE (def_rhs)),
|
TREE_TYPE (TREE_TYPE (def_rhs)),
|
unshare_expr (def_rhs),
|
unshare_expr (def_rhs),
|
fold_convert (ptr_type_node,
|
fold_convert (ptr_type_node,
|
rhs2)));
|
rhs2)));
|
gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
|
gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
|
use_stmt = gsi_stmt (*use_stmt_gsi);
|
use_stmt = gsi_stmt (*use_stmt_gsi);
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
tidy_after_forward_propagate_addr (use_stmt);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Try to optimize &x[0] p+ OFFSET where OFFSET is defined by
|
/* Try to optimize &x[0] p+ OFFSET where OFFSET is defined by
|
converting a multiplication of an index by the size of the
|
converting a multiplication of an index by the size of the
|
array elements, then the result is converted into the proper
|
array elements, then the result is converted into the proper
|
type for the arithmetic. */
|
type for the arithmetic. */
|
if (TREE_CODE (rhs2) == SSA_NAME
|
if (TREE_CODE (rhs2) == SSA_NAME
|
&& (TREE_CODE (array_ref) != ARRAY_REF
|
&& (TREE_CODE (array_ref) != ARRAY_REF
|
|| integer_zerop (TREE_OPERAND (array_ref, 1)))
|
|| integer_zerop (TREE_OPERAND (array_ref, 1)))
|
&& useless_type_conversion_p (TREE_TYPE (name), TREE_TYPE (def_rhs))
|
&& useless_type_conversion_p (TREE_TYPE (name), TREE_TYPE (def_rhs))
|
/* Avoid problems with IVopts creating PLUS_EXPRs with a
|
/* Avoid problems with IVopts creating PLUS_EXPRs with a
|
different type than their operands. */
|
different type than their operands. */
|
&& useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
|
&& useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
|
return forward_propagate_addr_into_variable_array_index (rhs2, def_rhs,
|
return forward_propagate_addr_into_variable_array_index (rhs2, def_rhs,
|
use_stmt_gsi);
|
use_stmt_gsi);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
|
/* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
|
|
|
Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
|
Try to forward propagate the ADDR_EXPR into all uses of the SSA_NAME.
|
Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
|
Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
|
node or for recovery of array indexing from pointer arithmetic.
|
node or for recovery of array indexing from pointer arithmetic.
|
Returns true, if all uses have been propagated into. */
|
Returns true, if all uses have been propagated into. */
|
|
|
static bool
|
static bool
|
forward_propagate_addr_expr (tree name, tree rhs)
|
forward_propagate_addr_expr (tree name, tree rhs)
|
{
|
{
|
int stmt_loop_depth = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_depth;
|
int stmt_loop_depth = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_depth;
|
imm_use_iterator iter;
|
imm_use_iterator iter;
|
gimple use_stmt;
|
gimple use_stmt;
|
bool all = true;
|
bool all = true;
|
bool single_use_p = has_single_use (name);
|
bool single_use_p = has_single_use (name);
|
|
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, name)
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, name)
|
{
|
{
|
bool result;
|
bool result;
|
tree use_rhs;
|
tree use_rhs;
|
|
|
/* If the use is not in a simple assignment statement, then
|
/* If the use is not in a simple assignment statement, then
|
there is nothing we can do. */
|
there is nothing we can do. */
|
if (gimple_code (use_stmt) != GIMPLE_ASSIGN)
|
if (gimple_code (use_stmt) != GIMPLE_ASSIGN)
|
{
|
{
|
if (!is_gimple_debug (use_stmt))
|
if (!is_gimple_debug (use_stmt))
|
all = false;
|
all = false;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If the use is in a deeper loop nest, then we do not want
|
/* If the use is in a deeper loop nest, then we do not want
|
to propagate non-invariant ADDR_EXPRs into the loop as that
|
to propagate non-invariant ADDR_EXPRs into the loop as that
|
is likely adding expression evaluations into the loop. */
|
is likely adding expression evaluations into the loop. */
|
if (gimple_bb (use_stmt)->loop_depth > stmt_loop_depth
|
if (gimple_bb (use_stmt)->loop_depth > stmt_loop_depth
|
&& !is_gimple_min_invariant (rhs))
|
&& !is_gimple_min_invariant (rhs))
|
{
|
{
|
all = false;
|
all = false;
|
continue;
|
continue;
|
}
|
}
|
|
|
{
|
{
|
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
|
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
|
result = forward_propagate_addr_expr_1 (name, rhs, &gsi,
|
result = forward_propagate_addr_expr_1 (name, rhs, &gsi,
|
single_use_p);
|
single_use_p);
|
/* If the use has moved to a different statement adjust
|
/* If the use has moved to a different statement adjust
|
the update machinery for the old statement too. */
|
the update machinery for the old statement too. */
|
if (use_stmt != gsi_stmt (gsi))
|
if (use_stmt != gsi_stmt (gsi))
|
{
|
{
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
use_stmt = gsi_stmt (gsi);
|
use_stmt = gsi_stmt (gsi);
|
}
|
}
|
|
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
}
|
}
|
all &= result;
|
all &= result;
|
|
|
/* Remove intermediate now unused copy and conversion chains. */
|
/* Remove intermediate now unused copy and conversion chains. */
|
use_rhs = gimple_assign_rhs1 (use_stmt);
|
use_rhs = gimple_assign_rhs1 (use_stmt);
|
if (result
|
if (result
|
&& TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME
|
&& TREE_CODE (use_rhs) == SSA_NAME
|
&& TREE_CODE (use_rhs) == SSA_NAME
|
&& has_zero_uses (gimple_assign_lhs (use_stmt)))
|
&& has_zero_uses (gimple_assign_lhs (use_stmt)))
|
{
|
{
|
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
|
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
|
release_defs (use_stmt);
|
release_defs (use_stmt);
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
}
|
}
|
}
|
}
|
|
|
return all && has_zero_uses (name);
|
return all && has_zero_uses (name);
|
}
|
}
|
|
|
|
|
/* Forward propagate the comparison defined in STMT like
|
/* Forward propagate the comparison defined in STMT like
|
cond_1 = x CMP y to uses of the form
|
cond_1 = x CMP y to uses of the form
|
a_1 = (T')cond_1
|
a_1 = (T')cond_1
|
a_1 = !cond_1
|
a_1 = !cond_1
|
a_1 = cond_1 != 0
|
a_1 = cond_1 != 0
|
Returns true if stmt is now unused. */
|
Returns true if stmt is now unused. */
|
|
|
static bool
|
static bool
|
forward_propagate_comparison (gimple stmt)
|
forward_propagate_comparison (gimple stmt)
|
{
|
{
|
tree name = gimple_assign_lhs (stmt);
|
tree name = gimple_assign_lhs (stmt);
|
gimple use_stmt;
|
gimple use_stmt;
|
tree tmp = NULL_TREE;
|
tree tmp = NULL_TREE;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
enum tree_code code;
|
enum tree_code code;
|
tree lhs;
|
tree lhs;
|
|
|
/* Don't propagate ssa names that occur in abnormal phis. */
|
/* Don't propagate ssa names that occur in abnormal phis. */
|
if ((TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
if ((TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)))
|
|| (TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME
|
|| (TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt))))
|
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs2 (stmt))))
|
return false;
|
return false;
|
|
|
/* Do not un-cse comparisons. But propagate through copies. */
|
/* Do not un-cse comparisons. But propagate through copies. */
|
use_stmt = get_prop_dest_stmt (name, &name);
|
use_stmt = get_prop_dest_stmt (name, &name);
|
if (!use_stmt
|
if (!use_stmt
|
|| !is_gimple_assign (use_stmt))
|
|| !is_gimple_assign (use_stmt))
|
return false;
|
return false;
|
|
|
code = gimple_assign_rhs_code (use_stmt);
|
code = gimple_assign_rhs_code (use_stmt);
|
lhs = gimple_assign_lhs (use_stmt);
|
lhs = gimple_assign_lhs (use_stmt);
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
|
return false;
|
return false;
|
|
|
/* We can propagate the condition into a statement that
|
/* We can propagate the condition into a statement that
|
computes the logical negation of the comparison result. */
|
computes the logical negation of the comparison result. */
|
if ((code == BIT_NOT_EXPR
|
if ((code == BIT_NOT_EXPR
|
&& TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
|
&& TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
|
|| (code == BIT_XOR_EXPR
|
|| (code == BIT_XOR_EXPR
|
&& integer_onep (gimple_assign_rhs2 (use_stmt))))
|
&& integer_onep (gimple_assign_rhs2 (use_stmt))))
|
{
|
{
|
tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
|
tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
|
bool nans = HONOR_NANS (TYPE_MODE (type));
|
bool nans = HONOR_NANS (TYPE_MODE (type));
|
enum tree_code inv_code;
|
enum tree_code inv_code;
|
inv_code = invert_tree_comparison (gimple_assign_rhs_code (stmt), nans);
|
inv_code = invert_tree_comparison (gimple_assign_rhs_code (stmt), nans);
|
if (inv_code == ERROR_MARK)
|
if (inv_code == ERROR_MARK)
|
return false;
|
return false;
|
|
|
tmp = build2 (inv_code, TREE_TYPE (lhs), gimple_assign_rhs1 (stmt),
|
tmp = build2 (inv_code, TREE_TYPE (lhs), gimple_assign_rhs1 (stmt),
|
gimple_assign_rhs2 (stmt));
|
gimple_assign_rhs2 (stmt));
|
}
|
}
|
else
|
else
|
return false;
|
return false;
|
|
|
gsi = gsi_for_stmt (use_stmt);
|
gsi = gsi_for_stmt (use_stmt);
|
gimple_assign_set_rhs_from_tree (&gsi, unshare_expr (tmp));
|
gimple_assign_set_rhs_from_tree (&gsi, unshare_expr (tmp));
|
use_stmt = gsi_stmt (gsi);
|
use_stmt = gsi_stmt (gsi);
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, " Replaced '");
|
fprintf (dump_file, " Replaced '");
|
print_gimple_expr (dump_file, stmt, 0, dump_flags);
|
print_gimple_expr (dump_file, stmt, 0, dump_flags);
|
fprintf (dump_file, "' with '");
|
fprintf (dump_file, "' with '");
|
print_gimple_expr (dump_file, use_stmt, 0, dump_flags);
|
print_gimple_expr (dump_file, use_stmt, 0, dump_flags);
|
fprintf (dump_file, "'\n");
|
fprintf (dump_file, "'\n");
|
}
|
}
|
|
|
/* Remove defining statements. */
|
/* Remove defining statements. */
|
return remove_prop_source_from_use (name);
|
return remove_prop_source_from_use (name);
|
}
|
}
|
|
|
|
|
/* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y.
|
/* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y.
|
If so, we can change STMT into lhs = y which can later be copy
|
If so, we can change STMT into lhs = y which can later be copy
|
propagated. Similarly for negation.
|
propagated. Similarly for negation.
|
|
|
This could trivially be formulated as a forward propagation
|
This could trivially be formulated as a forward propagation
|
to immediate uses. However, we already had an implementation
|
to immediate uses. However, we already had an implementation
|
from DOM which used backward propagation via the use-def links.
|
from DOM which used backward propagation via the use-def links.
|
|
|
It turns out that backward propagation is actually faster as
|
It turns out that backward propagation is actually faster as
|
there's less work to do for each NOT/NEG expression we find.
|
there's less work to do for each NOT/NEG expression we find.
|
Backwards propagation needs to look at the statement in a single
|
Backwards propagation needs to look at the statement in a single
|
backlink. Forward propagation needs to look at potentially more
|
backlink. Forward propagation needs to look at potentially more
|
than one forward link.
|
than one forward link.
|
|
|
Returns true when the statement was changed. */
|
Returns true when the statement was changed. */
|
|
|
static bool
|
static bool
|
simplify_not_neg_expr (gimple_stmt_iterator *gsi_p)
|
simplify_not_neg_expr (gimple_stmt_iterator *gsi_p)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi_p);
|
gimple stmt = gsi_stmt (*gsi_p);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
|
gimple rhs_def_stmt = SSA_NAME_DEF_STMT (rhs);
|
|
|
/* See if the RHS_DEF_STMT has the same form as our statement. */
|
/* See if the RHS_DEF_STMT has the same form as our statement. */
|
if (is_gimple_assign (rhs_def_stmt)
|
if (is_gimple_assign (rhs_def_stmt)
|
&& gimple_assign_rhs_code (rhs_def_stmt) == gimple_assign_rhs_code (stmt))
|
&& gimple_assign_rhs_code (rhs_def_stmt) == gimple_assign_rhs_code (stmt))
|
{
|
{
|
tree rhs_def_operand = gimple_assign_rhs1 (rhs_def_stmt);
|
tree rhs_def_operand = gimple_assign_rhs1 (rhs_def_stmt);
|
|
|
/* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME. */
|
/* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME. */
|
if (TREE_CODE (rhs_def_operand) == SSA_NAME
|
if (TREE_CODE (rhs_def_operand) == SSA_NAME
|
&& ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand))
|
&& ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand))
|
{
|
{
|
gimple_assign_set_rhs_from_tree (gsi_p, rhs_def_operand);
|
gimple_assign_set_rhs_from_tree (gsi_p, rhs_def_operand);
|
stmt = gsi_stmt (*gsi_p);
|
stmt = gsi_stmt (*gsi_p);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of
|
/* STMT is a SWITCH_EXPR for which we attempt to find equivalent forms of
|
the condition which we may be able to optimize better. */
|
the condition which we may be able to optimize better. */
|
|
|
static bool
|
static bool
|
simplify_gimple_switch (gimple stmt)
|
simplify_gimple_switch (gimple stmt)
|
{
|
{
|
tree cond = gimple_switch_index (stmt);
|
tree cond = gimple_switch_index (stmt);
|
tree def, to, ti;
|
tree def, to, ti;
|
gimple def_stmt;
|
gimple def_stmt;
|
|
|
/* The optimization that we really care about is removing unnecessary
|
/* The optimization that we really care about is removing unnecessary
|
casts. That will let us do much better in propagating the inferred
|
casts. That will let us do much better in propagating the inferred
|
constant at the switch target. */
|
constant at the switch target. */
|
if (TREE_CODE (cond) == SSA_NAME)
|
if (TREE_CODE (cond) == SSA_NAME)
|
{
|
{
|
def_stmt = SSA_NAME_DEF_STMT (cond);
|
def_stmt = SSA_NAME_DEF_STMT (cond);
|
if (is_gimple_assign (def_stmt))
|
if (is_gimple_assign (def_stmt))
|
{
|
{
|
if (gimple_assign_rhs_code (def_stmt) == NOP_EXPR)
|
if (gimple_assign_rhs_code (def_stmt) == NOP_EXPR)
|
{
|
{
|
int need_precision;
|
int need_precision;
|
bool fail;
|
bool fail;
|
|
|
def = gimple_assign_rhs1 (def_stmt);
|
def = gimple_assign_rhs1 (def_stmt);
|
|
|
/* ??? Why was Jeff testing this? We are gimple... */
|
/* ??? Why was Jeff testing this? We are gimple... */
|
gcc_checking_assert (is_gimple_val (def));
|
gcc_checking_assert (is_gimple_val (def));
|
|
|
to = TREE_TYPE (cond);
|
to = TREE_TYPE (cond);
|
ti = TREE_TYPE (def);
|
ti = TREE_TYPE (def);
|
|
|
/* If we have an extension that preserves value, then we
|
/* If we have an extension that preserves value, then we
|
can copy the source value into the switch. */
|
can copy the source value into the switch. */
|
|
|
need_precision = TYPE_PRECISION (ti);
|
need_precision = TYPE_PRECISION (ti);
|
fail = false;
|
fail = false;
|
if (! INTEGRAL_TYPE_P (ti))
|
if (! INTEGRAL_TYPE_P (ti))
|
fail = true;
|
fail = true;
|
else if (TYPE_UNSIGNED (to) && !TYPE_UNSIGNED (ti))
|
else if (TYPE_UNSIGNED (to) && !TYPE_UNSIGNED (ti))
|
fail = true;
|
fail = true;
|
else if (!TYPE_UNSIGNED (to) && TYPE_UNSIGNED (ti))
|
else if (!TYPE_UNSIGNED (to) && TYPE_UNSIGNED (ti))
|
need_precision += 1;
|
need_precision += 1;
|
if (TYPE_PRECISION (to) < need_precision)
|
if (TYPE_PRECISION (to) < need_precision)
|
fail = true;
|
fail = true;
|
|
|
if (!fail)
|
if (!fail)
|
{
|
{
|
gimple_switch_set_index (stmt, def);
|
gimple_switch_set_index (stmt, def);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* For pointers p2 and p1 return p2 - p1 if the
|
/* For pointers p2 and p1 return p2 - p1 if the
|
difference is known and constant, otherwise return NULL. */
|
difference is known and constant, otherwise return NULL. */
|
|
|
static tree
|
static tree
|
constant_pointer_difference (tree p1, tree p2)
|
constant_pointer_difference (tree p1, tree p2)
|
{
|
{
|
int i, j;
|
int i, j;
|
#define CPD_ITERATIONS 5
|
#define CPD_ITERATIONS 5
|
tree exps[2][CPD_ITERATIONS];
|
tree exps[2][CPD_ITERATIONS];
|
tree offs[2][CPD_ITERATIONS];
|
tree offs[2][CPD_ITERATIONS];
|
int cnt[2];
|
int cnt[2];
|
|
|
for (i = 0; i < 2; i++)
|
for (i = 0; i < 2; i++)
|
{
|
{
|
tree p = i ? p1 : p2;
|
tree p = i ? p1 : p2;
|
tree off = size_zero_node;
|
tree off = size_zero_node;
|
gimple stmt;
|
gimple stmt;
|
enum tree_code code;
|
enum tree_code code;
|
|
|
/* For each of p1 and p2 we need to iterate at least
|
/* For each of p1 and p2 we need to iterate at least
|
twice, to handle ADDR_EXPR directly in p1/p2,
|
twice, to handle ADDR_EXPR directly in p1/p2,
|
SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
|
SSA_NAME with ADDR_EXPR or POINTER_PLUS_EXPR etc.
|
on definition's stmt RHS. Iterate a few extra times. */
|
on definition's stmt RHS. Iterate a few extra times. */
|
j = 0;
|
j = 0;
|
do
|
do
|
{
|
{
|
if (!POINTER_TYPE_P (TREE_TYPE (p)))
|
if (!POINTER_TYPE_P (TREE_TYPE (p)))
|
break;
|
break;
|
if (TREE_CODE (p) == ADDR_EXPR)
|
if (TREE_CODE (p) == ADDR_EXPR)
|
{
|
{
|
tree q = TREE_OPERAND (p, 0);
|
tree q = TREE_OPERAND (p, 0);
|
HOST_WIDE_INT offset;
|
HOST_WIDE_INT offset;
|
tree base = get_addr_base_and_unit_offset (q, &offset);
|
tree base = get_addr_base_and_unit_offset (q, &offset);
|
if (base)
|
if (base)
|
{
|
{
|
q = base;
|
q = base;
|
if (offset)
|
if (offset)
|
off = size_binop (PLUS_EXPR, off, size_int (offset));
|
off = size_binop (PLUS_EXPR, off, size_int (offset));
|
}
|
}
|
if (TREE_CODE (q) == MEM_REF
|
if (TREE_CODE (q) == MEM_REF
|
&& TREE_CODE (TREE_OPERAND (q, 0)) == SSA_NAME)
|
&& TREE_CODE (TREE_OPERAND (q, 0)) == SSA_NAME)
|
{
|
{
|
p = TREE_OPERAND (q, 0);
|
p = TREE_OPERAND (q, 0);
|
off = size_binop (PLUS_EXPR, off,
|
off = size_binop (PLUS_EXPR, off,
|
double_int_to_tree (sizetype,
|
double_int_to_tree (sizetype,
|
mem_ref_offset (q)));
|
mem_ref_offset (q)));
|
}
|
}
|
else
|
else
|
{
|
{
|
exps[i][j] = q;
|
exps[i][j] = q;
|
offs[i][j++] = off;
|
offs[i][j++] = off;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (TREE_CODE (p) != SSA_NAME)
|
if (TREE_CODE (p) != SSA_NAME)
|
break;
|
break;
|
exps[i][j] = p;
|
exps[i][j] = p;
|
offs[i][j++] = off;
|
offs[i][j++] = off;
|
if (j == CPD_ITERATIONS)
|
if (j == CPD_ITERATIONS)
|
break;
|
break;
|
stmt = SSA_NAME_DEF_STMT (p);
|
stmt = SSA_NAME_DEF_STMT (p);
|
if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != p)
|
if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != p)
|
break;
|
break;
|
code = gimple_assign_rhs_code (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
if (code == POINTER_PLUS_EXPR)
|
if (code == POINTER_PLUS_EXPR)
|
{
|
{
|
if (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)
|
if (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST)
|
break;
|
break;
|
off = size_binop (PLUS_EXPR, off, gimple_assign_rhs2 (stmt));
|
off = size_binop (PLUS_EXPR, off, gimple_assign_rhs2 (stmt));
|
p = gimple_assign_rhs1 (stmt);
|
p = gimple_assign_rhs1 (stmt);
|
}
|
}
|
else if (code == ADDR_EXPR || code == NOP_EXPR)
|
else if (code == ADDR_EXPR || code == NOP_EXPR)
|
p = gimple_assign_rhs1 (stmt);
|
p = gimple_assign_rhs1 (stmt);
|
else
|
else
|
break;
|
break;
|
}
|
}
|
while (1);
|
while (1);
|
cnt[i] = j;
|
cnt[i] = j;
|
}
|
}
|
|
|
for (i = 0; i < cnt[0]; i++)
|
for (i = 0; i < cnt[0]; i++)
|
for (j = 0; j < cnt[1]; j++)
|
for (j = 0; j < cnt[1]; j++)
|
if (exps[0][i] == exps[1][j])
|
if (exps[0][i] == exps[1][j])
|
return size_binop (MINUS_EXPR, offs[0][i], offs[1][j]);
|
return size_binop (MINUS_EXPR, offs[0][i], offs[1][j]);
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* *GSI_P is a GIMPLE_CALL to a builtin function.
|
/* *GSI_P is a GIMPLE_CALL to a builtin function.
|
Optimize
|
Optimize
|
memcpy (p, "abcd", 4);
|
memcpy (p, "abcd", 4);
|
memset (p + 4, ' ', 3);
|
memset (p + 4, ' ', 3);
|
into
|
into
|
memcpy (p, "abcd ", 7);
|
memcpy (p, "abcd ", 7);
|
call if the latter can be stored by pieces during expansion. */
|
call if the latter can be stored by pieces during expansion. */
|
|
|
static bool
|
static bool
|
simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
|
simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2)
|
{
|
{
|
gimple stmt1, stmt2 = gsi_stmt (*gsi_p);
|
gimple stmt1, stmt2 = gsi_stmt (*gsi_p);
|
tree vuse = gimple_vuse (stmt2);
|
tree vuse = gimple_vuse (stmt2);
|
if (vuse == NULL)
|
if (vuse == NULL)
|
return false;
|
return false;
|
stmt1 = SSA_NAME_DEF_STMT (vuse);
|
stmt1 = SSA_NAME_DEF_STMT (vuse);
|
|
|
switch (DECL_FUNCTION_CODE (callee2))
|
switch (DECL_FUNCTION_CODE (callee2))
|
{
|
{
|
case BUILT_IN_MEMSET:
|
case BUILT_IN_MEMSET:
|
if (gimple_call_num_args (stmt2) != 3
|
if (gimple_call_num_args (stmt2) != 3
|
|| gimple_call_lhs (stmt2)
|
|| gimple_call_lhs (stmt2)
|
|| CHAR_BIT != 8
|
|| CHAR_BIT != 8
|
|| BITS_PER_UNIT != 8)
|
|| BITS_PER_UNIT != 8)
|
break;
|
break;
|
else
|
else
|
{
|
{
|
tree callee1;
|
tree callee1;
|
tree ptr1, src1, str1, off1, len1, lhs1;
|
tree ptr1, src1, str1, off1, len1, lhs1;
|
tree ptr2 = gimple_call_arg (stmt2, 0);
|
tree ptr2 = gimple_call_arg (stmt2, 0);
|
tree val2 = gimple_call_arg (stmt2, 1);
|
tree val2 = gimple_call_arg (stmt2, 1);
|
tree len2 = gimple_call_arg (stmt2, 2);
|
tree len2 = gimple_call_arg (stmt2, 2);
|
tree diff, vdef, new_str_cst;
|
tree diff, vdef, new_str_cst;
|
gimple use_stmt;
|
gimple use_stmt;
|
unsigned int ptr1_align;
|
unsigned int ptr1_align;
|
unsigned HOST_WIDE_INT src_len;
|
unsigned HOST_WIDE_INT src_len;
|
char *src_buf;
|
char *src_buf;
|
use_operand_p use_p;
|
use_operand_p use_p;
|
|
|
if (!host_integerp (val2, 0)
|
if (!host_integerp (val2, 0)
|
|| !host_integerp (len2, 1))
|
|| !host_integerp (len2, 1))
|
break;
|
break;
|
if (is_gimple_call (stmt1))
|
if (is_gimple_call (stmt1))
|
{
|
{
|
/* If first stmt is a call, it needs to be memcpy
|
/* If first stmt is a call, it needs to be memcpy
|
or mempcpy, with string literal as second argument and
|
or mempcpy, with string literal as second argument and
|
constant length. */
|
constant length. */
|
callee1 = gimple_call_fndecl (stmt1);
|
callee1 = gimple_call_fndecl (stmt1);
|
if (callee1 == NULL_TREE
|
if (callee1 == NULL_TREE
|
|| DECL_BUILT_IN_CLASS (callee1) != BUILT_IN_NORMAL
|
|| DECL_BUILT_IN_CLASS (callee1) != BUILT_IN_NORMAL
|
|| gimple_call_num_args (stmt1) != 3)
|
|| gimple_call_num_args (stmt1) != 3)
|
break;
|
break;
|
if (DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMCPY
|
if (DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMCPY
|
&& DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMPCPY)
|
&& DECL_FUNCTION_CODE (callee1) != BUILT_IN_MEMPCPY)
|
break;
|
break;
|
ptr1 = gimple_call_arg (stmt1, 0);
|
ptr1 = gimple_call_arg (stmt1, 0);
|
src1 = gimple_call_arg (stmt1, 1);
|
src1 = gimple_call_arg (stmt1, 1);
|
len1 = gimple_call_arg (stmt1, 2);
|
len1 = gimple_call_arg (stmt1, 2);
|
lhs1 = gimple_call_lhs (stmt1);
|
lhs1 = gimple_call_lhs (stmt1);
|
if (!host_integerp (len1, 1))
|
if (!host_integerp (len1, 1))
|
break;
|
break;
|
str1 = string_constant (src1, &off1);
|
str1 = string_constant (src1, &off1);
|
if (str1 == NULL_TREE)
|
if (str1 == NULL_TREE)
|
break;
|
break;
|
if (!host_integerp (off1, 1)
|
if (!host_integerp (off1, 1)
|
|| compare_tree_int (off1, TREE_STRING_LENGTH (str1) - 1) > 0
|
|| compare_tree_int (off1, TREE_STRING_LENGTH (str1) - 1) > 0
|
|| compare_tree_int (len1, TREE_STRING_LENGTH (str1)
|
|| compare_tree_int (len1, TREE_STRING_LENGTH (str1)
|
- tree_low_cst (off1, 1)) > 0
|
- tree_low_cst (off1, 1)) > 0
|
|| TREE_CODE (TREE_TYPE (str1)) != ARRAY_TYPE
|
|| TREE_CODE (TREE_TYPE (str1)) != ARRAY_TYPE
|
|| TYPE_MODE (TREE_TYPE (TREE_TYPE (str1)))
|
|| TYPE_MODE (TREE_TYPE (TREE_TYPE (str1)))
|
!= TYPE_MODE (char_type_node))
|
!= TYPE_MODE (char_type_node))
|
break;
|
break;
|
}
|
}
|
else if (gimple_assign_single_p (stmt1))
|
else if (gimple_assign_single_p (stmt1))
|
{
|
{
|
/* Otherwise look for length 1 memcpy optimized into
|
/* Otherwise look for length 1 memcpy optimized into
|
assignment. */
|
assignment. */
|
ptr1 = gimple_assign_lhs (stmt1);
|
ptr1 = gimple_assign_lhs (stmt1);
|
src1 = gimple_assign_rhs1 (stmt1);
|
src1 = gimple_assign_rhs1 (stmt1);
|
if (TREE_CODE (ptr1) != MEM_REF
|
if (TREE_CODE (ptr1) != MEM_REF
|
|| TYPE_MODE (TREE_TYPE (ptr1)) != TYPE_MODE (char_type_node)
|
|| TYPE_MODE (TREE_TYPE (ptr1)) != TYPE_MODE (char_type_node)
|
|| !host_integerp (src1, 0))
|
|| !host_integerp (src1, 0))
|
break;
|
break;
|
ptr1 = build_fold_addr_expr (ptr1);
|
ptr1 = build_fold_addr_expr (ptr1);
|
callee1 = NULL_TREE;
|
callee1 = NULL_TREE;
|
len1 = size_one_node;
|
len1 = size_one_node;
|
lhs1 = NULL_TREE;
|
lhs1 = NULL_TREE;
|
off1 = size_zero_node;
|
off1 = size_zero_node;
|
str1 = NULL_TREE;
|
str1 = NULL_TREE;
|
}
|
}
|
else
|
else
|
break;
|
break;
|
|
|
diff = constant_pointer_difference (ptr1, ptr2);
|
diff = constant_pointer_difference (ptr1, ptr2);
|
if (diff == NULL && lhs1 != NULL)
|
if (diff == NULL && lhs1 != NULL)
|
{
|
{
|
diff = constant_pointer_difference (lhs1, ptr2);
|
diff = constant_pointer_difference (lhs1, ptr2);
|
if (DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
|
if (DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
|
&& diff != NULL)
|
&& diff != NULL)
|
diff = size_binop (PLUS_EXPR, diff,
|
diff = size_binop (PLUS_EXPR, diff,
|
fold_convert (sizetype, len1));
|
fold_convert (sizetype, len1));
|
}
|
}
|
/* If the difference between the second and first destination pointer
|
/* If the difference between the second and first destination pointer
|
is not constant, or is bigger than memcpy length, bail out. */
|
is not constant, or is bigger than memcpy length, bail out. */
|
if (diff == NULL
|
if (diff == NULL
|
|| !host_integerp (diff, 1)
|
|| !host_integerp (diff, 1)
|
|| tree_int_cst_lt (len1, diff))
|
|| tree_int_cst_lt (len1, diff))
|
break;
|
break;
|
|
|
/* Use maximum of difference plus memset length and memcpy length
|
/* Use maximum of difference plus memset length and memcpy length
|
as the new memcpy length, if it is too big, bail out. */
|
as the new memcpy length, if it is too big, bail out. */
|
src_len = tree_low_cst (diff, 1);
|
src_len = tree_low_cst (diff, 1);
|
src_len += tree_low_cst (len2, 1);
|
src_len += tree_low_cst (len2, 1);
|
if (src_len < (unsigned HOST_WIDE_INT) tree_low_cst (len1, 1))
|
if (src_len < (unsigned HOST_WIDE_INT) tree_low_cst (len1, 1))
|
src_len = tree_low_cst (len1, 1);
|
src_len = tree_low_cst (len1, 1);
|
if (src_len > 1024)
|
if (src_len > 1024)
|
break;
|
break;
|
|
|
/* If mempcpy value is used elsewhere, bail out, as mempcpy
|
/* If mempcpy value is used elsewhere, bail out, as mempcpy
|
with bigger length will return different result. */
|
with bigger length will return different result. */
|
if (lhs1 != NULL_TREE
|
if (lhs1 != NULL_TREE
|
&& DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
|
&& DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY
|
&& (TREE_CODE (lhs1) != SSA_NAME
|
&& (TREE_CODE (lhs1) != SSA_NAME
|
|| !single_imm_use (lhs1, &use_p, &use_stmt)
|
|| !single_imm_use (lhs1, &use_p, &use_stmt)
|
|| use_stmt != stmt2))
|
|| use_stmt != stmt2))
|
break;
|
break;
|
|
|
/* If anything reads memory in between memcpy and memset
|
/* If anything reads memory in between memcpy and memset
|
call, the modified memcpy call might change it. */
|
call, the modified memcpy call might change it. */
|
vdef = gimple_vdef (stmt1);
|
vdef = gimple_vdef (stmt1);
|
if (vdef != NULL
|
if (vdef != NULL
|
&& (!single_imm_use (vdef, &use_p, &use_stmt)
|
&& (!single_imm_use (vdef, &use_p, &use_stmt)
|
|| use_stmt != stmt2))
|
|| use_stmt != stmt2))
|
break;
|
break;
|
|
|
ptr1_align = get_pointer_alignment (ptr1);
|
ptr1_align = get_pointer_alignment (ptr1);
|
/* Construct the new source string literal. */
|
/* Construct the new source string literal. */
|
src_buf = XALLOCAVEC (char, src_len + 1);
|
src_buf = XALLOCAVEC (char, src_len + 1);
|
if (callee1)
|
if (callee1)
|
memcpy (src_buf,
|
memcpy (src_buf,
|
TREE_STRING_POINTER (str1) + tree_low_cst (off1, 1),
|
TREE_STRING_POINTER (str1) + tree_low_cst (off1, 1),
|
tree_low_cst (len1, 1));
|
tree_low_cst (len1, 1));
|
else
|
else
|
src_buf[0] = tree_low_cst (src1, 0);
|
src_buf[0] = tree_low_cst (src1, 0);
|
memset (src_buf + tree_low_cst (diff, 1),
|
memset (src_buf + tree_low_cst (diff, 1),
|
tree_low_cst (val2, 1), tree_low_cst (len2, 1));
|
tree_low_cst (val2, 1), tree_low_cst (len2, 1));
|
src_buf[src_len] = '\0';
|
src_buf[src_len] = '\0';
|
/* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str
|
/* Neither builtin_strncpy_read_str nor builtin_memcpy_read_str
|
handle embedded '\0's. */
|
handle embedded '\0's. */
|
if (strlen (src_buf) != src_len)
|
if (strlen (src_buf) != src_len)
|
break;
|
break;
|
rtl_profile_for_bb (gimple_bb (stmt2));
|
rtl_profile_for_bb (gimple_bb (stmt2));
|
/* If the new memcpy wouldn't be emitted by storing the literal
|
/* If the new memcpy wouldn't be emitted by storing the literal
|
by pieces, this optimization might enlarge .rodata too much,
|
by pieces, this optimization might enlarge .rodata too much,
|
as commonly used string literals couldn't be shared any
|
as commonly used string literals couldn't be shared any
|
longer. */
|
longer. */
|
if (!can_store_by_pieces (src_len,
|
if (!can_store_by_pieces (src_len,
|
builtin_strncpy_read_str,
|
builtin_strncpy_read_str,
|
src_buf, ptr1_align, false))
|
src_buf, ptr1_align, false))
|
break;
|
break;
|
|
|
new_str_cst = build_string_literal (src_len, src_buf);
|
new_str_cst = build_string_literal (src_len, src_buf);
|
if (callee1)
|
if (callee1)
|
{
|
{
|
/* If STMT1 is a mem{,p}cpy call, adjust it and remove
|
/* If STMT1 is a mem{,p}cpy call, adjust it and remove
|
memset call. */
|
memset call. */
|
if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
|
if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
|
gimple_call_set_lhs (stmt1, NULL_TREE);
|
gimple_call_set_lhs (stmt1, NULL_TREE);
|
gimple_call_set_arg (stmt1, 1, new_str_cst);
|
gimple_call_set_arg (stmt1, 1, new_str_cst);
|
gimple_call_set_arg (stmt1, 2,
|
gimple_call_set_arg (stmt1, 2,
|
build_int_cst (TREE_TYPE (len1), src_len));
|
build_int_cst (TREE_TYPE (len1), src_len));
|
update_stmt (stmt1);
|
update_stmt (stmt1);
|
unlink_stmt_vdef (stmt2);
|
unlink_stmt_vdef (stmt2);
|
gsi_remove (gsi_p, true);
|
gsi_remove (gsi_p, true);
|
release_defs (stmt2);
|
release_defs (stmt2);
|
if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
|
if (lhs1 && DECL_FUNCTION_CODE (callee1) == BUILT_IN_MEMPCPY)
|
release_ssa_name (lhs1);
|
release_ssa_name (lhs1);
|
return true;
|
return true;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Otherwise, if STMT1 is length 1 memcpy optimized into
|
/* Otherwise, if STMT1 is length 1 memcpy optimized into
|
assignment, remove STMT1 and change memset call into
|
assignment, remove STMT1 and change memset call into
|
memcpy call. */
|
memcpy call. */
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt1);
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt1);
|
|
|
if (!is_gimple_val (ptr1))
|
if (!is_gimple_val (ptr1))
|
ptr1 = force_gimple_operand_gsi (gsi_p, ptr1, true, NULL_TREE,
|
ptr1 = force_gimple_operand_gsi (gsi_p, ptr1, true, NULL_TREE,
|
true, GSI_SAME_STMT);
|
true, GSI_SAME_STMT);
|
gimple_call_set_fndecl (stmt2,
|
gimple_call_set_fndecl (stmt2,
|
builtin_decl_explicit (BUILT_IN_MEMCPY));
|
builtin_decl_explicit (BUILT_IN_MEMCPY));
|
gimple_call_set_arg (stmt2, 0, ptr1);
|
gimple_call_set_arg (stmt2, 0, ptr1);
|
gimple_call_set_arg (stmt2, 1, new_str_cst);
|
gimple_call_set_arg (stmt2, 1, new_str_cst);
|
gimple_call_set_arg (stmt2, 2,
|
gimple_call_set_arg (stmt2, 2,
|
build_int_cst (TREE_TYPE (len2), src_len));
|
build_int_cst (TREE_TYPE (len2), src_len));
|
unlink_stmt_vdef (stmt1);
|
unlink_stmt_vdef (stmt1);
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
release_defs (stmt1);
|
release_defs (stmt1);
|
update_stmt (stmt2);
|
update_stmt (stmt2);
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Checks if expression has type of one-bit precision, or is a known
|
/* Checks if expression has type of one-bit precision, or is a known
|
truth-valued expression. */
|
truth-valued expression. */
|
static bool
|
static bool
|
truth_valued_ssa_name (tree name)
|
truth_valued_ssa_name (tree name)
|
{
|
{
|
gimple def;
|
gimple def;
|
tree type = TREE_TYPE (name);
|
tree type = TREE_TYPE (name);
|
|
|
if (!INTEGRAL_TYPE_P (type))
|
if (!INTEGRAL_TYPE_P (type))
|
return false;
|
return false;
|
/* Don't check here for BOOLEAN_TYPE as the precision isn't
|
/* Don't check here for BOOLEAN_TYPE as the precision isn't
|
necessarily one and so ~X is not equal to !X. */
|
necessarily one and so ~X is not equal to !X. */
|
if (TYPE_PRECISION (type) == 1)
|
if (TYPE_PRECISION (type) == 1)
|
return true;
|
return true;
|
def = SSA_NAME_DEF_STMT (name);
|
def = SSA_NAME_DEF_STMT (name);
|
if (is_gimple_assign (def))
|
if (is_gimple_assign (def))
|
return truth_value_p (gimple_assign_rhs_code (def));
|
return truth_value_p (gimple_assign_rhs_code (def));
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Helper routine for simplify_bitwise_binary_1 function.
|
/* Helper routine for simplify_bitwise_binary_1 function.
|
Return for the SSA name NAME the expression X if it mets condition
|
Return for the SSA name NAME the expression X if it mets condition
|
NAME = !X. Otherwise return NULL_TREE.
|
NAME = !X. Otherwise return NULL_TREE.
|
Detected patterns for NAME = !X are:
|
Detected patterns for NAME = !X are:
|
!X and X == 0 for X with integral type.
|
!X and X == 0 for X with integral type.
|
X ^ 1, X != 1,or ~X for X with integral type with precision of one. */
|
X ^ 1, X != 1,or ~X for X with integral type with precision of one. */
|
static tree
|
static tree
|
lookup_logical_inverted_value (tree name)
|
lookup_logical_inverted_value (tree name)
|
{
|
{
|
tree op1, op2;
|
tree op1, op2;
|
enum tree_code code;
|
enum tree_code code;
|
gimple def;
|
gimple def;
|
|
|
/* If name has none-intergal type, or isn't a SSA_NAME, then
|
/* If name has none-intergal type, or isn't a SSA_NAME, then
|
return. */
|
return. */
|
if (TREE_CODE (name) != SSA_NAME
|
if (TREE_CODE (name) != SSA_NAME
|
|| !INTEGRAL_TYPE_P (TREE_TYPE (name)))
|
|| !INTEGRAL_TYPE_P (TREE_TYPE (name)))
|
return NULL_TREE;
|
return NULL_TREE;
|
def = SSA_NAME_DEF_STMT (name);
|
def = SSA_NAME_DEF_STMT (name);
|
if (!is_gimple_assign (def))
|
if (!is_gimple_assign (def))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
code = gimple_assign_rhs_code (def);
|
code = gimple_assign_rhs_code (def);
|
op1 = gimple_assign_rhs1 (def);
|
op1 = gimple_assign_rhs1 (def);
|
op2 = NULL_TREE;
|
op2 = NULL_TREE;
|
|
|
/* Get for EQ_EXPR or BIT_XOR_EXPR operation the second operand.
|
/* Get for EQ_EXPR or BIT_XOR_EXPR operation the second operand.
|
If CODE isn't an EQ_EXPR, BIT_XOR_EXPR, or BIT_NOT_EXPR, then return. */
|
If CODE isn't an EQ_EXPR, BIT_XOR_EXPR, or BIT_NOT_EXPR, then return. */
|
if (code == EQ_EXPR || code == NE_EXPR
|
if (code == EQ_EXPR || code == NE_EXPR
|
|| code == BIT_XOR_EXPR)
|
|| code == BIT_XOR_EXPR)
|
op2 = gimple_assign_rhs2 (def);
|
op2 = gimple_assign_rhs2 (def);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case BIT_NOT_EXPR:
|
case BIT_NOT_EXPR:
|
if (truth_valued_ssa_name (name))
|
if (truth_valued_ssa_name (name))
|
return op1;
|
return op1;
|
break;
|
break;
|
case EQ_EXPR:
|
case EQ_EXPR:
|
/* Check if we have X == 0 and X has an integral type. */
|
/* Check if we have X == 0 and X has an integral type. */
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op1)))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op1)))
|
break;
|
break;
|
if (integer_zerop (op2))
|
if (integer_zerop (op2))
|
return op1;
|
return op1;
|
break;
|
break;
|
case NE_EXPR:
|
case NE_EXPR:
|
/* Check if we have X != 1 and X is a truth-valued. */
|
/* Check if we have X != 1 and X is a truth-valued. */
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op1)))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op1)))
|
break;
|
break;
|
if (integer_onep (op2) && truth_valued_ssa_name (op1))
|
if (integer_onep (op2) && truth_valued_ssa_name (op1))
|
return op1;
|
return op1;
|
break;
|
break;
|
case BIT_XOR_EXPR:
|
case BIT_XOR_EXPR:
|
/* Check if we have X ^ 1 and X is truth valued. */
|
/* Check if we have X ^ 1 and X is truth valued. */
|
if (integer_onep (op2) && truth_valued_ssa_name (op1))
|
if (integer_onep (op2) && truth_valued_ssa_name (op1))
|
return op1;
|
return op1;
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Optimize ARG1 CODE ARG2 to a constant for bitwise binary
|
/* Optimize ARG1 CODE ARG2 to a constant for bitwise binary
|
operations CODE, if one operand has the logically inverted
|
operations CODE, if one operand has the logically inverted
|
value of the other. */
|
value of the other. */
|
static tree
|
static tree
|
simplify_bitwise_binary_1 (enum tree_code code, tree type,
|
simplify_bitwise_binary_1 (enum tree_code code, tree type,
|
tree arg1, tree arg2)
|
tree arg1, tree arg2)
|
{
|
{
|
tree anot;
|
tree anot;
|
|
|
/* If CODE isn't a bitwise binary operation, return NULL_TREE. */
|
/* If CODE isn't a bitwise binary operation, return NULL_TREE. */
|
if (code != BIT_AND_EXPR && code != BIT_IOR_EXPR
|
if (code != BIT_AND_EXPR && code != BIT_IOR_EXPR
|
&& code != BIT_XOR_EXPR)
|
&& code != BIT_XOR_EXPR)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* First check if operands ARG1 and ARG2 are equal. If so
|
/* First check if operands ARG1 and ARG2 are equal. If so
|
return NULL_TREE as this optimization is handled fold_stmt. */
|
return NULL_TREE as this optimization is handled fold_stmt. */
|
if (arg1 == arg2)
|
if (arg1 == arg2)
|
return NULL_TREE;
|
return NULL_TREE;
|
/* See if we have in arguments logical-not patterns. */
|
/* See if we have in arguments logical-not patterns. */
|
if (((anot = lookup_logical_inverted_value (arg1)) == NULL_TREE
|
if (((anot = lookup_logical_inverted_value (arg1)) == NULL_TREE
|
|| anot != arg2)
|
|| anot != arg2)
|
&& ((anot = lookup_logical_inverted_value (arg2)) == NULL_TREE
|
&& ((anot = lookup_logical_inverted_value (arg2)) == NULL_TREE
|
|| anot != arg1))
|
|| anot != arg1))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* X & !X -> 0. */
|
/* X & !X -> 0. */
|
if (code == BIT_AND_EXPR)
|
if (code == BIT_AND_EXPR)
|
return fold_convert (type, integer_zero_node);
|
return fold_convert (type, integer_zero_node);
|
/* X | !X -> 1 and X ^ !X -> 1, if X is truth-valued. */
|
/* X | !X -> 1 and X ^ !X -> 1, if X is truth-valued. */
|
if (truth_valued_ssa_name (anot))
|
if (truth_valued_ssa_name (anot))
|
return fold_convert (type, integer_one_node);
|
return fold_convert (type, integer_one_node);
|
|
|
/* ??? Otherwise result is (X != 0 ? X : 1). not handled. */
|
/* ??? Otherwise result is (X != 0 ? X : 1). not handled. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Simplify bitwise binary operations.
|
/* Simplify bitwise binary operations.
|
Return true if a transformation applied, otherwise return false. */
|
Return true if a transformation applied, otherwise return false. */
|
|
|
static bool
|
static bool
|
simplify_bitwise_binary (gimple_stmt_iterator *gsi)
|
simplify_bitwise_binary (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
tree arg1 = gimple_assign_rhs1 (stmt);
|
tree arg1 = gimple_assign_rhs1 (stmt);
|
tree arg2 = gimple_assign_rhs2 (stmt);
|
tree arg2 = gimple_assign_rhs2 (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
tree res;
|
tree res;
|
gimple def1 = NULL, def2 = NULL;
|
gimple def1 = NULL, def2 = NULL;
|
tree def1_arg1, def2_arg1;
|
tree def1_arg1, def2_arg1;
|
enum tree_code def1_code, def2_code;
|
enum tree_code def1_code, def2_code;
|
|
|
def1_code = TREE_CODE (arg1);
|
def1_code = TREE_CODE (arg1);
|
def1_arg1 = arg1;
|
def1_arg1 = arg1;
|
if (TREE_CODE (arg1) == SSA_NAME)
|
if (TREE_CODE (arg1) == SSA_NAME)
|
{
|
{
|
def1 = SSA_NAME_DEF_STMT (arg1);
|
def1 = SSA_NAME_DEF_STMT (arg1);
|
if (is_gimple_assign (def1))
|
if (is_gimple_assign (def1))
|
{
|
{
|
def1_code = gimple_assign_rhs_code (def1);
|
def1_code = gimple_assign_rhs_code (def1);
|
def1_arg1 = gimple_assign_rhs1 (def1);
|
def1_arg1 = gimple_assign_rhs1 (def1);
|
}
|
}
|
}
|
}
|
|
|
def2_code = TREE_CODE (arg2);
|
def2_code = TREE_CODE (arg2);
|
def2_arg1 = arg2;
|
def2_arg1 = arg2;
|
if (TREE_CODE (arg2) == SSA_NAME)
|
if (TREE_CODE (arg2) == SSA_NAME)
|
{
|
{
|
def2 = SSA_NAME_DEF_STMT (arg2);
|
def2 = SSA_NAME_DEF_STMT (arg2);
|
if (is_gimple_assign (def2))
|
if (is_gimple_assign (def2))
|
{
|
{
|
def2_code = gimple_assign_rhs_code (def2);
|
def2_code = gimple_assign_rhs_code (def2);
|
def2_arg1 = gimple_assign_rhs1 (def2);
|
def2_arg1 = gimple_assign_rhs1 (def2);
|
}
|
}
|
}
|
}
|
|
|
/* Try to fold (type) X op CST -> (type) (X op ((type-x) CST)). */
|
/* Try to fold (type) X op CST -> (type) (X op ((type-x) CST)). */
|
if (TREE_CODE (arg2) == INTEGER_CST
|
if (TREE_CODE (arg2) == INTEGER_CST
|
&& CONVERT_EXPR_CODE_P (def1_code)
|
&& CONVERT_EXPR_CODE_P (def1_code)
|
&& INTEGRAL_TYPE_P (TREE_TYPE (def1_arg1))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (def1_arg1))
|
&& int_fits_type_p (arg2, TREE_TYPE (def1_arg1)))
|
&& int_fits_type_p (arg2, TREE_TYPE (def1_arg1)))
|
{
|
{
|
gimple newop;
|
gimple newop;
|
tree tem = create_tmp_reg (TREE_TYPE (def1_arg1), NULL);
|
tree tem = create_tmp_reg (TREE_TYPE (def1_arg1), NULL);
|
newop =
|
newop =
|
gimple_build_assign_with_ops (code, tem, def1_arg1,
|
gimple_build_assign_with_ops (code, tem, def1_arg1,
|
fold_convert_loc (gimple_location (stmt),
|
fold_convert_loc (gimple_location (stmt),
|
TREE_TYPE (def1_arg1),
|
TREE_TYPE (def1_arg1),
|
arg2));
|
arg2));
|
tem = make_ssa_name (tem, newop);
|
tem = make_ssa_name (tem, newop);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_set_location (newop, gimple_location (stmt));
|
gimple_set_location (newop, gimple_location (stmt));
|
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
|
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
|
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
|
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
|
tem, NULL_TREE, NULL_TREE);
|
tem, NULL_TREE, NULL_TREE);
|
update_stmt (gsi_stmt (*gsi));
|
update_stmt (gsi_stmt (*gsi));
|
return true;
|
return true;
|
}
|
}
|
|
|
/* For bitwise binary operations apply operand conversions to the
|
/* For bitwise binary operations apply operand conversions to the
|
binary operation result instead of to the operands. This allows
|
binary operation result instead of to the operands. This allows
|
to combine successive conversions and bitwise binary operations. */
|
to combine successive conversions and bitwise binary operations. */
|
if (CONVERT_EXPR_CODE_P (def1_code)
|
if (CONVERT_EXPR_CODE_P (def1_code)
|
&& CONVERT_EXPR_CODE_P (def2_code)
|
&& CONVERT_EXPR_CODE_P (def2_code)
|
&& types_compatible_p (TREE_TYPE (def1_arg1), TREE_TYPE (def2_arg1))
|
&& types_compatible_p (TREE_TYPE (def1_arg1), TREE_TYPE (def2_arg1))
|
/* Make sure that the conversion widens the operands, or has same
|
/* Make sure that the conversion widens the operands, or has same
|
precision, or that it changes the operation to a bitfield
|
precision, or that it changes the operation to a bitfield
|
precision. */
|
precision. */
|
&& ((TYPE_PRECISION (TREE_TYPE (def1_arg1))
|
&& ((TYPE_PRECISION (TREE_TYPE (def1_arg1))
|
<= TYPE_PRECISION (TREE_TYPE (arg1)))
|
<= TYPE_PRECISION (TREE_TYPE (arg1)))
|
|| (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (arg1)))
|
|| (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (arg1)))
|
!= MODE_INT)
|
!= MODE_INT)
|
|| (TYPE_PRECISION (TREE_TYPE (arg1))
|
|| (TYPE_PRECISION (TREE_TYPE (arg1))
|
!= GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg1))))))
|
!= GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg1))))))
|
{
|
{
|
gimple newop;
|
gimple newop;
|
tree tem = create_tmp_reg (TREE_TYPE (def1_arg1),
|
tree tem = create_tmp_reg (TREE_TYPE (def1_arg1),
|
NULL);
|
NULL);
|
newop = gimple_build_assign_with_ops (code, tem, def1_arg1, def2_arg1);
|
newop = gimple_build_assign_with_ops (code, tem, def1_arg1, def2_arg1);
|
tem = make_ssa_name (tem, newop);
|
tem = make_ssa_name (tem, newop);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_set_location (newop, gimple_location (stmt));
|
gimple_set_location (newop, gimple_location (stmt));
|
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
|
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
|
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
|
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
|
tem, NULL_TREE, NULL_TREE);
|
tem, NULL_TREE, NULL_TREE);
|
update_stmt (gsi_stmt (*gsi));
|
update_stmt (gsi_stmt (*gsi));
|
return true;
|
return true;
|
}
|
}
|
|
|
/* (a | CST1) & CST2 -> (a & CST2) | (CST1 & CST2). */
|
/* (a | CST1) & CST2 -> (a & CST2) | (CST1 & CST2). */
|
if (code == BIT_AND_EXPR
|
if (code == BIT_AND_EXPR
|
&& def1_code == BIT_IOR_EXPR
|
&& def1_code == BIT_IOR_EXPR
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& TREE_CODE (gimple_assign_rhs2 (def1)) == INTEGER_CST)
|
&& TREE_CODE (gimple_assign_rhs2 (def1)) == INTEGER_CST)
|
{
|
{
|
tree cst = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg2),
|
tree cst = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg2),
|
arg2, gimple_assign_rhs2 (def1));
|
arg2, gimple_assign_rhs2 (def1));
|
tree tem;
|
tree tem;
|
gimple newop;
|
gimple newop;
|
if (integer_zerop (cst))
|
if (integer_zerop (cst))
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, def1_arg1);
|
gimple_assign_set_rhs1 (stmt, def1_arg1);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
tem = create_tmp_reg (TREE_TYPE (arg2), NULL);
|
tem = create_tmp_reg (TREE_TYPE (arg2), NULL);
|
newop = gimple_build_assign_with_ops (BIT_AND_EXPR,
|
newop = gimple_build_assign_with_ops (BIT_AND_EXPR,
|
tem, def1_arg1, arg2);
|
tem, def1_arg1, arg2);
|
tem = make_ssa_name (tem, newop);
|
tem = make_ssa_name (tem, newop);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_assign_set_lhs (newop, tem);
|
gimple_set_location (newop, gimple_location (stmt));
|
gimple_set_location (newop, gimple_location (stmt));
|
/* Make sure to re-process the new stmt as it's walking upwards. */
|
/* Make sure to re-process the new stmt as it's walking upwards. */
|
gsi_insert_before (gsi, newop, GSI_NEW_STMT);
|
gsi_insert_before (gsi, newop, GSI_NEW_STMT);
|
gimple_assign_set_rhs1 (stmt, tem);
|
gimple_assign_set_rhs1 (stmt, tem);
|
gimple_assign_set_rhs2 (stmt, cst);
|
gimple_assign_set_rhs2 (stmt, cst);
|
gimple_assign_set_rhs_code (stmt, BIT_IOR_EXPR);
|
gimple_assign_set_rhs_code (stmt, BIT_IOR_EXPR);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Combine successive equal operations with constants. */
|
/* Combine successive equal operations with constants. */
|
if ((code == BIT_AND_EXPR
|
if ((code == BIT_AND_EXPR
|
|| code == BIT_IOR_EXPR
|
|| code == BIT_IOR_EXPR
|
|| code == BIT_XOR_EXPR)
|
|| code == BIT_XOR_EXPR)
|
&& def1_code == code
|
&& def1_code == code
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& TREE_CODE (gimple_assign_rhs2 (def1)) == INTEGER_CST)
|
&& TREE_CODE (gimple_assign_rhs2 (def1)) == INTEGER_CST)
|
{
|
{
|
tree cst = fold_build2 (code, TREE_TYPE (arg2),
|
tree cst = fold_build2 (code, TREE_TYPE (arg2),
|
arg2, gimple_assign_rhs2 (def1));
|
arg2, gimple_assign_rhs2 (def1));
|
gimple_assign_set_rhs1 (stmt, def1_arg1);
|
gimple_assign_set_rhs1 (stmt, def1_arg1);
|
gimple_assign_set_rhs2 (stmt, cst);
|
gimple_assign_set_rhs2 (stmt, cst);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Canonicalize X ^ ~0 to ~X. */
|
/* Canonicalize X ^ ~0 to ~X. */
|
if (code == BIT_XOR_EXPR
|
if (code == BIT_XOR_EXPR
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& TREE_CODE (arg2) == INTEGER_CST
|
&& integer_all_onesp (arg2))
|
&& integer_all_onesp (arg2))
|
{
|
{
|
gimple_assign_set_rhs_with_ops (gsi, BIT_NOT_EXPR, arg1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, BIT_NOT_EXPR, arg1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Try simple folding for X op !X, and X op X. */
|
/* Try simple folding for X op !X, and X op X. */
|
res = simplify_bitwise_binary_1 (code, TREE_TYPE (arg1), arg1, arg2);
|
res = simplify_bitwise_binary_1 (code, TREE_TYPE (arg1), arg1, arg2);
|
if (res != NULL_TREE)
|
if (res != NULL_TREE)
|
{
|
{
|
gimple_assign_set_rhs_from_tree (gsi, res);
|
gimple_assign_set_rhs_from_tree (gsi, res);
|
update_stmt (gsi_stmt (*gsi));
|
update_stmt (gsi_stmt (*gsi));
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Perform re-associations of the plus or minus statement STMT that are
|
/* Perform re-associations of the plus or minus statement STMT that are
|
always permitted. Returns true if the CFG was changed. */
|
always permitted. Returns true if the CFG was changed. */
|
|
|
static bool
|
static bool
|
associate_plusminus (gimple_stmt_iterator *gsi)
|
associate_plusminus (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
tree rhs2 = gimple_assign_rhs2 (stmt);
|
tree rhs2 = gimple_assign_rhs2 (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
bool changed;
|
bool changed;
|
|
|
/* We can't reassociate at all for saturating types. */
|
/* We can't reassociate at all for saturating types. */
|
if (TYPE_SATURATING (TREE_TYPE (rhs1)))
|
if (TYPE_SATURATING (TREE_TYPE (rhs1)))
|
return false;
|
return false;
|
|
|
/* First contract negates. */
|
/* First contract negates. */
|
do
|
do
|
{
|
{
|
changed = false;
|
changed = false;
|
|
|
/* A +- (-B) -> A -+ B. */
|
/* A +- (-B) -> A -+ B. */
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
if (TREE_CODE (rhs2) == SSA_NAME)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
|
if (is_gimple_assign (def_stmt)
|
if (is_gimple_assign (def_stmt)
|
&& gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
|
&& gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
|
&& can_propagate_from (def_stmt))
|
&& can_propagate_from (def_stmt))
|
{
|
{
|
code = (code == MINUS_EXPR) ? PLUS_EXPR : MINUS_EXPR;
|
code = (code == MINUS_EXPR) ? PLUS_EXPR : MINUS_EXPR;
|
gimple_assign_set_rhs_code (stmt, code);
|
gimple_assign_set_rhs_code (stmt, code);
|
rhs2 = gimple_assign_rhs1 (def_stmt);
|
rhs2 = gimple_assign_rhs1 (def_stmt);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
changed = true;
|
changed = true;
|
}
|
}
|
}
|
}
|
|
|
/* (-A) + B -> B - A. */
|
/* (-A) + B -> B - A. */
|
if (TREE_CODE (rhs1) == SSA_NAME
|
if (TREE_CODE (rhs1) == SSA_NAME
|
&& code == PLUS_EXPR)
|
&& code == PLUS_EXPR)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
|
if (is_gimple_assign (def_stmt)
|
if (is_gimple_assign (def_stmt)
|
&& gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
|
&& gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
|
&& can_propagate_from (def_stmt))
|
&& can_propagate_from (def_stmt))
|
{
|
{
|
code = MINUS_EXPR;
|
code = MINUS_EXPR;
|
gimple_assign_set_rhs_code (stmt, code);
|
gimple_assign_set_rhs_code (stmt, code);
|
rhs1 = rhs2;
|
rhs1 = rhs2;
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
rhs2 = gimple_assign_rhs1 (def_stmt);
|
rhs2 = gimple_assign_rhs1 (def_stmt);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
changed = true;
|
changed = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
while (changed);
|
while (changed);
|
|
|
/* We can't reassociate floating-point or fixed-point plus or minus
|
/* We can't reassociate floating-point or fixed-point plus or minus
|
because of saturation to +-Inf. */
|
because of saturation to +-Inf. */
|
if (FLOAT_TYPE_P (TREE_TYPE (rhs1))
|
if (FLOAT_TYPE_P (TREE_TYPE (rhs1))
|
|| FIXED_POINT_TYPE_P (TREE_TYPE (rhs1)))
|
|| FIXED_POINT_TYPE_P (TREE_TYPE (rhs1)))
|
goto out;
|
goto out;
|
|
|
/* Second match patterns that allow contracting a plus-minus pair
|
/* Second match patterns that allow contracting a plus-minus pair
|
irrespective of overflow issues.
|
irrespective of overflow issues.
|
|
|
(A +- B) - A -> +- B
|
(A +- B) - A -> +- B
|
(A +- B) -+ B -> A
|
(A +- B) -+ B -> A
|
(CST +- A) +- CST -> CST +- A
|
(CST +- A) +- CST -> CST +- A
|
(A + CST) +- CST -> A + CST
|
(A + CST) +- CST -> A + CST
|
~A + A -> -1
|
~A + A -> -1
|
~A + 1 -> -A
|
~A + 1 -> -A
|
A - (A +- B) -> -+ B
|
A - (A +- B) -> -+ B
|
A +- (B +- A) -> +- B
|
A +- (B +- A) -> +- B
|
CST +- (CST +- A) -> CST +- A
|
CST +- (CST +- A) -> CST +- A
|
CST +- (A +- CST) -> CST +- A
|
CST +- (A +- CST) -> CST +- A
|
A + ~A -> -1
|
A + ~A -> -1
|
|
|
via commutating the addition and contracting operations to zero
|
via commutating the addition and contracting operations to zero
|
by reassociation. */
|
by reassociation. */
|
|
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
if (TREE_CODE (rhs1) == SSA_NAME)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
|
if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
|
if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
|
{
|
{
|
enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
|
enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
|
if (def_code == PLUS_EXPR
|
if (def_code == PLUS_EXPR
|
|| def_code == MINUS_EXPR)
|
|| def_code == MINUS_EXPR)
|
{
|
{
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
|
tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
|
if (operand_equal_p (def_rhs1, rhs2, 0)
|
if (operand_equal_p (def_rhs1, rhs2, 0)
|
&& code == MINUS_EXPR)
|
&& code == MINUS_EXPR)
|
{
|
{
|
/* (A +- B) - A -> +- B. */
|
/* (A +- B) - A -> +- B. */
|
code = ((def_code == PLUS_EXPR)
|
code = ((def_code == PLUS_EXPR)
|
? TREE_CODE (def_rhs2) : NEGATE_EXPR);
|
? TREE_CODE (def_rhs2) : NEGATE_EXPR);
|
rhs1 = def_rhs2;
|
rhs1 = def_rhs2;
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
else if (operand_equal_p (def_rhs2, rhs2, 0)
|
else if (operand_equal_p (def_rhs2, rhs2, 0)
|
&& code != def_code)
|
&& code != def_code)
|
{
|
{
|
/* (A +- B) -+ B -> A. */
|
/* (A +- B) -+ B -> A. */
|
code = TREE_CODE (def_rhs1);
|
code = TREE_CODE (def_rhs1);
|
rhs1 = def_rhs1;
|
rhs1 = def_rhs1;
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
else if (TREE_CODE (rhs2) == INTEGER_CST
|
else if (TREE_CODE (rhs2) == INTEGER_CST
|
&& TREE_CODE (def_rhs1) == INTEGER_CST)
|
&& TREE_CODE (def_rhs1) == INTEGER_CST)
|
{
|
{
|
/* (CST +- A) +- CST -> CST +- A. */
|
/* (CST +- A) +- CST -> CST +- A. */
|
tree cst = fold_binary (code, TREE_TYPE (rhs1),
|
tree cst = fold_binary (code, TREE_TYPE (rhs1),
|
def_rhs1, rhs2);
|
def_rhs1, rhs2);
|
if (cst && !TREE_OVERFLOW (cst))
|
if (cst && !TREE_OVERFLOW (cst))
|
{
|
{
|
code = def_code;
|
code = def_code;
|
gimple_assign_set_rhs_code (stmt, code);
|
gimple_assign_set_rhs_code (stmt, code);
|
rhs1 = cst;
|
rhs1 = cst;
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
rhs2 = def_rhs2;
|
rhs2 = def_rhs2;
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (rhs2) == INTEGER_CST
|
else if (TREE_CODE (rhs2) == INTEGER_CST
|
&& TREE_CODE (def_rhs2) == INTEGER_CST
|
&& TREE_CODE (def_rhs2) == INTEGER_CST
|
&& def_code == PLUS_EXPR)
|
&& def_code == PLUS_EXPR)
|
{
|
{
|
/* (A + CST) +- CST -> A + CST. */
|
/* (A + CST) +- CST -> A + CST. */
|
tree cst = fold_binary (code, TREE_TYPE (rhs1),
|
tree cst = fold_binary (code, TREE_TYPE (rhs1),
|
def_rhs2, rhs2);
|
def_rhs2, rhs2);
|
if (cst && !TREE_OVERFLOW (cst))
|
if (cst && !TREE_OVERFLOW (cst))
|
{
|
{
|
code = PLUS_EXPR;
|
code = PLUS_EXPR;
|
gimple_assign_set_rhs_code (stmt, code);
|
gimple_assign_set_rhs_code (stmt, code);
|
rhs1 = def_rhs1;
|
rhs1 = def_rhs1;
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
rhs2 = cst;
|
rhs2 = cst;
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (def_code == BIT_NOT_EXPR
|
else if (def_code == BIT_NOT_EXPR
|
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs1)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs1)))
|
{
|
{
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
if (code == PLUS_EXPR
|
if (code == PLUS_EXPR
|
&& operand_equal_p (def_rhs1, rhs2, 0))
|
&& operand_equal_p (def_rhs1, rhs2, 0))
|
{
|
{
|
/* ~A + A -> -1. */
|
/* ~A + A -> -1. */
|
code = INTEGER_CST;
|
code = INTEGER_CST;
|
rhs1 = build_int_cst_type (TREE_TYPE (rhs2), -1);
|
rhs1 = build_int_cst_type (TREE_TYPE (rhs2), -1);
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
else if (code == PLUS_EXPR
|
else if (code == PLUS_EXPR
|
&& integer_onep (rhs1))
|
&& integer_onep (rhs1))
|
{
|
{
|
/* ~A + 1 -> -A. */
|
/* ~A + 1 -> -A. */
|
code = NEGATE_EXPR;
|
code = NEGATE_EXPR;
|
rhs1 = def_rhs1;
|
rhs1 = def_rhs1;
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (rhs2 && TREE_CODE (rhs2) == SSA_NAME)
|
if (rhs2 && TREE_CODE (rhs2) == SSA_NAME)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
|
gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
|
if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
|
if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
|
{
|
{
|
enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
|
enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
|
if (def_code == PLUS_EXPR
|
if (def_code == PLUS_EXPR
|
|| def_code == MINUS_EXPR)
|
|| def_code == MINUS_EXPR)
|
{
|
{
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
|
tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
|
if (operand_equal_p (def_rhs1, rhs1, 0)
|
if (operand_equal_p (def_rhs1, rhs1, 0)
|
&& code == MINUS_EXPR)
|
&& code == MINUS_EXPR)
|
{
|
{
|
/* A - (A +- B) -> -+ B. */
|
/* A - (A +- B) -> -+ B. */
|
code = ((def_code == PLUS_EXPR)
|
code = ((def_code == PLUS_EXPR)
|
? NEGATE_EXPR : TREE_CODE (def_rhs2));
|
? NEGATE_EXPR : TREE_CODE (def_rhs2));
|
rhs1 = def_rhs2;
|
rhs1 = def_rhs2;
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
else if (operand_equal_p (def_rhs2, rhs1, 0)
|
else if (operand_equal_p (def_rhs2, rhs1, 0)
|
&& code != def_code)
|
&& code != def_code)
|
{
|
{
|
/* A +- (B +- A) -> +- B. */
|
/* A +- (B +- A) -> +- B. */
|
code = ((code == PLUS_EXPR)
|
code = ((code == PLUS_EXPR)
|
? TREE_CODE (def_rhs1) : NEGATE_EXPR);
|
? TREE_CODE (def_rhs1) : NEGATE_EXPR);
|
rhs1 = def_rhs1;
|
rhs1 = def_rhs1;
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
else if (TREE_CODE (rhs1) == INTEGER_CST
|
else if (TREE_CODE (rhs1) == INTEGER_CST
|
&& TREE_CODE (def_rhs1) == INTEGER_CST)
|
&& TREE_CODE (def_rhs1) == INTEGER_CST)
|
{
|
{
|
/* CST +- (CST +- A) -> CST +- A. */
|
/* CST +- (CST +- A) -> CST +- A. */
|
tree cst = fold_binary (code, TREE_TYPE (rhs2),
|
tree cst = fold_binary (code, TREE_TYPE (rhs2),
|
rhs1, def_rhs1);
|
rhs1, def_rhs1);
|
if (cst && !TREE_OVERFLOW (cst))
|
if (cst && !TREE_OVERFLOW (cst))
|
{
|
{
|
code = (code == def_code ? PLUS_EXPR : MINUS_EXPR);
|
code = (code == def_code ? PLUS_EXPR : MINUS_EXPR);
|
gimple_assign_set_rhs_code (stmt, code);
|
gimple_assign_set_rhs_code (stmt, code);
|
rhs1 = cst;
|
rhs1 = cst;
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
rhs2 = def_rhs2;
|
rhs2 = def_rhs2;
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (rhs1) == INTEGER_CST
|
else if (TREE_CODE (rhs1) == INTEGER_CST
|
&& TREE_CODE (def_rhs2) == INTEGER_CST)
|
&& TREE_CODE (def_rhs2) == INTEGER_CST)
|
{
|
{
|
/* CST +- (A +- CST) -> CST +- A. */
|
/* CST +- (A +- CST) -> CST +- A. */
|
tree cst = fold_binary (def_code == code
|
tree cst = fold_binary (def_code == code
|
? PLUS_EXPR : MINUS_EXPR,
|
? PLUS_EXPR : MINUS_EXPR,
|
TREE_TYPE (rhs2),
|
TREE_TYPE (rhs2),
|
rhs1, def_rhs2);
|
rhs1, def_rhs2);
|
if (cst && !TREE_OVERFLOW (cst))
|
if (cst && !TREE_OVERFLOW (cst))
|
{
|
{
|
rhs1 = cst;
|
rhs1 = cst;
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
gimple_assign_set_rhs1 (stmt, rhs1);
|
rhs2 = def_rhs1;
|
rhs2 = def_rhs1;
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_assign_set_rhs2 (stmt, rhs2);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (def_code == BIT_NOT_EXPR
|
else if (def_code == BIT_NOT_EXPR
|
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs2)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (rhs2)))
|
{
|
{
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
|
if (code == PLUS_EXPR
|
if (code == PLUS_EXPR
|
&& operand_equal_p (def_rhs1, rhs1, 0))
|
&& operand_equal_p (def_rhs1, rhs1, 0))
|
{
|
{
|
/* A + ~A -> -1. */
|
/* A + ~A -> -1. */
|
code = INTEGER_CST;
|
code = INTEGER_CST;
|
rhs1 = build_int_cst_type (TREE_TYPE (rhs1), -1);
|
rhs1 = build_int_cst_type (TREE_TYPE (rhs1), -1);
|
rhs2 = NULL_TREE;
|
rhs2 = NULL_TREE;
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gcc_assert (gsi_stmt (*gsi) == stmt);
|
gimple_set_modified (stmt, true);
|
gimple_set_modified (stmt, true);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
out:
|
out:
|
if (gimple_modified_p (stmt))
|
if (gimple_modified_p (stmt))
|
{
|
{
|
fold_stmt_inplace (gsi);
|
fold_stmt_inplace (gsi);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
|
&& gimple_purge_dead_eh_edges (gimple_bb (stmt)))
|
&& gimple_purge_dead_eh_edges (gimple_bb (stmt)))
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Combine two conversions in a row for the second conversion at *GSI.
|
/* Combine two conversions in a row for the second conversion at *GSI.
|
Returns 1 if there were any changes made, 2 if cfg-cleanup needs to
|
Returns 1 if there were any changes made, 2 if cfg-cleanup needs to
|
run. Else it returns 0. */
|
run. Else it returns 0. */
|
|
|
static int
|
static int
|
combine_conversions (gimple_stmt_iterator *gsi)
|
combine_conversions (gimple_stmt_iterator *gsi)
|
{
|
{
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
gimple def_stmt;
|
gimple def_stmt;
|
tree op0, lhs;
|
tree op0, lhs;
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
|
|
gcc_checking_assert (CONVERT_EXPR_CODE_P (code)
|
gcc_checking_assert (CONVERT_EXPR_CODE_P (code)
|
|| code == FLOAT_EXPR
|
|| code == FLOAT_EXPR
|
|| code == FIX_TRUNC_EXPR);
|
|| code == FIX_TRUNC_EXPR);
|
|
|
lhs = gimple_assign_lhs (stmt);
|
lhs = gimple_assign_lhs (stmt);
|
op0 = gimple_assign_rhs1 (stmt);
|
op0 = gimple_assign_rhs1 (stmt);
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (op0)))
|
if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (op0)))
|
{
|
{
|
gimple_assign_set_rhs_code (stmt, TREE_CODE (op0));
|
gimple_assign_set_rhs_code (stmt, TREE_CODE (op0));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
if (TREE_CODE (op0) != SSA_NAME)
|
if (TREE_CODE (op0) != SSA_NAME)
|
return 0;
|
return 0;
|
|
|
def_stmt = SSA_NAME_DEF_STMT (op0);
|
def_stmt = SSA_NAME_DEF_STMT (op0);
|
if (!is_gimple_assign (def_stmt))
|
if (!is_gimple_assign (def_stmt))
|
return 0;
|
return 0;
|
|
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
|
if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
|
{
|
{
|
tree defop0 = gimple_assign_rhs1 (def_stmt);
|
tree defop0 = gimple_assign_rhs1 (def_stmt);
|
tree type = TREE_TYPE (lhs);
|
tree type = TREE_TYPE (lhs);
|
tree inside_type = TREE_TYPE (defop0);
|
tree inside_type = TREE_TYPE (defop0);
|
tree inter_type = TREE_TYPE (op0);
|
tree inter_type = TREE_TYPE (op0);
|
int inside_int = INTEGRAL_TYPE_P (inside_type);
|
int inside_int = INTEGRAL_TYPE_P (inside_type);
|
int inside_ptr = POINTER_TYPE_P (inside_type);
|
int inside_ptr = POINTER_TYPE_P (inside_type);
|
int inside_float = FLOAT_TYPE_P (inside_type);
|
int inside_float = FLOAT_TYPE_P (inside_type);
|
int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
|
int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
|
unsigned int inside_prec = TYPE_PRECISION (inside_type);
|
unsigned int inside_prec = TYPE_PRECISION (inside_type);
|
int inside_unsignedp = TYPE_UNSIGNED (inside_type);
|
int inside_unsignedp = TYPE_UNSIGNED (inside_type);
|
int inter_int = INTEGRAL_TYPE_P (inter_type);
|
int inter_int = INTEGRAL_TYPE_P (inter_type);
|
int inter_ptr = POINTER_TYPE_P (inter_type);
|
int inter_ptr = POINTER_TYPE_P (inter_type);
|
int inter_float = FLOAT_TYPE_P (inter_type);
|
int inter_float = FLOAT_TYPE_P (inter_type);
|
int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
|
int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
|
unsigned int inter_prec = TYPE_PRECISION (inter_type);
|
unsigned int inter_prec = TYPE_PRECISION (inter_type);
|
int inter_unsignedp = TYPE_UNSIGNED (inter_type);
|
int inter_unsignedp = TYPE_UNSIGNED (inter_type);
|
int final_int = INTEGRAL_TYPE_P (type);
|
int final_int = INTEGRAL_TYPE_P (type);
|
int final_ptr = POINTER_TYPE_P (type);
|
int final_ptr = POINTER_TYPE_P (type);
|
int final_float = FLOAT_TYPE_P (type);
|
int final_float = FLOAT_TYPE_P (type);
|
int final_vec = TREE_CODE (type) == VECTOR_TYPE;
|
int final_vec = TREE_CODE (type) == VECTOR_TYPE;
|
unsigned int final_prec = TYPE_PRECISION (type);
|
unsigned int final_prec = TYPE_PRECISION (type);
|
int final_unsignedp = TYPE_UNSIGNED (type);
|
int final_unsignedp = TYPE_UNSIGNED (type);
|
|
|
/* In addition to the cases of two conversions in a row
|
/* In addition to the cases of two conversions in a row
|
handled below, if we are converting something to its own
|
handled below, if we are converting something to its own
|
type via an object of identical or wider precision, neither
|
type via an object of identical or wider precision, neither
|
conversion is needed. */
|
conversion is needed. */
|
if (useless_type_conversion_p (type, inside_type)
|
if (useless_type_conversion_p (type, inside_type)
|
&& (((inter_int || inter_ptr) && final_int)
|
&& (((inter_int || inter_ptr) && final_int)
|
|| (inter_float && final_float))
|
|| (inter_float && final_float))
|
&& inter_prec >= final_prec)
|
&& inter_prec >= final_prec)
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, unshare_expr (defop0));
|
gimple_assign_set_rhs1 (stmt, unshare_expr (defop0));
|
gimple_assign_set_rhs_code (stmt, TREE_CODE (defop0));
|
gimple_assign_set_rhs_code (stmt, TREE_CODE (defop0));
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
}
|
}
|
|
|
/* Likewise, if the intermediate and initial types are either both
|
/* Likewise, if the intermediate and initial types are either both
|
float or both integer, we don't need the middle conversion if the
|
float or both integer, we don't need the middle conversion if the
|
former is wider than the latter and doesn't change the signedness
|
former is wider than the latter and doesn't change the signedness
|
(for integers). Avoid this if the final type is a pointer since
|
(for integers). Avoid this if the final type is a pointer since
|
then we sometimes need the middle conversion. Likewise if the
|
then we sometimes need the middle conversion. Likewise if the
|
final type has a precision not equal to the size of its mode. */
|
final type has a precision not equal to the size of its mode. */
|
if (((inter_int && inside_int)
|
if (((inter_int && inside_int)
|
|| (inter_float && inside_float)
|
|| (inter_float && inside_float)
|
|| (inter_vec && inside_vec))
|
|| (inter_vec && inside_vec))
|
&& inter_prec >= inside_prec
|
&& inter_prec >= inside_prec
|
&& (inter_float || inter_vec
|
&& (inter_float || inter_vec
|
|| inter_unsignedp == inside_unsignedp)
|
|| inter_unsignedp == inside_unsignedp)
|
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
|
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
|
&& TYPE_MODE (type) == TYPE_MODE (inter_type))
|
&& TYPE_MODE (type) == TYPE_MODE (inter_type))
|
&& ! final_ptr
|
&& ! final_ptr
|
&& (! final_vec || inter_prec == inside_prec))
|
&& (! final_vec || inter_prec == inside_prec))
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, defop0);
|
gimple_assign_set_rhs1 (stmt, defop0);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
}
|
}
|
|
|
/* If we have a sign-extension of a zero-extended value, we can
|
/* If we have a sign-extension of a zero-extended value, we can
|
replace that by a single zero-extension. */
|
replace that by a single zero-extension. */
|
if (inside_int && inter_int && final_int
|
if (inside_int && inter_int && final_int
|
&& inside_prec < inter_prec && inter_prec < final_prec
|
&& inside_prec < inter_prec && inter_prec < final_prec
|
&& inside_unsignedp && !inter_unsignedp)
|
&& inside_unsignedp && !inter_unsignedp)
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, defop0);
|
gimple_assign_set_rhs1 (stmt, defop0);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
}
|
}
|
|
|
/* Two conversions in a row are not needed unless:
|
/* Two conversions in a row are not needed unless:
|
- some conversion is floating-point (overstrict for now), or
|
- some conversion is floating-point (overstrict for now), or
|
- some conversion is a vector (overstrict for now), or
|
- some conversion is a vector (overstrict for now), or
|
- the intermediate type is narrower than both initial and
|
- the intermediate type is narrower than both initial and
|
final, or
|
final, or
|
- the intermediate type and innermost type differ in signedness,
|
- the intermediate type and innermost type differ in signedness,
|
and the outermost type is wider than the intermediate, or
|
and the outermost type is wider than the intermediate, or
|
- the initial type is a pointer type and the precisions of the
|
- the initial type is a pointer type and the precisions of the
|
intermediate and final types differ, or
|
intermediate and final types differ, or
|
- the final type is a pointer type and the precisions of the
|
- the final type is a pointer type and the precisions of the
|
initial and intermediate types differ. */
|
initial and intermediate types differ. */
|
if (! inside_float && ! inter_float && ! final_float
|
if (! inside_float && ! inter_float && ! final_float
|
&& ! inside_vec && ! inter_vec && ! final_vec
|
&& ! inside_vec && ! inter_vec && ! final_vec
|
&& (inter_prec >= inside_prec || inter_prec >= final_prec)
|
&& (inter_prec >= inside_prec || inter_prec >= final_prec)
|
&& ! (inside_int && inter_int
|
&& ! (inside_int && inter_int
|
&& inter_unsignedp != inside_unsignedp
|
&& inter_unsignedp != inside_unsignedp
|
&& inter_prec < final_prec)
|
&& inter_prec < final_prec)
|
&& ((inter_unsignedp && inter_prec > inside_prec)
|
&& ((inter_unsignedp && inter_prec > inside_prec)
|
== (final_unsignedp && final_prec > inter_prec))
|
== (final_unsignedp && final_prec > inter_prec))
|
&& ! (inside_ptr && inter_prec != final_prec)
|
&& ! (inside_ptr && inter_prec != final_prec)
|
&& ! (final_ptr && inside_prec != inter_prec)
|
&& ! (final_ptr && inside_prec != inter_prec)
|
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
|
&& ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
|
&& TYPE_MODE (type) == TYPE_MODE (inter_type)))
|
&& TYPE_MODE (type) == TYPE_MODE (inter_type)))
|
{
|
{
|
gimple_assign_set_rhs1 (stmt, defop0);
|
gimple_assign_set_rhs1 (stmt, defop0);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
return remove_prop_source_from_use (op0) ? 2 : 1;
|
}
|
}
|
|
|
/* A truncation to an unsigned type should be canonicalized as
|
/* A truncation to an unsigned type should be canonicalized as
|
bitwise and of a mask. */
|
bitwise and of a mask. */
|
if (final_int && inter_int && inside_int
|
if (final_int && inter_int && inside_int
|
&& final_prec == inside_prec
|
&& final_prec == inside_prec
|
&& final_prec > inter_prec
|
&& final_prec > inter_prec
|
&& inter_unsignedp)
|
&& inter_unsignedp)
|
{
|
{
|
tree tem;
|
tree tem;
|
tem = fold_build2 (BIT_AND_EXPR, inside_type,
|
tem = fold_build2 (BIT_AND_EXPR, inside_type,
|
defop0,
|
defop0,
|
double_int_to_tree
|
double_int_to_tree
|
(inside_type, double_int_mask (inter_prec)));
|
(inside_type, double_int_mask (inter_prec)));
|
if (!useless_type_conversion_p (type, inside_type))
|
if (!useless_type_conversion_p (type, inside_type))
|
{
|
{
|
tem = force_gimple_operand_gsi (gsi, tem, true, NULL_TREE, true,
|
tem = force_gimple_operand_gsi (gsi, tem, true, NULL_TREE, true,
|
GSI_SAME_STMT);
|
GSI_SAME_STMT);
|
gimple_assign_set_rhs1 (stmt, tem);
|
gimple_assign_set_rhs1 (stmt, tem);
|
}
|
}
|
else
|
else
|
gimple_assign_set_rhs_from_tree (gsi, tem);
|
gimple_assign_set_rhs_from_tree (gsi, tem);
|
update_stmt (gsi_stmt (*gsi));
|
update_stmt (gsi_stmt (*gsi));
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Main entry point for the forward propagation and statement combine
|
/* Main entry point for the forward propagation and statement combine
|
optimizer. */
|
optimizer. */
|
|
|
static unsigned int
|
static unsigned int
|
ssa_forward_propagate_and_combine (void)
|
ssa_forward_propagate_and_combine (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
unsigned int todoflags = 0;
|
unsigned int todoflags = 0;
|
|
|
cfg_changed = false;
|
cfg_changed = false;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
gimple_stmt_iterator gsi, prev;
|
gimple_stmt_iterator gsi, prev;
|
bool prev_initialized;
|
bool prev_initialized;
|
|
|
/* Apply forward propagation to all stmts in the basic-block.
|
/* Apply forward propagation to all stmts in the basic-block.
|
Note we update GSI within the loop as necessary. */
|
Note we update GSI within the loop as necessary. */
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
tree lhs, rhs;
|
tree lhs, rhs;
|
enum tree_code code;
|
enum tree_code code;
|
|
|
if (!is_gimple_assign (stmt))
|
if (!is_gimple_assign (stmt))
|
{
|
{
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
continue;
|
continue;
|
}
|
}
|
|
|
lhs = gimple_assign_lhs (stmt);
|
lhs = gimple_assign_lhs (stmt);
|
rhs = gimple_assign_rhs1 (stmt);
|
rhs = gimple_assign_rhs1 (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
code = gimple_assign_rhs_code (stmt);
|
if (TREE_CODE (lhs) != SSA_NAME
|
if (TREE_CODE (lhs) != SSA_NAME
|
|| has_zero_uses (lhs))
|
|| has_zero_uses (lhs))
|
{
|
{
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If this statement sets an SSA_NAME to an address,
|
/* If this statement sets an SSA_NAME to an address,
|
try to propagate the address into the uses of the SSA_NAME. */
|
try to propagate the address into the uses of the SSA_NAME. */
|
if (code == ADDR_EXPR
|
if (code == ADDR_EXPR
|
/* Handle pointer conversions on invariant addresses
|
/* Handle pointer conversions on invariant addresses
|
as well, as this is valid gimple. */
|
as well, as this is valid gimple. */
|
|| (CONVERT_EXPR_CODE_P (code)
|
|| (CONVERT_EXPR_CODE_P (code)
|
&& TREE_CODE (rhs) == ADDR_EXPR
|
&& TREE_CODE (rhs) == ADDR_EXPR
|
&& POINTER_TYPE_P (TREE_TYPE (lhs))))
|
&& POINTER_TYPE_P (TREE_TYPE (lhs))))
|
{
|
{
|
tree base = get_base_address (TREE_OPERAND (rhs, 0));
|
tree base = get_base_address (TREE_OPERAND (rhs, 0));
|
if ((!base
|
if ((!base
|
|| !DECL_P (base)
|
|| !DECL_P (base)
|
|| decl_address_invariant_p (base))
|
|| decl_address_invariant_p (base))
|
&& !stmt_references_abnormal_ssa_name (stmt)
|
&& !stmt_references_abnormal_ssa_name (stmt)
|
&& forward_propagate_addr_expr (lhs, rhs))
|
&& forward_propagate_addr_expr (lhs, rhs))
|
{
|
{
|
release_defs (stmt);
|
release_defs (stmt);
|
todoflags |= TODO_remove_unused_locals;
|
todoflags |= TODO_remove_unused_locals;
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
}
|
}
|
else
|
else
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
else if (code == POINTER_PLUS_EXPR)
|
else if (code == POINTER_PLUS_EXPR)
|
{
|
{
|
tree off = gimple_assign_rhs2 (stmt);
|
tree off = gimple_assign_rhs2 (stmt);
|
if (TREE_CODE (off) == INTEGER_CST
|
if (TREE_CODE (off) == INTEGER_CST
|
&& can_propagate_from (stmt)
|
&& can_propagate_from (stmt)
|
&& !simple_iv_increment_p (stmt)
|
&& !simple_iv_increment_p (stmt)
|
/* ??? Better adjust the interface to that function
|
/* ??? Better adjust the interface to that function
|
instead of building new trees here. */
|
instead of building new trees here. */
|
&& forward_propagate_addr_expr
|
&& forward_propagate_addr_expr
|
(lhs,
|
(lhs,
|
build1_loc (gimple_location (stmt),
|
build1_loc (gimple_location (stmt),
|
ADDR_EXPR, TREE_TYPE (rhs),
|
ADDR_EXPR, TREE_TYPE (rhs),
|
fold_build2 (MEM_REF,
|
fold_build2 (MEM_REF,
|
TREE_TYPE (TREE_TYPE (rhs)),
|
TREE_TYPE (TREE_TYPE (rhs)),
|
rhs,
|
rhs,
|
fold_convert (ptr_type_node,
|
fold_convert (ptr_type_node,
|
off)))))
|
off)))))
|
{
|
{
|
release_defs (stmt);
|
release_defs (stmt);
|
todoflags |= TODO_remove_unused_locals;
|
todoflags |= TODO_remove_unused_locals;
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
}
|
}
|
else if (is_gimple_min_invariant (rhs))
|
else if (is_gimple_min_invariant (rhs))
|
{
|
{
|
/* Make sure to fold &a[0] + off_1 here. */
|
/* Make sure to fold &a[0] + off_1 here. */
|
fold_stmt_inplace (&gsi);
|
fold_stmt_inplace (&gsi);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
else
|
else
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
{
|
{
|
if (forward_propagate_comparison (stmt))
|
if (forward_propagate_comparison (stmt))
|
cfg_changed = true;
|
cfg_changed = true;
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
else
|
else
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
|
|
/* Combine stmts with the stmts defining their operands.
|
/* Combine stmts with the stmts defining their operands.
|
Note we update GSI within the loop as necessary. */
|
Note we update GSI within the loop as necessary. */
|
prev_initialized = false;
|
prev_initialized = false;
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
bool changed = false;
|
bool changed = false;
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
{
|
{
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
tree rhs1 = gimple_assign_rhs1 (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
enum tree_code code = gimple_assign_rhs_code (stmt);
|
|
|
if ((code == BIT_NOT_EXPR
|
if ((code == BIT_NOT_EXPR
|
|| code == NEGATE_EXPR)
|
|| code == NEGATE_EXPR)
|
&& TREE_CODE (rhs1) == SSA_NAME)
|
&& TREE_CODE (rhs1) == SSA_NAME)
|
changed = simplify_not_neg_expr (&gsi);
|
changed = simplify_not_neg_expr (&gsi);
|
else if (code == COND_EXPR)
|
else if (code == COND_EXPR)
|
{
|
{
|
/* In this case the entire COND_EXPR is in rhs1. */
|
/* In this case the entire COND_EXPR is in rhs1. */
|
changed |= forward_propagate_into_cond (&gsi);
|
changed |= forward_propagate_into_cond (&gsi);
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
}
|
}
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
{
|
{
|
int did_something;
|
int did_something;
|
did_something = forward_propagate_into_comparison (&gsi);
|
did_something = forward_propagate_into_comparison (&gsi);
|
if (did_something == 2)
|
if (did_something == 2)
|
cfg_changed = true;
|
cfg_changed = true;
|
changed = did_something != 0;
|
changed = did_something != 0;
|
}
|
}
|
else if (code == BIT_AND_EXPR
|
else if (code == BIT_AND_EXPR
|
|| code == BIT_IOR_EXPR
|
|| code == BIT_IOR_EXPR
|
|| code == BIT_XOR_EXPR)
|
|| code == BIT_XOR_EXPR)
|
changed = simplify_bitwise_binary (&gsi);
|
changed = simplify_bitwise_binary (&gsi);
|
else if (code == PLUS_EXPR
|
else if (code == PLUS_EXPR
|
|| code == MINUS_EXPR)
|
|| code == MINUS_EXPR)
|
changed = associate_plusminus (&gsi);
|
changed = associate_plusminus (&gsi);
|
else if (CONVERT_EXPR_CODE_P (code)
|
else if (CONVERT_EXPR_CODE_P (code)
|
|| code == FLOAT_EXPR
|
|| code == FLOAT_EXPR
|
|| code == FIX_TRUNC_EXPR)
|
|| code == FIX_TRUNC_EXPR)
|
{
|
{
|
int did_something = combine_conversions (&gsi);
|
int did_something = combine_conversions (&gsi);
|
if (did_something == 2)
|
if (did_something == 2)
|
cfg_changed = true;
|
cfg_changed = true;
|
changed = did_something != 0;
|
changed = did_something != 0;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
case GIMPLE_SWITCH:
|
case GIMPLE_SWITCH:
|
changed = simplify_gimple_switch (stmt);
|
changed = simplify_gimple_switch (stmt);
|
break;
|
break;
|
|
|
case GIMPLE_COND:
|
case GIMPLE_COND:
|
{
|
{
|
int did_something;
|
int did_something;
|
did_something = forward_propagate_into_gimple_cond (stmt);
|
did_something = forward_propagate_into_gimple_cond (stmt);
|
if (did_something == 2)
|
if (did_something == 2)
|
cfg_changed = true;
|
cfg_changed = true;
|
changed = did_something != 0;
|
changed = did_something != 0;
|
break;
|
break;
|
}
|
}
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
{
|
{
|
tree callee = gimple_call_fndecl (stmt);
|
tree callee = gimple_call_fndecl (stmt);
|
if (callee != NULL_TREE
|
if (callee != NULL_TREE
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
|
changed = simplify_builtin_call (&gsi, callee);
|
changed = simplify_builtin_call (&gsi, callee);
|
break;
|
break;
|
}
|
}
|
|
|
default:;
|
default:;
|
}
|
}
|
|
|
if (changed)
|
if (changed)
|
{
|
{
|
/* If the stmt changed then re-visit it and the statements
|
/* If the stmt changed then re-visit it and the statements
|
inserted before it. */
|
inserted before it. */
|
if (!prev_initialized)
|
if (!prev_initialized)
|
gsi = gsi_start_bb (bb);
|
gsi = gsi_start_bb (bb);
|
else
|
else
|
{
|
{
|
gsi = prev;
|
gsi = prev;
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
prev = gsi;
|
prev = gsi;
|
prev_initialized = true;
|
prev_initialized = true;
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (cfg_changed)
|
if (cfg_changed)
|
todoflags |= TODO_cleanup_cfg;
|
todoflags |= TODO_cleanup_cfg;
|
|
|
return todoflags;
|
return todoflags;
|
}
|
}
|
|
|
|
|
static bool
|
static bool
|
gate_forwprop (void)
|
gate_forwprop (void)
|
{
|
{
|
return flag_tree_forwprop;
|
return flag_tree_forwprop;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_forwprop =
|
struct gimple_opt_pass pass_forwprop =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"forwprop", /* name */
|
"forwprop", /* name */
|
gate_forwprop, /* gate */
|
gate_forwprop, /* gate */
|
ssa_forward_propagate_and_combine, /* execute */
|
ssa_forward_propagate_and_combine, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_TREE_FORWPROP, /* tv_id */
|
TV_TREE_FORWPROP, /* tv_id */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_ggc_collect
|
TODO_ggc_collect
|
| TODO_update_ssa
|
| TODO_update_ssa
|
| TODO_verify_ssa /* todo_flags_finish */
|
| TODO_verify_ssa /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
