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

re PR bootstrap/45700 (--enable-checking=fold bootstrap failures)

Browse source 
PR bootstrap/45700
	* tree.h (build1_stat_loc, build2_stat_loc, build3_stat_loc,
	build4_stat_loc, build5_stat_loc, build6_stat_loc): New inlines.
	(build1_loc, build2_loc, build3_loc, build4_loc, build5_loc,
	build6_loc): Define.
	* fold-const.c (protected_set_expr_location_unshare): New inline.
	(fold_convert_loc, pedantic_non_lvalue_loc): Use it.
	(negate_expr, associate_trees, non_lvalue_loc, omit_one_operand_loc,
	pedantic_omit_one_operand_loc, omit_two_operands_loc,
	fold_truth_not_expr, invert_truthvalue_loc, make_bit_field_ref,
	optimize_bit_field_compare, make_range, fold_range_test, fold_truthop,
	build_fold_addr_expr_with_type_loc, fold_unary_loc, fold_binary_loc,
	fold_indirect_ref_1, build_fold_indirect_ref_loc): Use builN_loc
	instead of buildN followed by SET_EXPR_LOCATION or
	protected_set_expr_location.
	(fold_build1_stat_loc, fold_build2_stat_loc, fold_build3_stat_loc):
	Use buildN_stat_loc instead of buildN_stat followed by
	SET_EXPR_LOCATION.

	* trans.h (build1_stat_loc, build2_stat_loc, build3_stat_loc,
	build4_stat_loc): Removed.
	(build1_loc, build2_loc, build3_loc, build4_loc): Removed.

From-SVN: r167168
This commit is contained in:
Jakub Jelinek 2010-11-26 10:35:35 +01:00 • committed by Jakub Jelinek
parent 93b39277c5
commit c9019218a1
5 changed files with 243 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
gcc/ChangeLog
View file

@ -1,3 +1,24 @@
2010-11-26 Jakub Jelinek <jakub@redhat.com>
PR bootstrap/45700
* tree.h (build1_stat_loc, build2_stat_loc, build3_stat_loc,
build4_stat_loc, build5_stat_loc, build6_stat_loc): New inlines.
(build1_loc, build2_loc, build3_loc, build4_loc, build5_loc,
build6_loc): Define.
* fold-const.c (protected_set_expr_location_unshare): New inline.
(fold_convert_loc, pedantic_non_lvalue_loc): Use it.
(negate_expr, associate_trees, non_lvalue_loc, omit_one_operand_loc,
pedantic_omit_one_operand_loc, omit_two_operands_loc,
fold_truth_not_expr, invert_truthvalue_loc, make_bit_field_ref,
optimize_bit_field_compare, make_range, fold_range_test, fold_truthop,
build_fold_addr_expr_with_type_loc, fold_unary_loc, fold_binary_loc,
fold_indirect_ref_1, build_fold_indirect_ref_loc): Use builN_loc
instead of buildN followed by SET_EXPR_LOCATION or
protected_set_expr_location.
(fold_build1_stat_loc, fold_build2_stat_loc, fold_build3_stat_loc):
Use buildN_stat_loc instead of buildN_stat followed by
SET_EXPR_LOCATION.
2010-11-26 Basile Starynkevitch <basile@starynkevitch.net>
* Makefile.in (s-tm-texi): Remove spurous tab.

387
gcc/fold-const.c
View file

