Clang vectorizes simple loop in O3 worse than GCC does in O2.

[denzor200]

Look at the sample:

void addition(std::array<int, 10000>& result,
              const std::array<int, 10000>& first,
              const std::array<int, 10000>& second)
{
    for (int i=0;i<10000;++i) {
        result[i] = first[i] + second[i];
    }
}

As we could see, the code can be effectively vectorised. Moreover it works with fixed count of elements(10000) which divides by 16 with no remainder, so thus the compiler don't have to create second loop to handle block of remainded elements with count of elements <16 - only simple vectorized loop would be enough.

The full snippet here: https://godbolt.org/z/fcedzGEYa
As we could see in the snippet, GCC doesn't create second loop to handle remainder, while Clang does.
Any reason why Clang does it? Is it possible to fix?

[topperc]

That's not a remainder loop. Based on the control flow, only one of the loops will ever execute. It looks like clang is making sure that result doesn't overlap with first or second. It's treating the argument as if they are pointers to arrays that could partially overlap. But they are std::array objects which are either distinct memory or completely overlap.

[denzor200]

That's not a remainder loop. Based on the control flow, only one of the loops will ever execute.

Ah, that's the truth. My apologies for inattention.

[fhahn]

This is something we would need to model in libc++ somehow, but I don't think we currently have any good way of doing so.