[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2022-09-10 Thread roger at nextmovesoftware dot com via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

Roger Sayle  changed:

   What|Removed |Added

 Status|ASSIGNED|RESOLVED
 CC||roger at nextmovesoftware dot 
com
   Target Milestone|--- |13.0
 Resolution|--- |FIXED

--- Comment #6 from Roger Sayle  ---
This should now be fixed on mainline.

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2022-09-10 Thread roger at nextmovesoftware dot com via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956
Bug 98956 depends on bug 64992, which changed state.

Bug 64992 Summary: More optimize opportunity
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64992

   What|Removed |Added

 Status|ASSIGNED|RESOLVED
 Resolution|--- |FIXED

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2022-08-15 Thread cvs-commit at gcc dot gnu.org via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

--- Comment #5 from CVS Commits  ---
The master branch has been updated by Roger Sayle :

https://gcc.gnu.org/g:418b71c0d535bf91df78bad2e198c57934682eaa

commit r13-2048-g418b71c0d535bf91df78bad2e198c57934682eaa
Author: Roger Sayle 
Date:   Mon Aug 15 17:39:47 2022 +0100

PR tree-optimization/64992: (B << 2) != 0 is B when B is Boolean.

This patch resolves both PR tree-optimization/64992 and PR
tree-optimization/98956 which are missed optimization enhancement
request, for which Andrew Pinski already has a proposed solution
(related to a fix for PR tree-optimization/98954).  Yesterday,
I proposed an alternate improved patch for PR98954, which although
superior in most respects, alas didn't address this case [which
doesn't include a BIT_AND_EXPR], hence this follow-up fix.

For many functions, F(B), of a (zero-one) Boolean value B, the
expression F(B) != 0 can often be simplified to just B.  Hence
"(B * 5) != 0" is B, "-B != 0" is B, "bswap(B) != 0" is B,
"(B >>r 3) != 0" is B.  These are all currently optimized by GCC,
with the strange exception of left shifts by a constant (possibly
due to the undefined/implementation defined behaviour when the
shift constant is larger than the first operand's precision).
This patch adds support for this particular case, when the shift
constant is valid.

2022-08-15  Roger Sayle  

gcc/ChangeLog
PR tree-optimization/64992
PR tree-optimization/98956
* match.pd (ne (lshift @0 @1) 0): Simplify (X << C) != 0 to X
when X is zero_one_valued_p and the shift constant C is valid.
(eq (lshift @0 @1) 0): Likewise, simplify (X << C) == 0 to !X
when X is zero_one_valued_p and the shift constant C is valid.

gcc/testsuite/ChangeLog
PR tree-optimization/64992
* gcc.dg/pr64992.c: New test case.

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2021-11-30 Thread pinskia at gcc dot gnu.org via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

Andrew Pinski  changed:

   What|Removed |Added

 Depends on||64992
 Status|NEW |ASSIGNED
   Assignee|unassigned at gcc dot gnu.org  |pinskia at gcc dot 
gnu.org

--- Comment #4 from Andrew Pinski  ---
I just realized this is the same as PR 64992 which I almost have a patch. You
don't even need bools.

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64992#c8


Referenced Bugs:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64992
[Bug 64992] More optimize opportunity

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2021-11-16 Thread navidrahimi at microsoft dot com via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

Navid Rahimi  changed:

   What|Removed |Added

 CC||navidrahimi at microsoft dot 
com

--- Comment #3 from Navid Rahimi  ---
I am sending a patch for this:

/* cmp : ==, != */
/* ((B0 << CST) cmp 0) -> B0 cmp 0 */
(for cmp (eq ne)
 (simplify
  (cmp (lshift (convert @0) INTEGER_CST@1) integer_zerop@2)
  (if (TREE_CODE (TREE_TYPE (@0)) == BOOLEAN_TYPE) (cmp @0 @2


This does not apply to other arithmetic operations (at least it is not
verifiable). and for cases that it does apply to other arithmetic operators,
GCC already produces optimized code. You can play with the codegen I link
below:

Codegen:
https://compiler-explorer.com/z/nj4PTrecW

Proof:
https://alive2.llvm.org/ce/z/jyJAoS

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2021-07-16 Thread pinskia at gcc dot gnu.org via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

Andrew Pinski  changed:

   What|Removed |Added

   Severity|normal  |enhancement

--- Comment #2 from Andrew Pinski  ---
(for cmp (eq ne)
 (simplify
  (cmp (lshift truth_value@0 INTEGER_CST@1) zero_p@2)
  (cmp @0 @2)))

Something like the above, might apply to rotate too.

[Bug tree-optimization/98956] Failure to optimize out boolean left shift

2021-02-03 Thread rguenth at gcc dot gnu.org via Gcc-bugs
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98956

Richard Biener  changed:

   What|Removed |Added

 Ever confirmed|0   |1
   Last reconfirmed||2021-02-04
 Status|UNCONFIRMED |NEW

--- Comment #1 from Richard Biener  ---
Can be generalized to more arithmetic ops.