[Bug c/113106] New: Missing CSE with cast to volatile

[Bug c/113106] New: Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

            Bug ID: 113106
           Summary: Missing CSE with cast to volatile
           Product: gcc
           Version: 12.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: ubizjak at gmail dot com
  Target Milestone: ---

The following testcase:

--cut here--
int a;

int foo(void)
{
  return *(volatile int *) &a + a;
}
--cut here--

compiles with -O2 to:

        movl    a(%rip), %eax
        addl    a(%rip), %eax
        ret

with more detail:

#(insn:TI 6 7 8 2 (set (reg:SI 0 ax [orig:98 _1 ] [98])
#        (mem/v/c:SI (symbol_ref:DI ("a") [flags 0x2] <var_decl
0x7f59db15ac60a>) [1 MEM[(volatile int *)&a]+0 S4 A32])) "vol.c":5:10 85
{*movsi_internal}
#     (nil))
        movl    a(%rip), %eax   # 6     [c=5 l=6]  *movsi_internal/0
#(insn 8 6 14 2 (parallel [
#            (set (reg:SI 0 ax [102])
#                (plus:SI (reg:SI 0 ax [orig:98 _1 ] [98])
#                    (mem/c:SI (symbol_ref:DI ("a") [flags 0x2] <var_decl
0x7f59db15ac60 a>) [1 a+0 S4 A32])))
#            (clobber (reg:CC 17 flags))
#        ]) "vol.c":5:31 271 {*addsi_1}
#     (expr_list:REG_UNUSED (reg:CC 17 flags)
#        (nil)))
        addl    a(%rip), %eax   # 8     [c=9 l=6]  *addsi_1/1

This may be compiled to:

        movl    a(%rip), %eax
        addl    %eax, %eax
        ret

since only one read uses volatile.

[Bug c/113106] Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

--- Comment #1 from Uroš Bizjak <ubizjak at gmail dot com> ---
Perhaps related,

--cut here--
int a;

int foo(void)
{
  return *(volatile int *) &a + *(volatile int *) &a;
}
--cut here--

compiles with -O2 to:

        movl    a(%rip), %eax
        movl    a(%rip), %edx
        addl    %edx, %eax
        ret

but may be compiled to:

        movl    a(%rip), %eax
        addl    a(%rip), %eax
        ret

(the memory read may propagate to the insn)

[Bug c/113106] Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

--- Comment #2 from Uroš Bizjak <ubizjak at gmail dot com> ---
For reference, the same optimization should be applied with address spaces:

--cut here--
int __seg_gs b;

int bar(void)
{
  return *(volatile __seg_gs int *) &b + b;
}
--cut here--

the above testcase currently compiles to:

        movl    %gs:b(%rip), %eax
        addl    %gs:b(%rip), %eax
        ret

but can be compiled to:

        movl    %gs:b(%rip), %eax
        addl    %eax, %eax
        ret

[Bug c/113106] Missing CSE with cast to volatile

[rguenth at gcc dot gnu.org]

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

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

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

--- Comment #3 from Richard Biener <rguenth at gcc dot gnu.org> ---
The situation with address-spaces isn't valid as we need to preserve the second
load because it's volatile.  I think we simply refuse to combine
volatile loads out of caution in the first case.

[Bug c/113106] Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

--- Comment #4 from Uroš Bizjak <ubizjak at gmail dot com> ---
(In reply to Richard Biener from comment #3)
> The situation with address-spaces isn't valid as we need to preserve the
> second load because it's volatile.  I think we simply refuse to combine
> volatile loads out of caution in the first case.

int __seg_gs b;
return *(volatile __seg_gs int *) &b + b;

But the above is the same w.r.t to volatile as:

int a;
return *(volatile int *) &a + a;

?

BTW: I also checked with clang, and it creates expected code in all cases.

[Bug c/113106] Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

--- Comment #5 from Uroš Bizjak <ubizjak at gmail dot com> ---
The issue in comment #2 happens in a couple of places when compiling linux
kernel (with named address spaces enabled). However, the issue is not specific
to named AS, I was just more attentive to moves from %gs: prefixed locations.

[Bug rtl-optimization/113106] Missing CSE with cast to volatile

[rguenth at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
          Component|c                           |rtl-optimization
     Ever confirmed|0                           |1
           Keywords|                            |missed-optimization
   Last reconfirmed|                            |2023-12-21
             Status|UNCONFIRMED                 |NEW

--- Comment #6 from Richard Biener <rguenth at gcc dot gnu.org> ---
(In reply to Uroš Bizjak from comment #4)
> (In reply to Richard Biener from comment #3)
> > The situation with address-spaces isn't valid as we need to preserve the
> > second load because it's volatile.  I think we simply refuse to combine
> > volatile loads out of caution in the first case.
> 
> int __seg_gs b;
> return *(volatile __seg_gs int *) &b + b;
> 
> But the above is the same w.r.t to volatile as:
> 
> int a;
> return *(volatile int *) &a + a;
> 
> ?
> 
> BTW: I also checked with clang, and it creates expected code in all cases.

But you don't get

       movl    %gs:b(%rip), %eax
       addl    %eax, %eax

or

       movl    b(%rip), %eax
       addl    %eax, %eax

which I think would be wrong.  The volatile access doesn't need to yield
the same value as the non-volatile one so we can't value-number them the
same.

The combine issue remains of course.  But GCCs point was always that
trying to optimize volatile is wasted time.

[Bug rtl-optimization/113106] Missing CSE with cast to volatile

[ubizjak at gmail dot com]

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

--- Comment #7 from Uroš Bizjak <ubizjak at gmail dot com> ---
(In reply to Richard Biener from comment #6)

> > BTW: I also checked with clang, and it creates expected code in all cases.
> 
> But you don't get
> 
>        movl    %gs:b(%rip), %eax
>        addl    %eax, %eax
> 
> or
> 
>        movl    b(%rip), %eax
>        addl    %eax, %eax
> 
> which I think would be wrong.  The volatile access doesn't need to yield
> the same value as the non-volatile one so we can't value-number them the
> same.

The above is the code that clang produces for the testcases in Comment #2 and
Comment #0.

clang version 15.0.7 (Fedora 15.0.7-2.fc37)

[Bug rtl-optimization/113106] Missing CSE with cast to volatile

[pinskia at gcc dot gnu.org]

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

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Uroš Bizjak from comment #1)
> Perhaps related,
> 
> --cut here--
> int a;
> 
> int foo(void)
> {
>   return *(volatile int *) &a + *(volatile int *) &a;
> }
> --cut here--
> 
> compiles with -O2 to:
> 
>         movl    a(%rip), %eax
>         movl    a(%rip), %edx
>         addl    %edx, %eax
>         ret
> 
> but may be compiled to:
> 
>         movl    a(%rip), %eax
>         addl    a(%rip), %eax
>         ret
> 
> (the memory read may propagate to the insn)

That is pr 3506