[Bug tree-optimization/64910] New: tree reassociation results in poor code

[law at redhat dot com]

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

            Bug ID: 64910
           Summary: tree reassociation results in poor code
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: tree-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: law at redhat dot com

Tree reassociation seems to be taking expressions of the form
(X & Y) & C

Where X & Y are objects and C is a constant.  And turns them into

(Y & C) & X

The problem with generating that kind of code is it makes it much harder for
the backends to (for example) create bitfield test instructions.

Here's a concrete example:

int v;
int b2b (unsigned char u, unsigned char w)
{
  if ((u & w) & 0x20)
    v = 1; 
}

Generates the following .reassoc dump fragment

  <bb 2>:
  _8 = w_3(D) & 32;
  _7 = _8 & u_2(D);
  if (_7 != 0)


To turn that into a bitfield test something is going to have to look at all
three statements to determine that _8 can only have a single bit set and thus
_7 can only have a single bet set.

Contrast to the following after hacking up reassoc a bit:

 _4 = u_2(D) & w_3(D);
  _7 = _4 & 32;
  if (_7 != 0)


Which looks like a canonical bit test instruction.

The ranking of the operands in the array looks correct (X, Y, CONST).  But when
we go to rebuild the expression using the simple 3 operand recursive
rewrite_expr_tree, we pair up the last two operands into an operation (Y &
CONST), then create X & (Y & CONST) thus generating the poor code.