Skip to content

R
riscv-gcc-1
Commit 1b0f3e79 by Roger Sayle Committed by Roger Sayle
Options

fold-const.c (combine_comparisons, [...]): Use constant_boolean_node where appropriate. 


	* fold-const.c (combine_comparisons, optimize_bit_field_compare,
	range_binop, fold_truthop, fold_binary_op_with_conditional_arg,
	fold_mathfn_compare, fold_inf_compare, fold,
	fold_relational_hi_lo, nondestructive_fold_binary_to_constant):
	Use constant_boolean_node where appropriate.  Don't bother using
	fold_convert on the second argument to omit_one_operand.

From-SVN: r82468
parent 29d64660
Showing with 53 additions and 98 deletions
gcc/ChangeLog
2004-05-30 Roger Sayle <roger@eyesopen.com>
* fold-const.c (combine_comparisons, optimize_bit_field_compare,
range_binop, fold_truthop, fold_binary_op_with_conditional_arg,
fold_mathfn_compare, fold_inf_compare, fold,
fold_relational_hi_lo, nondestructive_fold_binary_to_constant):
Use constant_boolean_node where appropriate. Don't bother using
fold_convert on the second argument to omit_one_operand.
2004-05-30 Roger Sayle <roger@eyesopen.com>
* doc/c-tree.texi (Expressions): Document FLOOR_DIV_EXPR,
CEIL_DIV_EXPR, ROUND_DIV_EXPR, FLOOR_MOD_EXPR, CEIL_MOD_EXPR,
ROUND_MOD_EXPR, EXACT_DIV_EXPR. Improve documentation of
......
gcc/fold-const.c
......@@ -2298,9 +2298,9 @@ combine_comparisons (enum tree_code code, enum tree_code lcode,
}
if (compcode == COMPCODE_TRUE)
return fold_convert (truth_type, integer_one_node);
return constant_boolean_node (true, truth_type);
else if (compcode == COMPCODE_FALSE)
return fold_convert (truth_type, integer_zero_node);
return constant_boolean_node (false, truth_type);
else
return fold (build2 (compcode_to_comparison (compcode),
truth_type, ll_arg, lr_arg));
......@@ -3141,9 +3141,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
{
warning ("comparison is always %d due to width of bit-field",
code == NE_EXPR);
return fold_convert (compare_type,
(code == NE_EXPR
? integer_one_node : integer_zero_node));
return constant_boolean_node (code == NE_EXPR, compare_type);
}
}
else
......@@ -3154,9 +3152,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
{
warning ("comparison is always %d due to width of bit-field",
code == NE_EXPR);
return fold_convert (compare_type,
(code == NE_EXPR
? integer_one_node : integer_zero_node));
return constant_boolean_node (code == NE_EXPR, compare_type);
}
}
......@@ -3479,7 +3475,7 @@ range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
abort ();
}
return fold_convert (type, result ? integer_one_node : integer_zero_node);
return constant_boolean_node (result, type);
}
/* Given EXP, a logical expression, set the range it is testing into
......@@ -4212,7 +4208,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
return build2 (NE_EXPR, truth_type,
build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
ll_arg, rl_arg),
integer_zero_node);
fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
/* Convert (a == 0) && (b == 0) into (a | b) == 0. */
if (code == TRUTH_AND_EXPR
......@@ -4222,7 +4218,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
return build2 (EQ_EXPR, truth_type,
build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
ll_arg, rl_arg),
integer_zero_node);
fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
return build2 (code, truth_type, lhs, rhs);
}
......@@ -4344,9 +4340,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
{
warning ("comparison is always %d", wanted_code == NE_EXPR);
return fold_convert (truth_type,
wanted_code == NE_EXPR
? integer_one_node : integer_zero_node);
return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
}
}
if (r_const)
......@@ -4361,9 +4355,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
{
warning ("comparison is always %d", wanted_code == NE_EXPR);
return fold_convert (truth_type,
wanted_code == NE_EXPR
? integer_one_node : integer_zero_node);
return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
}
}
......@@ -4491,12 +4483,12 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
if (wanted_code == NE_EXPR)
{
warning ("`or' of unmatched not-equal tests is always 1");
return fold_convert (truth_type, integer_one_node);
return constant_boolean_node (true, truth_type);
}
else
{
warning ("`and' of mutually exclusive equal-tests is always 0");
return fold_convert (truth_type, integer_zero_node);
return constant_boolean_node (false, truth_type);
}
}
......@@ -4973,8 +4965,8 @@ fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
{
tree testtype = TREE_TYPE (cond);
test = cond;
true_value = fold_convert (testtype, integer_one_node);
false_value = fold_convert (testtype, integer_zero_node);
true_value = constant_boolean_node (true, testtype);
false_value = constant_boolean_node (false, testtype);
}
if (lhs == 0)
......@@ -5054,16 +5046,12 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
{
/* sqrt(x) < y is always false, if y is negative. */
if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
return omit_one_operand (type,
fold_convert (type, integer_zero_node),
arg);
return omit_one_operand (type, integer_zero_node, arg);
/* sqrt(x) > y is always true, if y is negative and we
don't care about NaNs, i.e. negative values of x. */
if (code == NE_EXPR || !HONOR_NANS (mode))
return omit_one_operand (type,
fold_convert (type, integer_one_node),
arg);
return omit_one_operand (type, integer_one_node, arg);
/* sqrt(x) > y is the same as x >= 0, if y is negative. */
return fold (build2 (GE_EXPR, type, arg,
......@@ -5085,9 +5073,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
/* sqrt(x) > y is always false, when y is very large
and we don't care about infinities. */
return omit_one_operand (type,
fold_convert (type, integer_zero_node),
arg);
return omit_one_operand (type, integer_zero_node, arg);
}
/* sqrt(x) > c is the same as x > c*c. */
......@@ -5106,9 +5092,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
/* sqrt(x) < y is always true, when y is a very large
value and we don't care about NaNs or Infinities. */
if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
return omit_one_operand (type,
fold_convert (type, integer_one_node),
arg);
return omit_one_operand (type, integer_one_node, arg);
/* sqrt(x) < y is x != +Inf when y is very large and we
don't care about NaNs. */
......@@ -5192,16 +5176,12 @@ fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
/* x > +Inf is always false, if with ignore sNANs. */
if (HONOR_SNANS (mode))
return NULL_TREE;
return omit_one_operand (type,
fold_convert (type, integer_zero_node),
arg0);
return omit_one_operand (type, integer_zero_node, arg0);
case LE_EXPR:
/* x <= +Inf is always true, if we don't case about NaNs. */
if (! HONOR_NANS (mode))
return omit_one_operand (type,
fold_convert (type, integer_one_node),
arg0);
return omit_one_operand (type, integer_one_node, arg0);
/* x <= +Inf is the same as x == x, i.e. isfinite(x). */
if (lang_hooks.decls.global_bindings_p () == 0
......@@ -7380,12 +7360,7 @@ fold (tree expr)
&& DECL_P (TREE_OPERAND (arg0, 0))
&& ! DECL_WEAK (TREE_OPERAND (arg0, 0))
&& integer_zerop (arg1))
{
if (code == EQ_EXPR)
return fold_convert (type, integer_zero_node);
else
return fold_convert (type, integer_one_node);
}
return constant_boolean_node (code != EQ_EXPR, type);
/* If this is an equality comparison of the address of two non-weak,
unaliased symbols neither of which are extern (since we do not
......@@ -7403,14 +7378,9 @@ fold (tree expr)
&& ! lookup_attribute ("alias",
DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
&& ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
{
if (code == EQ_EXPR)
return fold_convert (type, (operand_equal_p (arg0, arg1, 0)
? integer_one_node : integer_zero_node));
else
return fold_convert (type, (operand_equal_p (arg0, arg1, 0)
? integer_zero_node : integer_one_node));
}
return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
? code == EQ_EXPR : code != EQ_EXPR,
type);
if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
{
......@@ -7456,7 +7426,7 @@ fold (tree expr)
&& ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
{
tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
return omit_one_operand (type, fold_convert (type, tem), arg0);
return omit_one_operand (type, tem, arg0);
}
/* Fold comparisons against infinity. */
......@@ -7632,18 +7602,14 @@ fold (tree expr)
switch (code)
{
case GT_EXPR:
return omit_one_operand (type,
fold_convert (type,
integer_zero_node),
arg0);
return omit_one_operand (type, integer_zero_node, arg0);
case GE_EXPR:
return fold (build2 (EQ_EXPR, type, arg0, arg1));
case LE_EXPR:
return omit_one_operand (type,
fold_convert (type,
integer_one_node),
arg0);
return omit_one_operand (type, integer_one_node, arg0);
case LT_EXPR:
return fold (build2 (NE_EXPR, type, arg0, arg1));
......@@ -7671,18 +7637,14 @@ fold (tree expr)
switch (code)
{
case LT_EXPR:
return omit_one_operand (type,
fold_convert (type,
integer_zero_node),
arg0);
return omit_one_operand (type, integer_zero_node, arg0);
case LE_EXPR:
return fold (build2 (EQ_EXPR, type, arg0, arg1));
case GE_EXPR:
return omit_one_operand (type,
fold_convert (type,
integer_one_node),
arg0);
return omit_one_operand (type, integer_one_node, arg0);
case GT_EXPR:
return fold (build2 (NE_EXPR, type, arg0, arg1));
......@@ -9316,16 +9278,14 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
switch (code)
{
case GT_EXPR:
return omit_one_operand (type,
fold_convert (type, integer_zero_node),
op0);
return omit_one_operand (type, integer_zero_node, op0);
case GE_EXPR:
*code_p = EQ_EXPR;
break;
case LE_EXPR:
return omit_one_operand (type,
fold_convert (type, integer_one_node),
op0);
return omit_one_operand (type, integer_one_node, op0);
case LT_EXPR:
*code_p = NE_EXPR;
break;
......@@ -9356,17 +9316,15 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
switch (code)
{
case LT_EXPR:
return omit_one_operand (type,
fold_convert (type, integer_zero_node),
op0);
return omit_one_operand (type, integer_zero_node, op0);
case LE_EXPR:
*code_p = EQ_EXPR;
break;
case GE_EXPR:
return omit_one_operand (type,
fold_convert (type, integer_one_node),
op0);
return omit_one_operand (type, integer_one_node, op0);
case GT_EXPR:
*code_p = NE_EXPR;
break;
......@@ -9686,12 +9644,7 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
if (integer_zerop (op0))
return omit_one_operand (type, op0, op1);
if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
{
int x1 = ! integer_zerop (op0);
int x2 = ! integer_zerop (op1);
return ((x1 & x2) ? integer_one_node : integer_zero_node);
}
return constant_boolean_node (true, type);
return NULL_TREE;
case TRUTH_OR_EXPR:
......@@ -9704,21 +9657,14 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
return omit_one_operand (type, op0, op1);
if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
{
int x1 = ! integer_zerop (op0);
int x2 = ! integer_zerop (op1);
return ((x1 | x2) ? integer_one_node : integer_zero_node);
}
return constant_boolean_node (false, type);
return NULL_TREE;
case TRUTH_XOR_EXPR:
if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
{
int x1 = ! integer_zerop (op0);
int x2 = ! integer_zerop (op1);
return ((x1 ^ x2) ? integer_one_node : integer_zero_node);
int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
return constant_boolean_node (x, type);
}
return NULL_TREE;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment