[Bug c++/110381] New: Incorrect loop unrolling for structs of floating point types

[lennox.ho at intel dot com via Gcc-bugs]

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

            Bug ID: 110381
           Summary: Incorrect loop unrolling for structs of floating point
                    types
           Product: gcc
           Version: 12.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: lennox.ho at intel dot com
  Target Milestone: ---

We believe gcc is incorrectly unrolling loops while performing summation of
structs with floating point members:

Here's a minimal example:

```
#include <iostream>

using value_type = double;

struct FOO {
   value_type a = 0;
   value_type b = 0;
   value_type c = 0;
};

value_type sum_8_foos(const FOO* foos) {
    value_type sum = 0;

    for (int i = 0; i < 8; ++i) {
        auto foo = foos[i];

        sum += foo.c;
        sum += foo.b;
        sum += foo.a;
    }

    return sum;
}

int main() {
    FOO foos[8];
    foos[0].b = 5;

    std::cout << sum_8_foos(foos) << '\n';
    return 0;
}
```
With -O1, we get 5.
With -O2, we get 10.

godbolt link: https://godbolt.org/z/7cxeb3Gsv

Slightly reorganising the assembly output for the loop,
```
.L2
        add     rdi, 48

        addsd   sum, QWORD PTR [rdi-48] // c
        addsd   sum, QWORD PTR [rdi-40] // b
        addsd   sum, QWORD PTR [rdi-32] // a

        addsd   sum, QWORD PTR [rdi-24] // c
        addsd   sum, QWORD PTR [rdi-16] // b
        addsd   sum, QWORD PTR [rdi-8]  // a

        add     rax, 24

        addsd   sum, QWORD PTR [rax-16] // b
        addsd   sum, QWORD PTR [rax-24] // c

        cmp     rdi, end
        jne     .L2
```

There appears to be duplicate additions for the members b and c.

This behaviour appears on gcc 12.1 and is still present in gcc 13.1.