(New)GVN doesn't look through non-constant memcpy

[Keno]

Bugzilla Link	32570
Version	trunk
OS	All
CC	@hfinkel

Extended Description

E.g. in this example, GVN can't turn this into load a[100]:

declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i32, i1)

define double @trivial_memcpy(<200 x double> *%a) {
    %b = alloca <200 x double>
    %acast = bitcast <200 x double> *%a to i8*
    %bcast = bitcast <200 x double> *%b to i8*
    call void @llvm.memcpy.p0i8.p0i8.i64(i8* %bcast, i8* %acast, i64 1600, i32 8, i1 0)
    %innerptr = getelementptr <200 x double>, <200 x double> *%a, i32 0, i32 100
    %inner = load double, double *%innerptr
    ret double %inner
}

Now for this particular example, SROA does do this optimization, but this feels like something that GVN should be able to do as well.

[Keno]

Sorry, that getelementptr should have been from %b of course.

[llvmbot]

" // See if we are defined by a previous store expression, it already has a
// value, and it's the same value as our current store. FIXME: Right now, we
// only do this for simple stores, we should expand to cover memcpys, etc.
"

;)

If we did that, it would turn your example into return undef.

Well, almost.
We don't consider alloca to be a memdef in memoryssa.
We probably should.

[llvmbot]

+hal for thoughts about whether alloca should be considered a memdef.
(in memoryssa)
For example, otherwise, the example is:

define double @​trivial_memcpy(<200 x double>* %a) {
%b = alloca <200 x double>
%acast = bitcast <200 x double>* %a to i8*
%bcast = bitcast <200 x double>* %b to i8*
; 1 = MemoryDef(liveOnEntry)
call void @​llvm.memcpy.p0i8.p0i8.i64(i8* %bcast, i8* %acast, i64 1600, i32 8, i1 false)
%innerptr = getelementptr <200 x double>, <200 x double>* %a, i32 0, i32 100
; MemoryUse(liveOnEntry)
%inner = load double, double* %innerptr
ret double %inner
}

There is nothing for us to walk back to past the memcpy.

Obviously, this is the only case this occurs in.
If you have any load or store in the way, we would know the value.

I'm curious whether it's worth making alloca a memdef just to handle this case of marking something undef ;)

Otherwise, we will never get this example, but we would get the example where you store some value to a, and then memcpy it.

[Keno]

Just wanted to make sure you saw my comment clarifying that I typo'd in the original example and that gelementptr was meant to be from %b, so the optimization I want is essentially changing the %b in the getelementptr to %a, which is legal as long as %a is not clobbered.

[llvmbot]

Yup, i saw that.

What will end up if we do what i suggested is that is we will determine the load is equivalent to

1. any earlier load of %a
2. the stored value of any earlier complete store of %a
3. undef if we hit an alloca

It will not, however, just replace the value in the getelementptr.
Because it can't prove the pointers themselves are the same.
It can only prove the memory stored into them has the same value.
So it will replace things that read that memory with the appropriate values.