Store to potentially aliasing pointer causes LLVM to forget previously stored value

[Kmeakin]

The second load of x is redundant because, even if y aliases with x, the final value will still be z

https://godbolt.org/z/GKdPrPj6T

int src(int* x, int* y, int z) {
    *x = z;
    *y = z;
    return *x;
}

int tgt(int* x, int* y, int z) {
    *x = z;
    *y = z;
    return z;
}

src:
        str     w2, [x0]
        str     w2, [x1]
        ldr     w0, [x0]
        ret

tgt:
        str     w2, [x0]
        mov     w0, w2
        str     w2, [x1]
        ret

[pinskia]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=23094 was the GCC's bug report.

[nikic]

We have a related transform in

llvm-project/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

Lines 331 to 362 in 8d9911e

	// Check if SI that may alias with MemLoc can be safely skipped. This is
	// possible in case if SI can only must alias or no alias with MemLoc (no
	// partial overlapping possible) and it writes the same value that MemLoc
	// contains now (it was loaded before this store and was not modified in
	// between).
	static bool canSkipClobberingStore(const StoreInst *SI,
	const MemoryLocation &MemLoc,
	Align MemLocAlign, BatchAAResults &BatchAA,
	unsigned ScanLimit) {
	if (!MemLoc.Size.hasValue())
	return false;
	if (MemoryLocation::get(SI).Size != MemLoc.Size)
	return false;
	if (MemLoc.Size.isScalable())
	return false;
	if (std::min(MemLocAlign, SI->getAlign()).value() <
	MemLoc.Size.getValue().getKnownMinValue())
	return false;
	auto *LI = dyn_cast<LoadInst>(SI->getValueOperand());
	if (!LI || LI->getParent() != SI->getParent())
	return false;
	if (BatchAA.alias(MemoryLocation::get(LI), MemLoc) != AliasResult::MustAlias)
	return false;
	unsigned NumVisitedInsts = 0;
	for (const Instruction *I = LI; I != SI; I = I->getNextNonDebugInstruction())
	if (++NumVisitedInsts > ScanLimit ||
	isModSet(BatchAA.getModRefInfo(I, MemLoc)))
	return false;
	return true;
	}

It doesn't handle this store-store case currently.