From 74890d7bbdacf14edfcd1e50bac0e5053a2bdf53 Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Sun, 28 Jan 2007 03:48:41 +0000 Subject: [PATCH] fold-const.c (size_binop): In the fast-paths for X+0... * fold-const.c (size_binop): In the fast-paths for X+0, 0+X, X-0 and 1*X check that the constant hasn't overflowed, to preserve the TREE_OVERFLOW bit. (round_up): Provide an efficient implementation when rouding-up an INTEGER_CST to a power-of-two. * gcc-dg/large-size-array-3.c: New test case. From-SVN: r121252 --- gcc/ChangeLog | 8 ++++ gcc/fold-const.c | 58 ++++++++++++++++++----- gcc/testsuite/ChangeLog | 4 ++ gcc/testsuite/gcc.dg/large-size-array-3.c | 20 ++++++++ 4 files changed, 79 insertions(+), 11 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/large-size-array-3.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 7d566d21b85..2f0b43957c7 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2007-01-27 Roger Sayle + + * fold-const.c (size_binop): In the fast-paths for X+0, 0+X, X-0 and + 1*X check that the constant hasn't overflowed, to preserve the + TREE_OVERFLOW bit. + (round_up): Provide an efficient implementation when rouding-up an + INTEGER_CST to a power-of-two. + 2007-01-28 Ralf Wildenhues * doc/sourcebuild.texi: Add comma for clarity. diff --git a/gcc/fold-const.c b/gcc/fold-const.c index cd4d6847065..b6065871ffd 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -1815,13 +1815,23 @@ size_binop (enum tree_code code, tree arg0, tree arg1) if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST) { /* And some specific cases even faster than that. */ - if (code == PLUS_EXPR && integer_zerop (arg0)) - return arg1; - else if ((code == MINUS_EXPR || code == PLUS_EXPR) - && integer_zerop (arg1)) - return arg0; - else if (code == MULT_EXPR && integer_onep (arg0)) - return arg1; + if (code == PLUS_EXPR) + { + if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0)) + return arg1; + if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1)) + return arg0; + } + else if (code == MINUS_EXPR) + { + if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1)) + return arg0; + } + else if (code == MULT_EXPR) + { + if (integer_onep (arg0) && !TREE_OVERFLOW (arg0)) + return arg1; + } /* Handle general case of two integer constants. */ return int_const_binop (code, arg0, arg1, 0); @@ -13505,10 +13515,36 @@ round_up (tree value, int divisor) { tree t; - t = build_int_cst (TREE_TYPE (value), divisor - 1); - value = size_binop (PLUS_EXPR, value, t); - t = build_int_cst (TREE_TYPE (value), -divisor); - value = size_binop (BIT_AND_EXPR, value, t); + if (TREE_CODE (value) == INTEGER_CST) + { + unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (value); + HOST_WIDE_INT high; + + if ((low & (divisor - 1)) == 0) + return value; + + high = TREE_INT_CST_HIGH (value); + low &= ~(divisor - 1); + low += divisor; + if (low == 0) + high++; + + t = build_int_cst_wide_type (TREE_TYPE (value), low, high); + if ((TREE_OVERFLOW (value) || integer_zerop (t)) + && !TREE_OVERFLOW (t)) + { + t = copy_node (t); + TREE_OVERFLOW (t) = 1; + } + return t; + } + else + { + t = build_int_cst (TREE_TYPE (value), divisor - 1); + value = size_binop (PLUS_EXPR, value, t); + t = build_int_cst (TREE_TYPE (value), -divisor); + value = size_binop (BIT_AND_EXPR, value, t); + } } else { diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index ce96d1a72c5..9ed1d06b7ba 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2007-01-27 Roger Sayle + + * gcc-dg/large-size-array-3.c: New test case. + 2007-01-27 Roger Sayle * gfortran.dg/forall_7.f90: New test case. diff --git a/gcc/testsuite/gcc.dg/large-size-array-3.c b/gcc/testsuite/gcc.dg/large-size-array-3.c new file mode 100644 index 00000000000..954e28e5fda --- /dev/null +++ b/gcc/testsuite/gcc.dg/large-size-array-3.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ + +#ifdef __LP64__ +#define DIM UINT_MAX>>1 +#else +#define DIM 65536 +#endif + +int +sub (int *a) +{ + return a[0]; +} + +int +main (void) +{ + int a[DIM][DIM]; /* { dg-error "size of array 'a' is too large" } */ + return sub (&a[0][0]); +}