From 12085390166594050f02780cbd49a3967ecef882 Mon Sep 17 00:00:00 2001 From: "Naveen H.S" Date: Thu, 3 Sep 2015 10:20:03 +0000 Subject: [PATCH] re PR tree-optimization/67351 (Missed optimisation on 64-bit field compared to 32-bit) 2015-09-03 Naveen H.S PR middle-end/67351 gcc/ChangeLog: * fold-const.c (fold_binary_loc) : Move Transform (x >> c) << c into x & (-1<> c into x & ((unsigned)-1 >> c) for unsigned types using simplify and match. * match.pd (lshift (rshift @0 INTEGER_CST@1) @1) : New simplifier. (rshift (lshift @0 INTEGER_CST@1) @1) : New Simplifier. gcc/testsuite/ChangeLog: * g++.dg/pr66752-2.C: New test. From-SVN: r227432 --- gcc/ChangeLog | 10 ++++ gcc/fold-const.c | 26 -------- gcc/match.pd | 14 +++++ gcc/testsuite/ChangeLog | 5 ++ gcc/testsuite/g++.dg/pr67351.C | 106 +++++++++++++++++++++++++++++++++ 5 files changed, 135 insertions(+), 26 deletions(-) create mode 100644 gcc/testsuite/g++.dg/pr67351.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index f20e551f5ed..57234e7c1e0 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2015-09-03 Naveen H.S + + PR middle-end/67351 + * fold-const.c (fold_binary_loc) : Move + Transform (x >> c) << c into x & (-1<> c into x & ((unsigned)-1 >> c) for unsigned + types using simplify and match. + * match.pd (lshift (rshift @0 INTEGER_CST@1) @1) : New simplifier. + (rshift (lshift @0 INTEGER_CST@1) @1) : New Simplifier + 2015-09-03 Richard Biener PR ipa/66705 diff --git a/gcc/fold-const.c b/gcc/fold-const.c index d478c4dc1c2..a79bfa7b060 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -10412,32 +10412,6 @@ fold_binary_loc (location_t loc, prec = element_precision (type); - /* Transform (x >> c) << c into x & (-1<> c - into x & ((unsigned)-1 >> c) for unsigned types. */ - if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR) - || (TYPE_UNSIGNED (type) - && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR)) - && tree_fits_uhwi_p (arg1) - && tree_to_uhwi (arg1) < prec - && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1)) - && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec) - { - HOST_WIDE_INT low0 = tree_to_uhwi (TREE_OPERAND (arg0, 1)); - HOST_WIDE_INT low1 = tree_to_uhwi (arg1); - tree lshift; - tree arg00; - - if (low0 == low1) - { - arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)); - - lshift = build_minus_one_cst (type); - lshift = const_binop (code, lshift, arg1); - - return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift); - } - } - /* If we have a rotate of a bit operation with the rotate count and the second operand of the bit operation both constant, permute the two operations. */ diff --git a/gcc/match.pd b/gcc/match.pd index fb4b342d31d..bd5c267f1f8 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -931,6 +931,20 @@ along with GCC; see the file COPYING3. If not see && tree_expr_nonnegative_p (@1)) @0)) +/* Optimize (x >> c) << c into x & (-1<> c into x & ((unsigned)-1 >> c) for unsigned + types. */ +(simplify + (rshift (lshift @0 INTEGER_CST@1) @1) + (if (TYPE_UNSIGNED (type) + && (wi::ltu_p (@1, element_precision (type)))) + (bit_and @0 (rshift { build_minus_one_cst (type); } @1)))) + (for shiftrotate (lrotate rrotate lshift rshift) (simplify (shiftrotate @0 integer_zerop) diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 97bdd7a10ea..c107835c41d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2015-09-03 Naveen H.S + + PR middle-end/67351 + * g++.dg/pr66752-2.C: New test. + 2015-09-03 Richard Biener PR ipa/66705 diff --git a/gcc/testsuite/g++.dg/pr67351.C b/gcc/testsuite/g++.dg/pr67351.C new file mode 100644 index 00000000000..f5bdda6cca7 --- /dev/null +++ b/gcc/testsuite/g++.dg/pr67351.C @@ -0,0 +1,106 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned long long uint64; + +class MyRgba +{ + uint rgba; + +public: + explicit MyRgba (uint c):rgba (c) + { + }; + + static MyRgba fromRgba (uchar r, uchar g, uchar b, uchar a) + { + return MyRgba (uint (r) << 24 + | uint (g) << 16 | uint (b) << 8 | uint (a)); + } + + uchar r () + { + return rgba >> 24; + } + uchar g () + { + return rgba >> 16; + } + uchar b () + { + return rgba >> 8; + } + uchar a () + { + return rgba; + } + + void setG (uchar _g) + { + *this = fromRgba (r (), _g, b (), a ()); + } +}; + +extern MyRgba giveMe (); + +MyRgba +test () +{ + MyRgba a = giveMe (); + a.setG (0xf0); + return a; +} + +class MyRgba64 +{ + uint64 rgba; + +public: + explicit MyRgba64 (uint64 c):rgba (c) + { + }; + + static MyRgba64 fromRgba64 (ushort r, ushort g, ushort b, ushort a) + { + return MyRgba64 (uint64 (r) << 48 + | uint64 (g) << 32 | uint64 (b) << 16 | uint64 (a)); + } + + ushort r () + { + return rgba >> 48; + } + ushort g () + { + return rgba >> 32; + } + ushort b () + { + return rgba >> 16; + } + ushort a () + { + return rgba; + } + + void setG (ushort _g) + { + *this = fromRgba64 (r (), _g, b (), a ()); + } +}; + +extern MyRgba64 giveMe64 (); + +MyRgba64 +test64 () +{ + MyRgba64 a = giveMe64 (); + a.setG (0xf0f0); + return a; +} + +/* { dg-final { scan-tree-dump-not "<<" "optimized" } } */ +/* { dg-final { scan-tree-dump-not ">>" "optimized" } } */ -- 2.30.2