Missed Optimization: Store of Known Zero Not Folded in Conditional Path

[GINN-Imp]

The following reduced IR is derived from https://eigen.tuxfamily.org/dox/Ref_8h_source.html.
More specifically, it comes from function EIGEN_DEVICE_FUNC bool construct(Expression& expr) (line 111).

Godbolt: https://godbolt.org/z/436xvYdsv
Missed optimization: store i8 %2, ptr @v, align 1 --> store i8 0, ptr @v, align 1
alive2 proof: https://alive2.llvm.org/ce/z/kjuHWQ

@_ZN5EigenL14no_more_assertE = internal global i8 0, align 1
@v = external global i8

define void @src(i1 %0) {
  %2 = zext i1 %0 to i8
  br i1 %0, label %common.ret, label %3

3:                                                ; preds = %1
  %.b2 = load i1, ptr @_ZN5EigenL14no_more_assertE, align 1
  br i1 %.b2, label %common.ret, label %4

4:                                                ; preds = %3
  store i1 true, ptr @_ZN5EigenL14no_more_assertE, align 1
  store i8 %2, ptr @v, align 1
  br label %common.ret

common.ret:                                       ; preds = %1, %3, %4
  ret void
}

opt-trunk -O3 generates:

define void @src(i1 %0) local_unnamed_addr #0 {
  %2 = zext i1 %0 to i8
  br i1 %0, label %common.ret, label %3

3:                                                ; preds = %1
  %.b2 = load i1, ptr @_ZN5EigenL14no_more_assertE, align 1
  br i1 %.b2, label %common.ret, label %4

4:                                                ; preds = %3
  store i1 true, ptr @_ZN5EigenL14no_more_assertE, align 1
  store i8 %2, ptr @v, align 1
  br label %common.ret

common.ret:                                       ; preds = %4, %3, %1
  ret void
}

[dtcxzyw]

%2 = zext i1 %0 to i8 should be sunk into bb %4. Then instcombine will handle this case: https://godbolt.org/z/K3M7od3P1

[nikic]

I think this doesn't get sunk due to this check:

llvm-project/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

Lines 5276 to 5285 in f0a59c4

	// See if the user is one of our successors that has only one
	// predecessor, so that we don't have to split the critical edge.
	// Another option where we can sink is a block that ends with a
	// terminator that does not pass control to other block (such as
	// return or unreachable or resume). In this case:
	// - I dominates the User (by SSA form);
	// - the User will be executed at most once.
	// So sinking I down to User is always profitable or neutral.
	if (UserParent->getUniquePredecessor() != BB && !succ_empty(Term))
	return std::nullopt;

We only allow sinking in simple cases to make sure we don't sink into a cycle. We could query LoopInfo, though it would be a shame to reintroduce this dependency...