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

decl.c (annotate_value): Use test on the sign bit instead of on the sign of the value.

Browse source 
* gcc-interface/decl.c (annotate_value) <INTEGER_CST>: Use test on
	the sign bit instead of on the sign of the value.
	<PLUS_EXPR>: Turn addition of negative constant into subtraction.
	<MULT_EXPR>: Add test for degenerate case.
	<BIT_AND_EXPR>: Simplify.

From-SVN: r268286
This commit is contained in:
Eric Botcazou 2019-01-26 11:34:39 +00:00 • committed by Eric Botcazou
parent 18f5df94df
commit 03160cc9d6
2 changed files with 37 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
gcc/ada/ChangeLog
View file

@ -1,3 +1,11 @@
2019-01-26 Eric Botcazou <ebotcazou@adacore.com>
* gcc-interface/decl.c (annotate_value) <INTEGER_CST>: Use test on
the sign bit instead of on the sign of the value.
<PLUS_EXPR>: Turn addition of negative constant into subtraction.
<MULT_EXPR>: Add test for degenerate case.
<BIT_AND_EXPR>: Simplify.
2019-01-18 Sebastian Huber <sebastian.huber@embedded-brains.de>
* s-oscons-tmplt.c (AF_INET6): Do not undefine for RTEMS.

46
gcc/ada/gcc-interface/decl.c
View file

@ -8250,8 +8250,9 @@ annotate_value (tree gnu_size)
{
case INTEGER_CST:
/* For negative values, build NEGATE_EXPR of the opposite. Such values
can appear for discriminants in expressions for variants. */
if (tree_int_cst_sgn (gnu_size) < 0)
can appear for discriminants in expressions for variants. Note that,
sizetype being unsigned, we don't directly use tree_int_cst_sgn. */
if (tree_int_cst_sign_bit (gnu_size))
{
tree t = wide_int_to_tree (sizetype, -wi::to_wide (gnu_size));
tcode = Negate_Expr;
@ -8323,8 +8324,21 @@ annotate_value (tree gnu_size)
case EQ_EXPR: tcode = Eq_Expr; break;
case NE_EXPR: tcode = Ne_Expr; break;
case MULT_EXPR:
case PLUS_EXPR:
/* Turn addition of negative constant into subtraction. */
if (TREE_CODE (TREE_OPERAND (gnu_size, 1)) == INTEGER_CST
&& tree_int_cst_sign_bit (TREE_OPERAND (gnu_size, 1)))
{
tcode = Minus_Expr;
ops[0] = annotate_value (TREE_OPERAND (gnu_size, 0));
wide_int op1 = -wi::to_wide (TREE_OPERAND (gnu_size, 1));
ops[1] = annotate_value (wide_int_to_tree (sizetype, op1));
break;
}
/* ... fall through ... */
case MULT_EXPR:
tcode = (TREE_CODE (gnu_size) == MULT_EXPR ? Mult_Expr : Plus_Expr);
/* Fold conversions from bytes to bits into inner operations. */
if (TREE_CODE (TREE_OPERAND (gnu_size, 1)) == INTEGER_CST
@ -8334,6 +8348,7 @@ annotate_value (tree gnu_size)
if (TREE_CODE (inner_op) == TREE_CODE (gnu_size)
&& TREE_CODE (TREE_OPERAND (inner_op, 1)) == INTEGER_CST)
{
ops[0] = annotate_value (TREE_OPERAND (inner_op, 0));
tree inner_op_op1 = TREE_OPERAND (inner_op, 1);
tree gnu_size_op1 = TREE_OPERAND (gnu_size, 1);
widest_int op1;
@ -8341,10 +8356,13 @@ annotate_value (tree gnu_size)
op1 = (wi::to_widest (inner_op_op1)
* wi::to_widest (gnu_size_op1));
else
op1 = (wi::to_widest (inner_op_op1)
+ wi::to_widest (gnu_size_op1));
ops[1] = UI_From_gnu (wide_int_to_tree (sizetype, op1));
ops[0] = annotate_value (TREE_OPERAND (inner_op, 0));
{
op1 = (wi::to_widest (inner_op_op1)
+ wi::to_widest (gnu_size_op1));
if (wi::zext (op1, TYPE_PRECISION (sizetype)) == 0)
return ops[0];
}
ops[1] = annotate_value (wide_int_to_tree (sizetype, op1));
}
}
break;
@ -8352,18 +8370,12 @@ annotate_value (tree gnu_size)
case BIT_AND_EXPR:
tcode = Bit_And_Expr;
/* For negative values in sizetype, build NEGATE_EXPR of the opposite.
Such values appear in expressions with aligning patterns. Note that,
since sizetype is unsigned, we have to jump through some hoops. */
Such values can appear in expressions with aligning patterns. */
if (TREE_CODE (TREE_OPERAND (gnu_size, 1)) == INTEGER_CST)
{
tree op1 = TREE_OPERAND (gnu_size, 1);
wide_int signed_op1 = wi::sext (wi::to_wide (op1),
TYPE_PRECISION (sizetype));
if (wi::neg_p (signed_op1))
{
op1 = wide_int_to_tree (sizetype, wi::neg (signed_op1));
ops[1] = annotate_value (build1 (NEGATE_EXPR, sizetype, op1));
}
wide_int op1 = wi::sext (wi::to_wide (TREE_OPERAND (gnu_size, 1)),
TYPE_PRECISION (sizetype));
ops[1] = annotate_value (wide_int_to_tree (sizetype, op1));
}
break;