@ -143,6 +143,25 @@ static tree fold_relational_const (enum tree_code, tree, tree, tree);
static tree fold_convert_const (enum tree_code, tree, tree);
/* Similar to protected_set_expr_location, but never modify x in place,
if location can and needs to be set, unshare it. */
static inline tree
protected_set_expr_location_unshare (tree x, location_t loc)
{
if (CAN_HAVE_LOCATION_P (x)
&& EXPR_LOCATION (x) != loc
&& !(TREE_CODE (x) == SAVE_EXPR
|| TREE_CODE (x) == TARGET_EXPR
|| TREE_CODE (x) == BIND_EXPR))
{
x = copy_node (x);
SET_EXPR_LOCATION (x, loc);
}
return x;
}
/* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
and SUM1. Then this yields nonzero if overflow occurred during the
@ -727,10 +746,7 @@ negate_expr (tree t)
tem = fold_negate_expr (loc, t);
if (!tem)
{
tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
SET_EXPR_LOCATION (tem, loc);
}
tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
return fold_convert_loc (loc, type, tem);
}
@ -841,8 +857,6 @@ split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
static tree
associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
{
tree tem;
if (t1 == 0)
return t2;
else if (t2 == 0)
@ -857,11 +871,15 @@ associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree typ
if (code == PLUS_EXPR)
{
if (TREE_CODE (t1) == NEGATE_EXPR)
tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t2),
fold_convert_loc (loc, type, TREE_OPERAND (t1, 0)));
return build2_loc (loc, MINUS_EXPR, type,
fold_convert_loc (loc, type, t2),
fold_convert_loc (loc, type,
TREE_OPERAND (t1, 0)));
else if (TREE_CODE (t2) == NEGATE_EXPR)
tem = build2 (MINUS_EXPR, type, fold_convert_loc (loc, type, t1),
fold_convert_loc (loc, type, TREE_OPERAND (t2, 0)));
return build2_loc (loc, MINUS_EXPR, type,
fold_convert_loc (loc, type, t1),
fold_convert_loc (loc, type,
TREE_OPERAND (t2, 0)));
else if (integer_zerop (t2))
return fold_convert_loc (loc, type, t1);
}
@ -871,16 +889,12 @@ associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree typ
return fold_convert_loc (loc, type, t1);
}
tem = build2 (code, type, fold_convert_loc (loc, type, t1),
fold_convert_loc (loc, type, t2));
goto associate_trees_exit;
return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
fold_convert_loc (loc, type, t2));
}
return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
fold_convert_loc (loc, type, t2));
associate_trees_exit:
protected_set_expr_location (tem, loc);
return tem;
fold_convert_loc (loc, type, t2));
}
/* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
@ -2015,7 +2029,7 @@ fold_convert_loc (location_t loc, tree type, tree arg)
gcc_unreachable ();
}
fold_convert_exit:
protected_set_expr_location (tem, loc);
protected_set_expr_location_unshare (tem, loc);
return tem;
}
@ -2079,9 +2093,7 @@ non_lvalue_loc (location_t loc, tree x)
if (! maybe_lvalue_p (x))
return x;
x = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
SET_EXPR_LOCATION (x, loc);
return x;
return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
}
/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
@ -2098,16 +2110,7 @@ pedantic_non_lvalue_loc (location_t loc, tree x)
if (pedantic_lvalues)
return non_lvalue_loc (loc, x);
if (CAN_HAVE_LOCATION_P (x)
&& EXPR_LOCATION (x) != loc
&& !(TREE_CODE (x) == SAVE_EXPR
|| TREE_CODE (x) == TARGET_EXPR
|| TREE_CODE (x) == BIND_EXPR))
{
x = copy_node (x);
SET_EXPR_LOCATION (x, loc);
}
return x;
return protected_set_expr_location_unshare (x, loc);
}
/* Given a tree comparison code, return the code that is the logical inverse
@ -2981,22 +2984,14 @@ omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
/* If the resulting operand is an empty statement, just return the omitted
statement casted to void. */
if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
{
t = build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
goto omit_one_operand_exit;
}
return build1_loc (loc, NOP_EXPR, void_type_node,
fold_ignored_result (omitted));
if (TREE_SIDE_EFFECTS (omitted))
{
t = build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
goto omit_one_operand_exit;
}
return build2_loc (loc, COMPOUND_EXPR, type,
fold_ignored_result (omitted), t);
return non_lvalue_loc (loc, t);
omit_one_operand_exit:
protected_set_expr_location (t, loc);
return t;
}
/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
@ -3010,22 +3005,14 @@ pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
/* If the resulting operand is an empty statement, just return the omitted
statement casted to void. */
if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
{
t = build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
goto pedantic_omit_one_operand_exit;
}
return build1_loc (loc, NOP_EXPR, void_type_node,
fold_ignored_result (omitted));
if (TREE_SIDE_EFFECTS (omitted))
{
t = build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
goto pedantic_omit_one_operand_exit;
}
return build2_loc (loc, COMPOUND_EXPR, type,
fold_ignored_result (omitted), t);
return pedantic_non_lvalue_loc (loc, t);
pedantic_omit_one_operand_exit:
protected_set_expr_location (t, loc);
return t;
}
/* Return a tree for the case when the result of an expression is RESULT
@ -3039,20 +3026,14 @@ pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
tree
omit_two_operands_loc (location_t loc, tree type, tree result,
tree omitted1, tree omitted2)
tree omitted1, tree omitted2)
{
tree t = fold_convert_loc (loc, type, result);
if (TREE_SIDE_EFFECTS (omitted2))
{
t = build2 (COMPOUND_EXPR, type, omitted2, t);
SET_EXPR_LOCATION (t, loc);
}
t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
if (TREE_SIDE_EFFECTS (omitted1))
{
t = build2 (COMPOUND_EXPR, type, omitted1, t);
SET_EXPR_LOCATION (t, loc);
}
t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
}
@ -3068,7 +3049,7 @@ omit_two_operands_loc (location_t loc, tree type, tree result,
tree
fold_truth_not_expr (location_t loc, tree arg)
{
tree t, type = TREE_TYPE (arg);
tree type = TREE_TYPE (arg);
enum tree_code code = TREE_CODE (arg);
location_t loc1, loc2;
@ -3089,9 +3070,8 @@ fold_truth_not_expr (location_t loc, tree arg)
if (code == ERROR_MARK)
return NULL_TREE;
t = build2 (code, type, TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
SET_EXPR_LOCATION (t, loc);
return t;
return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
TREE_OPERAND (arg, 1));
}
switch (code)
@ -3106,10 +3086,9 @@ fold_truth_not_expr (location_t loc, tree arg)
loc1 = loc;
if (loc2 == UNKNOWN_LOCATION)
loc2 = loc;
t = build2 (TRUTH_OR_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
break;
return build2_loc (loc, TRUTH_OR_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
case TRUTH_OR_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
@ -3118,10 +3097,9 @@ fold_truth_not_expr (location_t loc, tree arg)
loc1 = loc;
if (loc2 == UNKNOWN_LOCATION)
loc2 = loc;
t = build2 (TRUTH_AND_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
break;
return build2_loc (loc, TRUTH_AND_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
case TRUTH_XOR_EXPR:
/* Here we can invert either operand. We invert the first operand
@ -3130,13 +3108,12 @@ fold_truth_not_expr (location_t loc, tree arg)
negation of the second operand. */
if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
t = build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
else
t = build2 (TRUTH_XOR_EXPR, type,
invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
TREE_OPERAND (arg, 1));
break;
return build2_loc (loc, TRUTH_XOR_EXPR, type,
invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
TREE_OPERAND (arg, 1));
case TRUTH_ANDIF_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
@ -3145,10 +3122,9 @@ fold_truth_not_expr (location_t loc, tree arg)
loc1 = loc;
if (loc2 == UNKNOWN_LOCATION)
loc2 = loc;
t = build2 (TRUTH_ORIF_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
break;
return build2_loc (loc, TRUTH_ORIF_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
case TRUTH_ORIF_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
@ -3157,10 +3133,9 @@ fold_truth_not_expr (location_t loc, tree arg)
loc1 = loc;
if (loc2 == UNKNOWN_LOCATION)
loc2 = loc;
t = build2 (TRUTH_ANDIF_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
break;
return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
case TRUTH_NOT_EXPR:
return TREE_OPERAND (arg, 0);
@ -3180,22 +3155,20 @@ fold_truth_not_expr (location_t loc, tree arg)
/* A COND_EXPR may have a throw as one operand, which
then has void type. Just leave void operands
as they are. */
t = build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
VOID_TYPE_P (TREE_TYPE (arg1))
? arg1 : invert_truthvalue_loc (loc1, arg1),
VOID_TYPE_P (TREE_TYPE (arg2))
? arg2 : invert_truthvalue_loc (loc2, arg2));
break;
return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
VOID_TYPE_P (TREE_TYPE (arg1))
? arg1 : invert_truthvalue_loc (loc1, arg1),
VOID_TYPE_P (TREE_TYPE (arg2))
? arg2 : invert_truthvalue_loc (loc2, arg2));
}
case COMPOUND_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
if (loc1 == UNKNOWN_LOCATION)
loc1 = loc;
t = build2 (COMPOUND_EXPR, type,
TREE_OPERAND (arg, 0),
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
break;
return build2_loc (loc, COMPOUND_EXPR, type,
TREE_OPERAND (arg, 0),
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
case NON_LVALUE_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
@ -3205,10 +3178,7 @@ fold_truth_not_expr (location_t loc, tree arg)
CASE_CONVERT:
if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
{
t = build1 (TRUTH_NOT_EXPR, type, arg);
break;
}
return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
/* ... fall through ... */
@ -3216,37 +3186,27 @@ fold_truth_not_expr (location_t loc, tree arg)
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
if (loc1 == UNKNOWN_LOCATION)
loc1 = loc;
t = build1 (TREE_CODE (arg), type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
break;
return build1_loc (loc, TREE_CODE (arg), type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
case BIT_AND_EXPR:
if (!integer_onep (TREE_OPERAND (arg, 1)))
return NULL_TREE;
t = build2 (EQ_EXPR, type, arg, build_int_cst (type, 0));
break;
return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
case SAVE_EXPR:
t = build1 (TRUTH_NOT_EXPR, type, arg);
break;
return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
case CLEANUP_POINT_EXPR:
loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
if (loc1 == UNKNOWN_LOCATION)
loc1 = loc;
t = build1 (CLEANUP_POINT_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
break;
return build1_loc (loc, CLEANUP_POINT_EXPR, type,
invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
default:
t = NULL_TREE;
break;
return NULL_TREE;
}
if (t)
SET_EXPR_LOCATION (t, loc);
return t;
}
/* Return a simplified tree node for the truth-negation of ARG. This
@ -3266,10 +3226,7 @@ invert_truthvalue_loc (location_t loc, tree arg)
tem = fold_truth_not_expr (loc, arg);
if (!tem)
{
tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
SET_EXPR_LOCATION (tem, loc);
}
tem = build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
return tem;
}
@ -3395,9 +3352,8 @@ make_bit_field_ref (location_t loc, tree inner, tree type,
|| TYPE_UNSIGNED (bftype) == !unsignedp)
bftype = build_nonstandard_integer_type (bitsize, 0);
result = build3 (BIT_FIELD_REF, bftype, inner,
size_int (bitsize), bitsize_int (bitpos));
SET_EXPR_LOCATION (result, loc);
result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
size_int (bitsize), bitsize_int (bitpos));
if (bftype != type)
result = fold_convert_loc (loc, type, result);
@ -3576,10 +3532,8 @@ optimize_bit_field_compare (location_t loc, enum tree_code code,
size_int (lbitpos)),
mask);
lhs = build2 (code, compare_type,
build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
rhs);
SET_EXPR_LOCATION (lhs, loc);
lhs = build2_loc (loc, code, compare_type,
build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
return lhs;
}
@ -4005,9 +3959,8 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
case BIT_NOT_EXPR:
/* ~ X -> -X - 1 */
exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
build_int_cst (exp_type, 1));
SET_EXPR_LOCATION (exp, loc);
exp = build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
build_int_cst (exp_type, 1));
continue;
case PLUS_EXPR: case MINUS_EXPR:
@ -4925,13 +4878,9 @@ fold_range_test (location_t loc, enum tree_code code, tree type,
unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
which cases we can't do this. */
if (simple_operand_p (lhs))
{
tem = build2 (code == TRUTH_ANDIF_EXPR
? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
type, op0, op1);
SET_EXPR_LOCATION (tem, loc);
return tem;
}
return build2_loc (loc, code == TRUTH_ANDIF_EXPR
? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
type, op0, op1);
else if (lang_hooks.decls.global_bindings_p () == 0
&& ! CONTAINS_PLACEHOLDER_P (lhs))
@ -4948,11 +4897,9 @@ fold_range_test (location_t loc, enum tree_code code, tree type,
if (strict_overflow_p)
fold_overflow_warning (warnmsg,
WARN_STRICT_OVERFLOW_COMPARISON);
tem = build2 (code == TRUTH_ANDIF_EXPR
? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
type, lhs, rhs);
SET_EXPR_LOCATION (tem, loc);
return tem;
return build2_loc (loc, code == TRUTH_ANDIF_EXPR
? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
type, lhs, rhs);
}
}
}
@ -5166,7 +5113,6 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
if (simple_operand_p (ll_arg)
&& simple_operand_p (lr_arg))
{
tree result;
if (operand_equal_p (ll_arg, rl_arg, 0)
&& operand_equal_p (lr_arg, rr_arg, 0))
{
@ -5207,13 +5153,10 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
&& rcode == NE_EXPR && integer_zerop (rr_arg)
&& TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
&& INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
{
result = build2 (NE_EXPR, truth_type,
return build2_loc (loc, NE_EXPR, truth_type,
build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
ll_arg, rl_arg),
build_int_cst (TREE_TYPE (ll_arg), 0));
goto fold_truthop_exit;
}
/* Convert (a == 0) && (b == 0) into (a | b) == 0. */
if (code == TRUTH_AND_EXPR
@ -5221,21 +5164,15 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
&& rcode == EQ_EXPR && integer_zerop (rr_arg)
&& TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
&& INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
{
result = build2 (EQ_EXPR, truth_type,
return build2_loc (loc, EQ_EXPR, truth_type,
build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
ll_arg, rl_arg),
build_int_cst (TREE_TYPE (ll_arg), 0));
goto fold_truthop_exit;
}
if (LOGICAL_OP_NON_SHORT_CIRCUIT)
{
if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
{
result = build2 (code, truth_type, lhs, rhs);
goto fold_truthop_exit;
}
return build2_loc (loc, code, truth_type, lhs, rhs);
return NULL_TREE;
}
}
@ -5426,8 +5363,7 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
if (! all_ones_mask_p (lr_mask, rnbitsize))
rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
result = build2 (wanted_code, truth_type, lhs, rhs);
goto fold_truthop_exit;
return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
}
/* There is still another way we can do something: If both pairs of
@ -5480,8 +5416,7 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
result = build2 (wanted_code, truth_type, lhs, rhs);
goto fold_truthop_exit;
return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
}
return 0;
@ -5517,17 +5452,10 @@ fold_truthop (location_t loc, enum tree_code code, tree truth_type,
ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
if (! all_ones_mask_p (ll_mask, lnbitsize))
{
result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
SET_EXPR_LOCATION (result, loc);
}
result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
result = build2 (wanted_code, truth_type, result,
const_binop (BIT_IOR_EXPR, l_const, r_const));
fold_truthop_exit:
SET_EXPR_LOCATION (result, loc);
return result;
return build2_loc (loc, wanted_code, truth_type, result,
const_binop (BIT_IOR_EXPR, l_const, r_const));
}
/* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
@ -7616,10 +7544,7 @@ build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
t = TREE_OPERAND (t, 0);
if (TREE_TYPE (t) != ptrtype)
{
t = build1 (NOP_EXPR, ptrtype, t);
SET_EXPR_LOCATION (t, loc);
}
t = build1_loc (loc, NOP_EXPR, ptrtype, t);
}
else if (TREE_CODE (t) == MEM_REF
&& integer_zerop (TREE_OPERAND (t, 1)))
@ -7632,10 +7557,7 @@ build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
t = fold_convert_loc (loc, ptrtype, t);
}
else
{
t = build1 (ADDR_EXPR, ptrtype, t);
SET_EXPR_LOCATION (t, loc);
}
t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
return t;
}
@ -7736,16 +7658,14 @@ fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
(TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
&& TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
|| flag_syntax_only))
{
tem = build1 (code, type,
build3 (COND_EXPR,
TREE_TYPE (TREE_OPERAND
(TREE_OPERAND (tem, 1), 0)),
TREE_OPERAND (tem, 0),
TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
SET_EXPR_LOCATION (tem, loc);
}
tem = build1_loc (loc, code, type,
build3 (COND_EXPR,
TREE_TYPE (TREE_OPERAND
(TREE_OPERAND (tem, 1), 0)),
TREE_OPERAND (tem, 0),
TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
TREE_OPERAND (TREE_OPERAND (tem, 2),
0)));
return tem;
}
else if (COMPARISON_CLASS_P (arg0))
@ -7908,10 +7828,9 @@ fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
unless assigning a bitfield. */
tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
/* First do the assignment, then return converted constant. */
tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
TREE_NO_WARNING (tem) = 1;
TREE_USED (tem) = 1;
SET_EXPR_LOCATION (tem, loc);
return tem;
}
@ -9533,8 +9452,8 @@ fold_binary_loc (location_t loc,
tem = fold_build2_loc (loc, code, type,
fold_convert_loc (loc, TREE_TYPE (op0),
TREE_OPERAND (arg0, 1)), op1);
tem = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0), tem);
goto fold_binary_exit;
return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
tem);
}
if (TREE_CODE (arg1) == COMPOUND_EXPR
&& reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
@ -9542,8 +9461,8 @@ fold_binary_loc (location_t loc,
tem = fold_build2_loc (loc, code, type, op0,
fold_convert_loc (loc, TREE_TYPE (op1),
TREE_OPERAND (arg1, 1)));
tem = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0), tem);
goto fold_binary_exit;
return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
tem);
}
if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
@ -9942,12 +9861,10 @@ fold_binary_loc (location_t loc,
&& ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
== TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
{
tem = build2 (LROTATE_EXPR,
TREE_TYPE (TREE_OPERAND (arg0, 0)),
TREE_OPERAND (arg0, 0),
code0 == LSHIFT_EXPR
? tree01 : tree11);
SET_EXPR_LOCATION (tem, loc);
tem = build2_loc (loc, LROTATE_EXPR,
TREE_TYPE (TREE_OPERAND (arg0, 0)),
TREE_OPERAND (arg0, 0),
code0 == LSHIFT_EXPR ? tree01 : tree11);
return fold_convert_loc (loc, type, tem);
}
else if (code11 == MINUS_EXPR)
@ -13142,13 +13059,10 @@ fold_binary_loc (location_t loc,
&& TYPE_UNSIGNED (TREE_TYPE (arg0))
&& TREE_CODE (arg1) == LSHIFT_EXPR
&& integer_onep (TREE_OPERAND (arg1, 0)))
{
tem = build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
TREE_OPERAND (arg1, 1)),
build_int_cst (TREE_TYPE (arg0), 0));
goto fold_binary_exit;
}
return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
TREE_OPERAND (arg1, 1)),
build_int_cst (TREE_TYPE (arg0), 0));
if ((code == LT_EXPR || code == GE_EXPR)
&& TYPE_UNSIGNED (TREE_TYPE (arg0))
@ -13156,14 +13070,11 @@ fold_binary_loc (location_t loc,
&& TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
&& integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
{
tem = build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
fold_convert_loc (loc, TREE_TYPE (arg0),
build2 (RSHIFT_EXPR,
TREE_TYPE (arg0), arg0,
TREE_OPERAND (TREE_OPERAND (arg1, 0),
1))),
build_int_cst (TREE_TYPE (arg0), 0));
goto fold_binary_exit;
tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
fold_convert_loc (loc, TREE_TYPE (arg0), tem),
build_int_cst (TREE_TYPE (arg0), 0));
}
return NULL_TREE;
@ -13257,9 +13168,6 @@ fold_binary_loc (location_t loc,
default:
return NULL_TREE;
} /* switch (code) */
fold_binary_exit:
protected_set_expr_location (tem, loc);
return tem;
}
/* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
@ -14026,10 +13934,7 @@ fold_build1_stat_loc (location_t loc,
tem = fold_unary_loc (loc, code, type, op0);
if (!tem)
{
tem = build1_stat (code, type, op0 PASS_MEM_STAT);
SET_EXPR_LOCATION (tem, loc);
}
tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
#ifdef ENABLE_FOLD_CHECKING
md5_init_ctx (&ctx);
@ -14077,10 +13982,7 @@ fold_build2_stat_loc (location_t loc,
tem = fold_binary_loc (loc, code, type, op0, op1);
if (!tem)
{
tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
SET_EXPR_LOCATION (tem, loc);
}
tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
#ifdef ENABLE_FOLD_CHECKING
md5_init_ctx (&ctx);
@ -14142,10 +14044,7 @@ fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
if (!tem)
{
tem = build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
SET_EXPR_LOCATION (tem, loc);
}
tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
#ifdef ENABLE_FOLD_CHECKING
md5_init_ctx (&ctx);
@ -15661,9 +15560,8 @@ fold_indirect_ref_1 (location_t loc, tree type, tree op0)
tree min_val = size_zero_node;
if (type_domain && TYPE_MIN_VALUE (type_domain))
min_val = TYPE_MIN_VALUE (type_domain);
op0 = build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
SET_EXPR_LOCATION (op0, loc);
return op0;
return build4_loc (loc, ARRAY_REF, type, op, min_val,
NULL_TREE, NULL_TREE);
}
/* *(foo *)&complexfoo => __real__ complexfoo */
else if (TREE_CODE (optype) == COMPLEX_TYPE
@ -15727,10 +15625,8 @@ fold_indirect_ref_1 (location_t loc, tree type, tree op0)
op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
TYPE_SIZE_UNIT (type));
op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
op0 = build4 (ARRAY_REF, type, op00, op01,
NULL_TREE, NULL_TREE);
SET_EXPR_LOCATION (op0, loc);
return op0;
return build4_loc (loc, ARRAY_REF, type, op00, op01,
NULL_TREE, NULL_TREE);
}
}
}
@ -15745,9 +15641,8 @@ fold_indirect_ref_1 (location_t loc, tree type, tree op0)
type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
if (type_domain && TYPE_MIN_VALUE (type_domain))
min_val = TYPE_MIN_VALUE (type_domain);
op0 = build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
SET_EXPR_LOCATION (op0, loc);
return op0;
return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
NULL_TREE);
}
return NULL_TREE;
@ -15765,9 +15660,7 @@ build_fold_indirect_ref_loc (location_t loc, tree t)
if (sub)
return sub;
t = build1 (INDIRECT_REF, type, t);
SET_EXPR_LOCATION (t, loc);
return t;
return build1_loc (loc, INDIRECT_REF, type, t);
}
/* Given an INDIRECT_REF T, return either T or a simplified version. */

