2007-01-11 Roger Sayle <roger@eyesopen.com>
+ * builtins.c (expand_builtin_pow, expand_builtin_powi,
+ fold_builtin_cabs, fold_builtin_sqrt, fold_builtin_trunc,
+ fold_builtin_floor, fold_builtin_ceil, fold_builtin_round,
+ fold_builtin_int_int_roundingfn, fold_builtin_bitop,
+ fold_builtin_bswap, real_constp, fold_builtin_pow,
+ fold_builtin_powi, fold_builtin_signbit, fold_builtin_copysign,
+ do_mpfr_arg1, do_mpfr_arg2, do_mpfr_arg3, do_mpfr_sincos): Replace
+ uses of the macro TREE_CONSTANT_OVERFLOW with TREE_OVERFLOW.
+ * convert.c (convert_to_pointer): Likewise.
+ * expr.c (highest_pow2_factor, expand_expr_real_1): Likewise.
+ * fold-const.c (force_fit_type, fold_negate_expr, int_const_binop,
+ const_binop, fold_convert_const_int_from_int,
+ fold_convert_const_int_from_real,
+ fold_convert_const_real_from_real, sign_bit_p,
+ optimize_minmax_comparison, extract_muldiv_1, fold_div_compare,
+ fold_sign_changed_comparison, fold_unary, fold_comparison,
+ fold_binary, multiple_of_p, tree_Expr_non_zero_p,
+ fold_negate_const, fold_abs_const, fold_not_const): Likewise.
+ * print-tree.c (print_node_brief, print_node): Likewise.
+ * stor-layout.c (place_field, layout_type): Likewise.
+ * tree-chrec.c (keep_cast): Likewise.
+ * tree.c (build_vector, build_real, build_real_from_int_cst,
+ build_complex): Likewise.
+
+2007-01-11 Roger Sayle <roger@eyesopen.com>
+
* tree.h (TREE_CONSTANT_OVERFLOW): Obsolete. For the time being,
treat TREE_CONSTANT_OVERFLOW as a synonym of TREE_OVERFLOW.
/* Expand builtin functions.
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GCC.
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
if (TREE_CODE (arg1) != REAL_CST
- || TREE_CONSTANT_OVERFLOW (arg1))
+ || TREE_OVERFLOW (arg1))
return expand_builtin_mathfn_2 (exp, target, subtarget);
/* Handle constant exponents. */
/* Handle constant power. */
if (TREE_CODE (arg1) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (arg1))
+ && !TREE_OVERFLOW (arg1))
{
HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
&& TREE_CODE (arg) == COMPLEX_CST
&& TREE_CODE (TREE_REALPART (arg)) == REAL_CST
&& TREE_CODE (TREE_IMAGPART (arg)) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (TREE_REALPART (arg))
- && ! TREE_CONSTANT_OVERFLOW (TREE_IMAGPART (arg)))
+ && !TREE_OVERFLOW (TREE_REALPART (arg))
+ && !TREE_OVERFLOW (TREE_IMAGPART (arg)))
{
REAL_VALUE_TYPE r, i;
/* Optimize sqrt of constant value. */
if (TREE_CODE (arg) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg))
+ && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE r, x;
/* Optimize trunc of constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE r, x;
tree type = TREE_TYPE (TREE_TYPE (fndecl));
/* Optimize floor of constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE x;
/* Optimize ceil of constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE x;
/* Optimize round of constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE x;
/* Optimize lround of constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
/* Optimize for constant argument. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
{
HOST_WIDE_INT hi, width, result;
unsigned HOST_WIDE_INT lo;
/* Optimize constant value. */
arg = TREE_VALUE (arglist);
- if (TREE_CODE (arg) == INTEGER_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
{
HOST_WIDE_INT hi, width, r_hi = 0;
unsigned HOST_WIDE_INT lo, r_lo = 0;
STRIP_NOPS (expr);
return ((TREE_CODE (expr) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (expr)
+ && !TREE_OVERFLOW (expr)
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), *value))
|| (TREE_CODE (expr) == COMPLEX_CST
&& real_dconstp (TREE_REALPART (expr), value)
return omit_one_operand (type, build_real (type, dconst1), arg1);
if (TREE_CODE (arg1) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg1))
+ && !TREE_OVERFLOW (arg1))
{
REAL_VALUE_TYPE cint;
REAL_VALUE_TYPE c;
{
/* Attempt to evaluate pow at compile-time. */
if (TREE_CODE (arg0) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg0))
+ && !TREE_OVERFLOW (arg0))
{
REAL_VALUE_TYPE x;
bool inexact;
/* Evaluate powi at compile-time. */
if (TREE_CODE (arg0) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg0))
+ && !TREE_OVERFLOW (arg0))
{
REAL_VALUE_TYPE x;
x = TREE_REAL_CST (arg0);
/* If ARG is a compile-time constant, determine the result. */
if (TREE_CODE (arg) == REAL_CST
- && !TREE_CONSTANT_OVERFLOW (arg))
+ && !TREE_OVERFLOW (arg))
{
REAL_VALUE_TYPE c;
/* If ARG1 and ARG2 are compile-time constants, determine the result. */
if (TREE_CODE (arg1) == REAL_CST
&& TREE_CODE (arg2) == REAL_CST
- && !TREE_CONSTANT_OVERFLOW (arg1)
- && !TREE_CONSTANT_OVERFLOW (arg2))
+ && !TREE_OVERFLOW (arg1)
+ && !TREE_OVERFLOW (arg2))
{
REAL_VALUE_TYPE c1, c2;
/* To proceed, MPFR must exactly represent the target floating point
format, which only happens when the target base equals two. */
if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
- && TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
{
const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
/* To proceed, MPFR must exactly represent the target floating point
format, which only happens when the target base equals two. */
if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
- && TREE_CODE (arg1) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg1)
- && TREE_CODE (arg2) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg2))
+ && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
+ && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
{
const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
/* To proceed, MPFR must exactly represent the target floating point
format, which only happens when the target base equals two. */
if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
- && TREE_CODE (arg1) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg1)
- && TREE_CODE (arg2) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg2)
- && TREE_CODE (arg3) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg3))
+ && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
+ && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
+ && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
{
const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
/* To proceed, MPFR must exactly represent the target floating point
format, which only happens when the target base equals two. */
if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
- && TREE_CODE (arg) == REAL_CST && ! TREE_CONSTANT_OVERFLOW (arg))
+ && TREE_CODE (arg) == REAL_CST
+ && !TREE_OVERFLOW (arg))
{
const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
/* Utility routines for data type conversion for GCC.
Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1997, 1998,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GCC.
/* Propagate overflow to the NULL pointer. */
if (integer_zerop (expr))
return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr),
- TREE_CONSTANT_OVERFLOW (expr));
+ false);
switch (TREE_CODE (TREE_TYPE (expr)))
{
/* Convert tree expression to rtl instructions, for GNU compiler.
Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
- Inc.
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GCC.
a MIN_EXPR, or a MAX_EXPR. If the constant overflows, we have an
erroneous program, so return BIGGEST_ALIGNMENT to avoid any
later ICE. */
- if (TREE_CONSTANT_OVERFLOW (exp))
+ if (TREE_OVERFLOW (exp))
return BIGGEST_ALIGNMENT;
else
{
simplified by validate_replace_rtx during virtual register
instantiation, which can result in unrecognizable insns.
Avoid this by forcing all overflows into registers. */
- if (TREE_CONSTANT_OVERFLOW (exp)
+ if (TREE_OVERFLOW (exp)
&& modifier != EXPAND_INITIALIZER)
temp = force_reg (mode, temp);
force_fit_type takes a constant, an overflowable flag and prior
overflow indicators. It forces the value to fit the type and sets
- TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.
+ TREE_OVERFLOW as appropriate.
Note: Since the folders get called on non-gimple code as well as
gimple code, we need to handle GIMPLE tuples as well as their
OVERFLOWED is nonzero,
or OVERFLOWABLE is >0 and signed overflow occurs
or OVERFLOWABLE is <0 and any overflow occurs
- We set TREE_CONSTANT_OVERFLOWED if,
- CONST_OVERFLOWED is nonzero
- or we set TREE_OVERFLOWED.
We return a new tree node for the extended double-int. The node
is shared if no overflow flags are set. */
TREE_INT_CST_HIGH (t) = high;
TREE_TYPE (t) = type;
TREE_OVERFLOW (t) = 1;
- TREE_CONSTANT_OVERFLOW (t) = 1;
-
- return t;
- }
- else if (overflowed_const)
- {
- tree t = make_node (INTEGER_CST);
- TREE_INT_CST_LOW (t) = low;
- TREE_INT_CST_HIGH (t) = high;
- TREE_TYPE (t) = type;
- TREE_CONSTANT_OVERFLOW (t) = 1;
-
return t;
}
}
case INTEGER_CST:
tem = fold_negate_const (t, type);
- if (! TREE_OVERFLOW (tem)
+ if (!TREE_OVERFLOW (tem)
|| TYPE_UNSIGNED (type)
- || ! flag_trapv)
+ || !flag_trapv)
return tem;
break;
case REAL_CST:
tem = fold_negate_const (t, type);
/* Two's complement FP formats, such as c4x, may overflow. */
- if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
+ if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
return tem;
break;
case EXACT_DIV_EXPR:
/* This is a shortcut for a common special case. */
if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
- && ! TREE_CONSTANT_OVERFLOW (arg1)
- && ! TREE_CONSTANT_OVERFLOW (arg2)
+ && !TREE_OVERFLOW (arg1)
+ && !TREE_OVERFLOW (arg2)
&& int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
{
if (code == CEIL_DIV_EXPR)
case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
/* This is a shortcut for a common special case. */
if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
- && ! TREE_CONSTANT_OVERFLOW (arg1)
- && ! TREE_CONSTANT_OVERFLOW (arg2)
+ && !TREE_OVERFLOW (arg1)
+ && !TREE_OVERFLOW (arg2)
&& int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
{
if (code == CEIL_MOD_EXPR)
{
t = copy_node (t);
TREE_OVERFLOW (t) = 1;
- TREE_CONSTANT_OVERFLOW (t) = 1;
- }
- else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
- {
- t = copy_node (t);
- TREE_CONSTANT_OVERFLOW (t) = 1;
}
}
else
t = force_fit_type_double (TREE_TYPE (arg1), low, hi, 1,
((!uns || is_sizetype) && overflow)
| TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2),
- TREE_CONSTANT_OVERFLOW (arg1)
- | TREE_CONSTANT_OVERFLOW (arg2));
+ false);
return t;
}
t = build_real (type, result);
TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
- TREE_CONSTANT_OVERFLOW (t)
- = TREE_OVERFLOW (t)
- | TREE_CONSTANT_OVERFLOW (arg1)
- | TREE_CONSTANT_OVERFLOW (arg2);
return t;
}
&& (TYPE_UNSIGNED (type)
< TYPE_UNSIGNED (TREE_TYPE (arg1))))
| TREE_OVERFLOW (arg1),
- TREE_CONSTANT_OVERFLOW (arg1));
+ false);
return t;
}
t = force_fit_type_double (type, low, high, -1,
overflow | TREE_OVERFLOW (arg1),
- TREE_CONSTANT_OVERFLOW (arg1));
+ false);
return t;
}
t = build_real (type, value);
TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
- TREE_CONSTANT_OVERFLOW (t)
- = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
return t;
}
/* Tree VAL must be an integer constant. */
if (TREE_CODE (val) != INTEGER_CST
- || TREE_CONSTANT_OVERFLOW (val))
+ || TREE_OVERFLOW (val))
return NULL_TREE;
width = TYPE_PRECISION (t);
/* If something does not permit us to optimize, return the original tree. */
if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
|| TREE_CODE (comp_const) != INTEGER_CST
- || TREE_CONSTANT_OVERFLOW (comp_const)
+ || TREE_OVERFLOW (comp_const)
|| TREE_CODE (minmax_const) != INTEGER_CST
- || TREE_CONSTANT_OVERFLOW (minmax_const))
+ || TREE_OVERFLOW (minmax_const))
return NULL_TREE;
/* Now handle all the various comparison codes. We only handle EQ_EXPR
possible later conversion to our or some other type. */
if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
&& TREE_CODE (t2) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (t2)
+ && !TREE_OVERFLOW (t2)
&& (0 != (t1 = extract_muldiv (op0, t2, code,
code == MULT_EXPR
? ctype : NULL_TREE))))
const_binop (LSHIFT_EXPR,
size_one_node,
op1, 0)))
- && ! TREE_OVERFLOW (t1))
+ && !TREE_OVERFLOW (t1))
return extract_muldiv (build2 (tcode == LSHIFT_EXPR
? MULT_EXPR : FLOOR_DIV_EXPR,
ctype, fold_convert (ctype, op0), t1),
if (tcode == code
&& 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
fold_convert (ctype, c), 0))
- && ! TREE_OVERFLOW (t1))
+ && !TREE_OVERFLOW (t1))
return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
/* If these operations "cancel" each other, we have the main
&lpart, &hpart, unsigned_p);
hi = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
-1, overflow | TREE_OVERFLOW (prod),
- TREE_CONSTANT_OVERFLOW (prod));
+ false);
}
else if (tree_int_cst_sgn (arg01) >= 0)
{
arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
TREE_INT_CST_HIGH (arg1), 0,
TREE_OVERFLOW (arg1),
- TREE_CONSTANT_OVERFLOW (arg1));
+ false);
else
arg1 = fold_convert (inner_type, arg1);
tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
TREE_INT_CST_HIGH (and1), 0,
TREE_OVERFLOW (and1),
- TREE_CONSTANT_OVERFLOW (and1));
+ false);
return fold_build2 (BIT_AND_EXPR, type,
fold_convert (type, and0), tem);
}
&& 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
? MINUS_EXPR : PLUS_EXPR,
arg1, TREE_OPERAND (arg0, 1), 0))
- && ! TREE_CONSTANT_OVERFLOW (tem))
+ && !TREE_OVERFLOW (tem))
return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
/* Likewise, we can simplify a comparison of a real constant with
&& TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
&& 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
arg1, 0))
- && ! TREE_CONSTANT_OVERFLOW (tem))
+ && !TREE_OVERFLOW (tem))
return fold_build2 (swap_tree_comparison (code), type,
TREE_OPERAND (arg0, 1), tem);
tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
1)));
if (TREE_CODE (arg11) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg11)
+ && !TREE_OVERFLOW (arg11)
&& operand_equal_p (arg0, arg10, 0))
{
tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
1)));
if (TREE_CODE (arg01) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg01)
+ && !TREE_OVERFLOW (arg01)
&& operand_equal_p (arg1, arg00, 0))
{
tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
if (TREE_CODE (arg01) == REAL_CST
- && ! TREE_CONSTANT_OVERFLOW (arg01)
+ && !TREE_OVERFLOW (arg01)
&& operand_equal_p (arg1, arg00, 0))
{
tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
if (code == TRUNC_MOD_EXPR
&& !TYPE_UNSIGNED (type)
&& TREE_CODE (arg1) == INTEGER_CST
- && !TREE_CONSTANT_OVERFLOW (arg1)
+ && !TREE_OVERFLOW (arg1)
&& TREE_INT_CST_HIGH (arg1) < 0
&& !flag_trapv
/* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
? MINUS_EXPR : PLUS_EXPR,
fold_convert (TREE_TYPE (arg0), arg1),
TREE_OPERAND (arg0, 1), 0))
- && ! TREE_CONSTANT_OVERFLOW (tem))
+ && !TREE_OVERFLOW (tem))
return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
/* Similarly for a NEGATE_EXPR. */
&& TREE_CODE (arg1) == INTEGER_CST
&& 0 != (tem = negate_expr (arg1))
&& TREE_CODE (tem) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (tem))
+ && !TREE_OVERFLOW (tem))
return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
/* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
unsigned int width = TYPE_PRECISION (arg1_type);
if (TREE_CODE (arg1) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (arg1)
+ && !TREE_OVERFLOW (arg1)
&& width <= 2 * HOST_BITS_PER_WIDE_INT
&& (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
{
&& ! TREE_SIDE_EFFECTS (arg0)
&& (0 != (tem = negate_expr (arg1)))
&& TREE_CODE (tem) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (tem))
+ && !TREE_OVERFLOW (tem))
return fold_build2 (TRUTH_ANDIF_EXPR, type,
build2 (GE_EXPR, type,
TREE_OPERAND (arg0, 0), tem),
const_binop (LSHIFT_EXPR,
size_one_node,
op1, 0)))
- && ! TREE_OVERFLOW (t1))
+ && !TREE_OVERFLOW (t1))
return multiple_of_p (type, t1, bottom);
}
return 0;
return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
case INTEGER_CST:
- /* We used to test for !integer_zerop here. This does not work correctly
- if TREE_CONSTANT_OVERFLOW (t). */
- return (TREE_INT_CST_LOW (t) != 0
- || TREE_INT_CST_HIGH (t) != 0);
+ return !integer_zerop (t);
case PLUS_EXPR:
if (!TYPE_UNSIGNED (type) && !flag_wrapv)
t = force_fit_type_double (type, low, high, 1,
(overflow | TREE_OVERFLOW (arg0))
&& !TYPE_UNSIGNED (type),
- TREE_CONSTANT_OVERFLOW (arg0));
+ false);
break;
}
&low, &high);
t = force_fit_type_double (type, low, high, -1,
overflow | TREE_OVERFLOW (arg0),
- TREE_CONSTANT_OVERFLOW (arg0));
+ false);
}
break;
t = force_fit_type_double (type, ~TREE_INT_CST_LOW (arg0),
~TREE_INT_CST_HIGH (arg0), 0,
TREE_OVERFLOW (arg0),
- TREE_CONSTANT_OVERFLOW (arg0));
+ false);
return t;
}
/* Prints out tree in human readable form - GCC
Copyright (C) 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GCC.
/* We might as well always print the value of an integer or real. */
if (TREE_CODE (node) == INTEGER_CST)
{
- if (TREE_CONSTANT_OVERFLOW (node))
+ if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
fprintf (file, " ");
switch (TREE_CODE (node))
{
case INTEGER_CST:
- if (TREE_CONSTANT_OVERFLOW (node))
+ if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
fprintf (file, " ");
/* C-compiler utilities for types and variables storage layout
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GCC.
if (DECL_SIZE (field) == 0)
/* Do nothing. */;
else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
- || TREE_CONSTANT_OVERFLOW (DECL_SIZE (field)))
+ || TREE_OVERFLOW (DECL_SIZE (field)))
{
rli->offset
= size_binop (PLUS_EXPR, rli->offset,
&& TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
/* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
TYPE_ALIGN_UNIT. */
- && !TREE_CONSTANT_OVERFLOW (TYPE_SIZE_UNIT (element))
+ && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
&& !integer_zerop (TYPE_SIZE_UNIT (element))
&& compare_tree_int (TYPE_SIZE_UNIT (element),
TYPE_ALIGN_UNIT (element)) < 0)
/* Chains of recurrences.
- Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
Contributed by Sebastian Pop <pop@cri.ensmp.fr>
This file is part of GCC.
/* Don't propagate overflows. */
if (CONSTANT_CLASS_P (res))
- {
- TREE_CONSTANT_OVERFLOW (res) = 0;
- TREE_OVERFLOW (res) = 0;
- }
+ TREE_OVERFLOW (res) = 0;
/* But reject constants that don't fit in their type after conversion.
This can happen if TYPE_MIN_VALUE or TYPE_MAX_VALUE are not the
/* Language-independent node constructors for parse phase of GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GCC.
build_vector (tree type, tree vals)
{
tree v = make_node (VECTOR_CST);
- int over1 = 0, over2 = 0;
+ int over = 0;
tree link;
TREE_VECTOR_CST_ELTS (v) = vals;
if (!CONSTANT_CLASS_P (value))
continue;
- over1 |= TREE_OVERFLOW (value);
- over2 |= TREE_CONSTANT_OVERFLOW (value);
+ over |= TREE_OVERFLOW (value);
}
- TREE_OVERFLOW (v) = over1;
- TREE_CONSTANT_OVERFLOW (v) = over2;
-
+ TREE_OVERFLOW (v) = over;
return v;
}
TREE_TYPE (v) = type;
TREE_REAL_CST_PTR (v) = dp;
- TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
+ TREE_OVERFLOW (v) = overflow;
return v;
}
v = build_real (type, real_value_from_int_cst (type, i));
TREE_OVERFLOW (v) |= overflow;
- TREE_CONSTANT_OVERFLOW (v) |= overflow;
return v;
}
TREE_IMAGPART (t) = imag;
TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
- TREE_CONSTANT_OVERFLOW (t)
- = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
return t;
}
projects / platform / upstream / linaro-gcc.git / commitdiff