[Bug rtl-optimization/114688] New: repeat load argument of an inline function

[Bug rtl-optimization/114688] New: repeat load argument of an inline function

[absoler at smail dot nju.edu.cn]

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

            Bug ID: 114688
           Summary: repeat load argument of an inline function
           Product: gcc
           Version: 13.2.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: rtl-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: absoler at smail dot nju.edu.cn
  Target Milestone: ---

Hi, here's the case, regression from gcc-10, x86-64
```
char g;
int v;

void foo(char p_17);
void func_1() { foo(g); }

void foo(char c) { 
    v = (char)(2 - c) & c; 
}
```

-O2 produce this for `func_1`:

```
<func_1>:
foo():
  401130:       mov    $0x2,%eax
  401135:       sub    0x2ef5(%rip),%al        # 404030 <g>
  40113b:       and    0x2eef(%rip),%al        # 404030 <g>
  401141:       movsbl %al,%eax
  401144:       mov    %eax,0x2ee2(%rip)        # 40402c <v>
func_1():
  40114a:       retq
```
it seems register allocator feels it's better to repeat load `g` instead of
generating an extra `mov` to load it.

while clang-trunk choose to do so: https://godbolt.org/z/bqxz8fMYn

[Bug rtl-optimization/114688] repeat load argument of an inline function

[rguenth at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2024-04-11
           Keywords|                            |missed-optimization, ra
     Ever confirmed|0                           |1
             Target|                            |x86_64-*-*
             Status|UNCONFIRMED                 |NEW

--- Comment #1 from Richard Biener <rguenth at gcc dot gnu.org> ---
char g;
int v;

static inline __attribute__((always_inline)) void foo(char p_17);
void func_1() { foo(g); }

static inline void foo(char c) { 
    v = (char)(2 - c) & c; 
}

shows that with -Os we get

func_1:
.LFB0:
        .cfi_startproc
        movb    g(%rip), %dl
        movb    $2, %al
        subl    %edx, %eax
        andl    %edx, %eax
        movsbl  %al, %eax
        movl    %eax, v(%rip)
        ret

I think we have duplicate bugs that show we're too happy replicating
memory operands to multiple instructions.  That might be a target cost
thing in the end.

[Bug rtl-optimization/114688] repeat load argument of an inline function

[pinskia at gcc dot gnu.org]

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

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114591#c13 is talking about this
exact thing ...

So this might be expected for x86_64.