45
gcc/fortran/trans.h
View file

@ -756,51 +756,6 @@ struct GTY((variable_size)) lang_decl {
(TYPE_LANG_SPECIFIC(node)->base_decl[(internal)])
/* Create _loc version of build[0-9]. */
static inline tree
build1_stat_loc (location_t loc, enum tree_code code, tree type,
tree op MEM_STAT_DECL)
{
tree t = build1_stat (code, type, op PASS_MEM_STAT);
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build1_loc(l,c,t1,t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)
static inline tree
build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree op MEM_STAT_DECL)
{
tree t = build2_stat (code, type, arg0, op PASS_MEM_STAT);
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build2_loc(l,c,t1,t2,t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)
static inline tree
build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree op MEM_STAT_DECL)
{
tree t = build3_stat (code, type, arg0, arg1, op PASS_MEM_STAT);
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build3_loc(l,c,t1,t2,t3,t4) \
build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)
static inline tree
build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree op MEM_STAT_DECL)
{
tree t = build4_stat (code, type, arg0, arg1, arg2, op PASS_MEM_STAT);
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build4_loc(l,c,t1,t2,t3,t4,t5) \
build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
/* Build an expression with void type. */
#define build1_v(code, arg) \
fold_build1_loc (input_location, code, void_type_node, arg)

7
gcc/testsuite/ChangeLog
View file

@ -1,3 +1,10 @@
2010-11-26 Jakub Jelinek <jakub@redhat.com>
PR bootstrap/45700
* trans.h (build1_stat_loc, build2_stat_loc, build3_stat_loc,
build4_stat_loc): Removed.
(build1_loc, build2_loc, build3_loc, build4_loc): Removed.
2010-11-25 Janus Weil <janus@gcc.gnu.org>
PR fortran/46581

75
gcc/tree.h
View file

@ -4034,6 +4034,81 @@ extern tree build6_stat (enum tree_code, tree, tree, tree, tree, tree,
#define build6(c,t1,t2,t3,t4,t5,t6,t7) \
build6_stat (c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
/* _loc versions of build[1-6]. */
static inline tree
build1_stat_loc (location_t loc, enum tree_code code, tree type,
tree arg1 MEM_STAT_DECL)
{
tree t = build1_stat (code, type, arg1 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build1_loc(l,c,t1,t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)
static inline tree
build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1 MEM_STAT_DECL)
{
tree t = build2_stat (code, type, arg0, arg1 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build2_loc(l,c,t1,t2,t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)
static inline tree
build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2 MEM_STAT_DECL)
{
tree t = build3_stat (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build3_loc(l,c,t1,t2,t3,t4) \
build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)
static inline tree
build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree arg3 MEM_STAT_DECL)
{
tree t = build4_stat (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build4_loc(l,c,t1,t2,t3,t4,t5) \
build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
static inline tree
build5_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
{
tree t = build5_stat (code, type, arg0, arg1, arg2, arg3,
arg4 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build5_loc(l,c,t1,t2,t3,t4,t5,t6) \
build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
static inline tree
build6_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0,
tree arg1, tree arg2, tree arg3, tree arg4,
tree arg5 MEM_STAT_DECL)
{
tree t = build6_stat (code, type, arg0, arg1, arg2, arg3, arg4,
arg5 PASS_MEM_STAT);
if (CAN_HAVE_LOCATION_P (t))
SET_EXPR_LOCATION (t, loc);
return t;
}
#define build6_loc(l,c,t1,t2,t3,t4,t5,t6,t7) \
build6_stat_loc (l,c,t1,t2,t3,t4,t5,t6,t7 MEM_STAT_INFO)
extern tree build_var_debug_value_stat (tree, tree MEM_STAT_DECL);
#define build_var_debug_value(t1,t2) \
build_var_debug_value_stat (t1,t2 MEM_STAT_INFO)