OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tree-ssa-operands.c (build_ssa_operands, [...]): Ignore a VIEW_CONVERT_EXPR on LHS when deciding if must or may def. 

PR/18664
	* tree-ssa-operands.c (build_ssa_operands, case MODIFY_EXPR):
	Ignore a VIEW_CONVERT_EXPR on LHS when deciding if must or may def.
	* tree-ssa-ccp.c (visit_assignment): If LHS is a VIEW_CONVERT_EXPR,
	add an inverse VIEW_CONVERT_EXPR to const_val.

From-SVN: r91450
This commit is contained in:
Richard Kenner 2004-11-29 01:08:41 +00:00 committed by Richard Kenner
parent ab1a8620fc
commit 9390c347e9
3 changed files with 57 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,5 +1,12 @@
2004-11-28 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
PR/18664
* tree-ssa-operands.c (build_ssa_operands, case MODIFY_EXPR):
Ignore a VIEW_CONVERT_EXPR on LHS when deciding if must or may def.
* tree-ssa-ccp.c (visit_assignment): If LHS is a VIEW_CONVERT_EXPR,
add an inverse VIEW_CONVERT_EXPR to const_val.
PR/18657
* tree-nested.c (check_for_nested_with_variably_modified): New.
(create_nesting_tree): Call it.

32
gcc/tree-ssa-ccp.c
View File

@ -1053,21 +1053,35 @@ visit_assignment (tree stmt, tree *output_p)
val = *nval;
}
else
{
/* Evaluate the statement. */
/* Evaluate the statement. */
val = evaluate_stmt (stmt);
}
/* FIXME: Hack. If this was a definition of a bitfield, we need to widen
/* If the original LHS was a VIEW_CONVERT_EXPR, modify the constant
value to be a VIEW_CONVERT_EXPR of the old constant value. This is
valid because a VIEW_CONVERT_EXPR is valid everywhere an operand of
aggregate type is valid.
??? Also, if this was a definition of a bitfield, we need to widen
the constant value into the type of the destination variable. This
should not be necessary if GCC represented bitfields properly. */
{
tree lhs = TREE_OPERAND (stmt, 0);
if (val.lattice_val == CONSTANT
&& TREE_CODE (lhs) == COMPONENT_REF
&& DECL_BIT_FIELD (TREE_OPERAND (lhs, 1)))
tree orig_lhs = TREE_OPERAND (stmt, 0);
if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
&& val.lattice_val == CONSTANT)
{
tree w = widen_bitfield (val.const_val, TREE_OPERAND (lhs, 1), lhs);
val.const_val = build1 (VIEW_CONVERT_EXPR,
TREE_TYPE (TREE_OPERAND (orig_lhs, 0)),
val.const_val);
orig_lhs = TREE_OPERAND (orig_lhs, 1);
}
if (val.lattice_val == CONSTANT
&& TREE_CODE (orig_lhs) == COMPONENT_REF
&& DECL_BIT_FIELD (TREE_OPERAND (orig_lhs, 1)))
{
tree w = widen_bitfield (val.const_val, TREE_OPERAND (orig_lhs, 1),
orig_lhs);
if (w && is_gimple_min_invariant (w))
val.const_val = w;

41
gcc/tree-ssa-operands.c
View File

@ -893,20 +893,33 @@ build_ssa_operands (tree stmt, stmt_ann_t ann, stmt_operands_p old_ops,
switch (code)
{
case MODIFY_EXPR:
get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
if (TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_RANGE_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == COMPONENT_REF
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == REALPART_EXPR
|| TREE_CODE (TREE_OPERAND (stmt, 0)) == IMAGPART_EXPR
/* Use a V_MAY_DEF if the RHS might throw, as the LHS won't be
modified in that case. FIXME we should represent somehow
that it is killed on the fallthrough path. */
|| tree_could_throw_p (TREE_OPERAND (stmt, 1)))
get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_is_def);
else
get_expr_operands (stmt, &TREE_OPERAND (stmt, 0),
opf_is_def | opf_kill_def);
/* First get operands from the RHS. For the LHS, we use a V_MAY_DEF if
either only part of LHS is modified or if the RHS might throw,
otherwise, use V_MUST_DEF.
??? If it might throw, we should represent somehow that it is killed
on the fallthrough path. */
{
tree lhs = TREE_OPERAND (stmt, 0);
int lhs_flags = opf_is_def;
get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
/* If the LHS is a VIEW_CONVERT_EXPR, it isn't changing whether
or not the entire LHS is modified; that depends on what's
inside the VIEW_CONVERT_EXPR. */
if (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
lhs = TREE_OPERAND (lhs, 0);
if (TREE_CODE (lhs) != ARRAY_REF && TREE_CODE (lhs) != ARRAY_RANGE_REF
&& TREE_CODE (lhs) != COMPONENT_REF
&& TREE_CODE (lhs) != BIT_FIELD_REF
&& TREE_CODE (lhs) != REALPART_EXPR
&& TREE_CODE (lhs) != IMAGPART_EXPR)
lhs_flags |= opf_kill_def;
get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), lhs_flags);
}
break;
case COND_EXPR: