procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ChangeLog gcc/

Browse source 
2011-07-21  Kai Tietz  <ktietz@redhat.com>

	* fold-const.c (fold_unary_loc): Preserve indirect
	comparison cast to none-boolean type.
	* tree-ssa.c (useless_type_conversion_p): Preserve cast
	from/to boolean-type.
	* gimplify.c (gimple_boolify): Handle boolification
	of comparisons.
	(gimplify_expr): Boolifiy non aggregate-typed
	comparisons.
	* tree-cfg.c (verify_gimple_comparison): Check result
	type of comparison expression.
	* tree-ssa-forwprop.c (forward_propagate_comparison):
	Adjust test of condition result and disallow type-cast
	sinking into comparison.

ChangeLog gcc/testsuite

2011-07-21  Kai Tietz  <ktietz@redhat.com>

	* gcc.dg/tree-ssa/pr30978.c: adjusted.
	* gcc.dg/tree-ssa/ssa-fre-6.c: Likewise.
	* gcc.dg/binop-xor1.c: Set to fail.
	* gcc.dg/binop-xor3.c: Set to fail.

From-SVN: r176563
This commit is contained in:
Kai Tietz 2011-07-21 14:11:28 +02:00 • committed by Kai Tietz
parent 0c53708ead
commit 7f3ff78299
11 changed files with 67 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
gcc/ChangeLog
View file

@ -1,3 +1,19 @@
2011-07-21 Kai Tietz <ktietz@redhat.com>
* fold-const.c (fold_unary_loc): Preserve indirect
comparison cast to none-boolean type.
* tree-ssa.c (useless_type_conversion_p): Preserve cast
from/to boolean-type.
* gimplify.c (gimple_boolify): Handle boolification
of comparisons.
(gimplify_expr): Boolifiy non aggregate-typed
comparisons.
* tree-cfg.c (verify_gimple_comparison): Check result
type of comparison expression.
* tree-ssa-forwprop.c (forward_propagate_comparison):
Adjust test of condition result and disallow type-cast
sinking into comparison.
2011-07-21 Richard Guenther <rguenther@suse.de>
* tree-ssa-forwprop.c (combine_conversions): Return whether

4
gcc/fold-const.c
View file

@ -7664,11 +7664,11 @@ fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
non-integral type.
Do not fold the result as that would not simplify further, also
folding again results in recursions. */
if (INTEGRAL_TYPE_P (type))
if (TREE_CODE (type) == BOOLEAN_TYPE)
return build2_loc (loc, TREE_CODE (op0), type,
TREE_OPERAND (op0, 0),
TREE_OPERAND (op0, 1));
else
else if (!INTEGRAL_TYPE_P (type))
return build3_loc (loc, COND_EXPR, type, op0,
fold_convert (type, boolean_true_node),
fold_convert (type, boolean_false_node));

29
gcc/gimplify.c
View file

@ -2860,18 +2860,23 @@ gimple_boolify (tree expr)
case TRUTH_NOT_EXPR:
TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
/* FALLTHRU */
case EQ_EXPR: case NE_EXPR:
case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
/* These expressions always produce boolean results. */
TREE_TYPE (expr) = boolean_type_node;
if (TREE_CODE (type) != BOOLEAN_TYPE)
TREE_TYPE (expr) = boolean_type_node;
return expr;
default:
if (COMPARISON_CLASS_P (expr))
{
/* There expressions always prduce boolean results. */
if (TREE_CODE (type) != BOOLEAN_TYPE)
TREE_TYPE (expr) = boolean_type_node;
return expr;
}
/* Other expressions that get here must have boolean values, but
might need to be converted to the appropriate mode. */
if (type == boolean_type_node)
if (TREE_CODE (type) == BOOLEAN_TYPE)
return expr;
return fold_convert_loc (loc, boolean_type_node, expr);
}
@ -7316,7 +7321,19 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
if (!AGGREGATE_TYPE_P (type))
goto expr_2;
{
tree org_type = TREE_TYPE (*expr_p);
*expr_p = gimple_boolify (*expr_p);
if (!useless_type_conversion_p (org_type,
TREE_TYPE (*expr_p)))
{
*expr_p = fold_convert_loc (input_location,
org_type, *expr_p);
ret = GS_OK;
}
else
goto expr_2;
}
else if (TYPE_MODE (type) != BLKmode)
ret = gimplify_scalar_mode_aggregate_compare (expr_p);
else

5
gcc/testsuite/ChangeLog
View file

@ -1,3 +1,8 @@
2011-07-21 Kai Tietz <ktietz@redhat.com>
* gcc.dg/tree-ssa/pr30978.c: adjusted.
* gcc.dg/tree-ssa/ssa-fre-6.c: Likewise.
2011-07-21 Tobias Burnus <burnus@net-b.de>
* gfortran.dg/coarray_lib_token_1.f90: New.

5
gcc/testsuite/gcc.dg/binop-xor1.c
View file

@ -7,8 +7,5 @@ foo (int a, int b, int c)
return ((a && !b && c) || (!a && b && c));
}
/* We expect to see "<bb N>"; confirm that, so that we know to count
it in the real test. */
/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 5 "optimized" } } */
/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" } } */
/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" { xfail *-*-* } } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */

5
gcc/testsuite/gcc.dg/binop-xor3.c
View file

@ -7,8 +7,5 @@ foo (int a, int b)
return ((a && !b) || (!a && b));
}
/* We expect to see "<bb N>"; confirm that, so that we know to count
it in the real test. */
/* { dg-final { scan-tree-dump-times "<bb\[^>\]*>" 1 "optimized" } } */
/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" } } */
/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" { xfail *-*-* } } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */

5
gcc/testsuite/gcc.dg/tree-ssa/pr30978.c
View file

@ -10,5 +10,8 @@ int foo(int a)
return e;
}
/* { dg-final { scan-tree-dump "e_. = a_..D. > 0;" "optimized" } } */
/* { dg-final { scan-tree-dump-times " = " 2 "optimized" } } */
/* One comparison and one extension to int. */
/* { dg-final { scan-tree-dump " = a_..D. > 0;" "optimized" } } */
/* { dg-final { scan-tree-dump "e_. = \\\(int\\\)" "optimized" } } */
/* { dg-final { cleanup-tree-dump "optimized" } } */

2
gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c
View file

@ -2,5 +2,5 @@
/* { dg-options "-O -fdump-tree-fre1-details" } */
int i; int foo(void) { i = 2; int j = i * 2; int k = i + 2; return j == k; }
/* { dg-final { scan-tree-dump-times "Replaced " 5 "fre1" } } */
/* { dg-final { scan-tree-dump-times "Replaced " 6 "fre1" } } */
/* { dg-final { cleanup-tree-dump "fre1" } } */

4
gcc/tree-cfg.c
View file

@ -3203,7 +3203,9 @@ verify_gimple_comparison (tree type, tree op0, tree op1)
&& (!POINTER_TYPE_P (op0_type)
|| !POINTER_TYPE_P (op1_type)
|| TYPE_MODE (op0_type) != TYPE_MODE (op1_type)))
|| !INTEGRAL_TYPE_P (type))
|| !INTEGRAL_TYPE_P (type)
|| (TREE_CODE (type) != BOOLEAN_TYPE
&& TYPE_PRECISION (type) != 1))
{
error ("type mismatch in comparison expression");
debug_generic_expr (type);

19
gcc/tree-ssa-forwprop.c
View file

@ -1132,20 +1132,12 @@ forward_propagate_comparison (gimple stmt)
if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
return false;
/* We can propagate the condition into a conversion. */
if (CONVERT_EXPR_CODE_P (code))
{
/* Avoid using fold here as that may create a COND_EXPR with
non-boolean condition as canonical form. */
tmp = build2 (gimple_assign_rhs_code (stmt), TREE_TYPE (lhs),
gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt));
}
/* We can propagate the condition into a statement that
computes the logical negation of the comparison result. */
else if ((code == BIT_NOT_EXPR
&& TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
|| (code == BIT_XOR_EXPR
&& integer_onep (gimple_assign_rhs2 (use_stmt))))
if ((code == BIT_NOT_EXPR
&& TYPE_PRECISION (TREE_TYPE (lhs)) == 1)
|| (code == BIT_XOR_EXPR
&& integer_onep (gimple_assign_rhs2 (use_stmt))))
{
tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
bool nans = HONOR_NANS (TYPE_MODE (type));
@ -1750,6 +1742,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
arg2));
tem = make_ssa_name (tem, newop);
gimple_assign_set_lhs (newop, tem);
gimple_set_location (newop, gimple_location (stmt));
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
tem, NULL_TREE, NULL_TREE);
@ -1779,6 +1772,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
newop = gimple_build_assign_with_ops (code, tem, def1_arg1, def2_arg1);
tem = make_ssa_name (tem, newop);
gimple_assign_set_lhs (newop, tem);
gimple_set_location (newop, gimple_location (stmt));
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR,
tem, NULL_TREE, NULL_TREE);
@ -1807,6 +1801,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
tem, def1_arg1, arg2);
tem = make_ssa_name (tem, newop);
gimple_assign_set_lhs (newop, tem);
gimple_set_location (newop, gimple_location (stmt));
/* Make sure to re-process the new stmt as it's walking upwards. */
gsi_insert_before (gsi, newop, GSI_NEW_STMT);
gimple_assign_set_rhs1 (stmt, tem);

8
gcc/tree-ssa.c
View file

@ -1306,10 +1306,10 @@ useless_type_conversion_p (tree outer_type, tree inner_type)
|| TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
return false;
/* Preserve conversions to BOOLEAN_TYPE if it is not of precision
one. */
if (TREE_CODE (inner_type) != BOOLEAN_TYPE
&& TREE_CODE (outer_type) == BOOLEAN_TYPE
/* Preserve conversions to/from BOOLEAN_TYPE if types are not
of precision one. */
if (((TREE_CODE (inner_type) == BOOLEAN_TYPE)
!= (TREE_CODE (outer_type) == BOOLEAN_TYPE))
&& TYPE_PRECISION (outer_type) != 1)
return false;