Clang fails to get rid of a simple loop, and ends up generating horrible vector code

[LebedevRI]

Bugzilla Link	36893
Version	trunk
OS	Linux
CC	@efriedma-quic,@fhahn,@sparker-arm,@rotateright

Extended Description

I'm not sure i've picked the right category.

https://godbolt.org/g/GfPP1m

IMHO both sources do the same thing, so the resulting assembly should be the same.
The loop should have been optimized away.

[efriedma-quic]

For reference, copy-pasting the loop which doesn't get optimized away.

struct Slicing {
  int numSlices = 0;
  int sliceWidth = 0;
  int lastSliceWidth = 0;
  int widthOfSlice(int sliceId) const {
    if ((sliceId + 1) == numSlices)
      return lastSliceWidth;
    return sliceWidth;
  }
  int totalWidth() const {
    __builtin_assume(numSlices >= 0);
    int width = 0;
    for (auto sliceId = 0; sliceId < numSlices; sliceId++)
      width += widthOfSlice(sliceId);
    return width;
  }
};
int totalWidth(const Slicing& s) {
    return s.totalWidth();
}

[fhahn]

This may be a good motivating case for peeling off iterations at the back of the loop. That should be able to transform the loop into something like the code below, which will simplified to a condition & mul.

struct Slicing {
int numSlices = 0;
int sliceWidth = 0;
int lastSliceWidth = 0;
int totalWidth() const {
__builtin_assume(numSlices >= 0);
int width = 0;
auto sliceId = 0;
for (; sliceId < numSlices - 1; sliceId++) {
width += sliceWidth;
}
if (sliceId + 1 == numSlices)
width += lastSliceWidth;
return width;
}
};

I plan to fix this as a follow up to https://reviews.llvm.org/rL327671

I'll get to that once I had time to address a cost-modelling issue with peeling.

[LebedevRI]

This may be a good motivating case for peeling off iterations at the back of
the loop.
...
I plan to fix this as a follow up to https://reviews.llvm.org/rL327671

I'll get to that once I had time to address a cost-modelling issue with
peeling.

The peeling sounds very promising,
but if i change the code to move the case-that-should-be-peeled to the beginning,
it still does not help.

I.e.
int widthOfSlice(int sliceId) const {
if (sliceId == 0)
return lastSliceWidth;
return sliceWidth;
}
https://godbolt.org/g/MJWhhq

[nikic]

LLVM supports peeling the last iteration now, and the loop gets eliminated. The result is still not entirely optimal (in that there are separate codepaths for 0 & 1 element), but I think the core part of this issue is fixed.