[Bug tree-optimization/112723] New: Missed optimization for invariants 'c+c' when c += -2147483648 and c is a global variable

[Bug tree-optimization/112723] New: Missed optimization for invariants 'c+c' when c += -2147483648 and c is a global variable

[652023330028 at smail dot nju.edu.cn]

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

            Bug ID: 112723
           Summary: Missed optimization for invariants 'c+c' when c +=
                    -2147483648 and c is a global variable
           Product: gcc
           Version: 14.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: tree-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: 652023330028 at smail dot nju.edu.cn
  Target Milestone: ---

Hello, we noticed that maybe there is a missed optimization for invariants
'c+c' when c+= -2147483648 and c is a global variable.
Such missed optimization affects many related optimizations, such as LICM
(where we found this issue), CSE, and others.
To describe this issue more clearly, we show an example of CSE. And we attach a
link to an example of LICM at the end.

In the following, the value of c+c is invariant between the two expressions.

In this example, c is the global variable.
https://godbolt.org/z/Y3djqKWjh

int a, b, c;
void test() {
    a = c + c;
    c += -2147483648;
    b = c + c;
}

But GCC -O3 -fwrapv or GCC -O3:
test():
        movl    c(%rip), %eax
        leal    (%rax,%rax), %edx
        addl    $-2147483648, %eax
        movl    %eax, c(%rip)
        addl    %eax, %eax      #Redundant computation
        movl    %edx, a(%rip)
        movl    %eax, b(%rip)
        ret

Expected code (Clang):
test():                               # @test()
        mov     eax, dword ptr [rip + c]
        lea     ecx, [rax + rax]
        mov     dword ptr [rip + a], ecx
        add     eax, -2147483648
        mov     dword ptr [rip + c], eax
        mov     dword ptr [rip + b], ecx
        ret

When c appears as a function argument, it works as expected:

https://godbolt.org/z/Tf6hP6M9W
int a, b;
void test(int c) {
    a = c + c;
    c += -2147483648;
    b = c + c;
}
GCC -O3:
test(int):
        leal    (%rdi,%rdi), %eax
        movl    %eax, a(%rip)
        movl    %eax, b(%rip)
        ret

An example of LICM affected by this: https://godbolt.org/z/5T89TWaG9

Thank you very much for your time and effort! We look forward to hearing from
you.

[Bug tree-optimization/112723] Missed optimization for invariants 'c+c' when c += -2147483648 and c is a global variable

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|normal                      |enhancement
           Keywords|                            |missed-optimization, TREE

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
The argument case is only optimized at the RTL level:
Trying 8 -> 9:
    8: {r87:SI=r85:SI-0x80000000;clobber flags:CC;}
      REG_DEAD r85:SI
      REG_UNUSED flags:CC
    9: {r88:SI=r87:SI<<0x1;clobber flags:CC;}
      REG_DEAD r87:SI
      REG_UNUSED flags:CC
Successfully matched this instruction:
(parallel [
        (set (reg:SI 88)
            (ashift:SI (reg/v:SI 85 [ cD.2766 ])
                (const_int 1 [0x1])))
        (clobber (reg:CC 17 flags))
    ])

[Bug tree-optimization/112723] Missed optimization for invariants 'c+c' when c += -2147483648 and c is a global variable

[rguenth at gcc dot gnu.org]

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

--- Comment #2 from Richard Biener <rguenth at gcc dot gnu.org> ---
It's combine on RTL that is able to eliminate the addition/subtraction and
postreload the redundant shift.  Nothing on GIMPLE optimizes

  c.0_2 = (unsigned int) c_5(D);
  _3 = c.0_2 + 2147483648;
  c_8 = (int) _3;
  _4 = c_8 * 2;

to

  _4 = c_5(D) * 2;

note you need to write

  c += -2147483647 - 1;

to avoid using 'long' (but I guess it's necessary to avoid undefined behavior).

So what's missing is a simplification pattern that ignores ops that only alter
bits that are dont-care in a later operation.  That fits the backprop pass
best, not special simplification patterns.

[Bug tree-optimization/112723] Missed optimization for invariants 'c+c' when c += -2147483648 and c is a global variable

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2023-11-27
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW

[Bug tree-optimization/112723] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[652023330028 at smail dot nju.edu.cn]

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

--- Comment #3 from Yi <652023330028 at smail dot nju.edu.cn> ---
https://godbolt.org/z/zKq3dsqW3
This is a regression since gcc-7.3. If the bisection right:
https://github.com/gcc-mirror/gcc/commit/540b5cb6c70.

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|enhancement                 |normal
   Target Milestone|---                         |11.5
                 CC|                            |pinskia at gcc dot gnu.org

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[pinskia at gcc dot gnu.org]

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

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
gimple-ssa-strength-reduction definitely should be improved to handle this case
where it should understand that (a+CSTWITHLASTBITSET)*2 can be done as
a*2+NEWCST if the type can wrap. Only can do that if wrapping rather than if
overflow is undefined.

For a non-signed case which should be handled:
```
unsigned a, b, c;
void test() {
    a = c + c;
    c += -2147483648u;
    b = c + c;
}
```

Maybe I will look at this for GCC 15. It might improve other code ...

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[pinskia at gcc dot gnu.org]

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

--- Comment #5 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Richard Biener from comment #2)
> 
> So what's missing is a simplification pattern that ignores ops that only
> alter
> bits that are dont-care in a later operation.  That fits the backprop pass
> best, not special simplification patterns.

I think this belongs in gimple-ssa-strength-reduction like it was done for GCC
7.1.0/7.2.0 until that fix went in which was done for all types rather than
just overflow types.

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #6 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Why is this marked as a regression?  I don't see 7.1 nor other versions behave
any differently than trunk.

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[jakub at gcc dot gnu.org]

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

--- Comment #7 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Ah, with -fwrapv.  Without -fwrapv the testcase invokes UB always, either the
first c + c overflows or the second one, or the c += -2147483647 - 1;
overflows.

[Bug tree-optimization/112723] [11/12/13/14 Regression] Missed optimization for invariants 'c+c' when c += -2147483647-1 and c is a global variable

[law at gcc dot gnu.org]

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

Jeffrey A. Law <law at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |law at gcc dot gnu.org
           Priority|P3                          |P2