[Bug tree-optimization/34417] simplify '(x & A) % B' if 'B > A/2'

[Bug tree-optimization/34417] simplify '(x & A) % B' if 'B > A/2'

[pinskia at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34417

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> 2012-02-27 03:38:48 UTC ---
(In reply to comment #1)
> Confirmed.
> 
> VRP could do this, though we generally avoid creating control flow and extra
> basic blocks here.

We could create a COND_EXPR here, though I don't know if that would be a good
idea on some targets.

[Bug tree-optimization/34417] simplify '(x & A) % B' if 'B > A/2'

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=34417

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|2007-12-10 13:40:29         |2021-7-26

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Andrew Pinski from comment #2)
> (In reply to comment #1)
> > Confirmed.
> > 
> > VRP could do this, though we generally avoid creating control flow and extra
> > basic blocks here.
> 
> We could create a COND_EXPR here, though I don't know if that would be a
> good idea on some targets.

Or we could just create the MIN_EXPR :) since that is what it is.

[Bug tree-optimization/34417] New: simplify '(x & A) % B' if 'B > A/2'

[wouter dot vermaelen at scarlet dot be]

Hi,

In one of my application I need the expression '(x & 0xf) % 9'. Because of the
restricted range of (x & 0xf) it's possible to replace the modulo operation
with an if (see examples below). It would be nice if gcc could do this
optimization automatically. 

unsigned fooA(unsigned x)
{
        return (x & 0xf) % 9;
}
unsigned fooB(unsigned x)
{
        x &= 0xf;
        if (x >= 9) x -= 9;
        return x;
}
unsigned fooC(unsigned x)
{
        x &= 0xf;
        return std::min(x, x - 9);
}


The generated code is pasted below (SVN revision r130738, linux_x86_64, -O3).
Version B and C are very close (maybe C is slightly better) but they are
clearly better than version A.

fooA:   andl    $15, %edi
        movl    $954437177, %edx
        movl    %edi, %eax
        mull    %edx
        shrl    %edx
        leal    0(,%rdx,8), %eax
        addl    %edx, %eax
        subl    %eax, %edi
        movl    %edi, %eax
        ret

fooB:   andl    $15, %edi
        leal    -9(%rdi), %eax
        cmpl    $9, %edi
        cmovae  %eax, %edi
        movl    %edi, %eax
        ret

fooC:   andl    $15, %edi
        leal    -9(%rdi), %eax
        cmpl    %edi, %eax
        cmova   %edi, %eax
        ret


-- 
           Summary: simplify '(x & A) % B' if 'B > A/2'
           Product: gcc
           Version: 4.3.0
            Status: UNCONFIRMED
          Severity: enhancement
          Priority: P3
         Component: tree-optimization
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: wouter dot vermaelen at scarlet dot be


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34417

[Bug tree-optimization/34417] simplify '(x & A) % B' if 'B > A/2'

[rguenth at gcc dot gnu dot org]

------- Comment #1 from rguenth at gcc dot gnu dot org  2007-12-10 13:40 -------
Confirmed.

VRP could do this, though we generally avoid creating control flow and extra
basic blocks here.


-- 

rguenth at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |rguenth at gcc dot gnu dot
                   |                            |org
             Status|UNCONFIRMED                 |NEW
     Ever Confirmed|0                           |1
           Keywords|                            |missed-optimization
   Last reconfirmed|0000-00-00 00:00:00         |2007-12-10 13:40:29
               date|                            |


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34417