[CaptureTracking] Consider ephemeral calls accessing memory as capturing.

[fhahn]

Summary

Consider ephemeral calls reading or writing memory as capturing to avoid
memory optimizations that introduce new UB after inlining such calls.

This fixes a mis-compile (see
llvm/test/Transforms/PhaseOrdering/dse-ephemeral-value-captures.ll). The
issue is roughly:

1. There's a call to a readonly function that takes a pointer argument and its result is only used by an assume, so the call is considered ephemeral and not capturing.
2. Because the call doesn't capture the pointer, it's considered to not read the pointer, causing DSE to remove the store before the call.
3. Now the called function gets inlined and there's now a load from the pointer, but the initializing store has been removed
4. This leads to SROA replacing the load with undef, which will cause the function to get folded to unreachable by subsequent optimizations.

Alternative to D153464

[nikic]

I believe that after D153511 this should not be necessary anymore.

llvm/lib/Analysis/CaptureTracking.cpp

void tooManyUses() override {
       LLVM_DEBUG(dbgs() << "Captured due to too many uses\n");
       Captured = true;
     }
 
     bool captured(const Use *U) override {
       if (isa<ReturnInst>(U->getUser()) && !ReturnCaptures)
         return false;
 
-      if (EphValues.contains(U->getUser()))
+      // Consider ephemeral calls reading or writing memory as capturing to avoid memory optimizations that may result in UB after inlining such calls.
+      if (EphValues.contains(U->getUser()) &&
+          !cast<Instruction>(U->getUser())->mayReadOrWriteMemory())
         return false;
 
       LLVM_DEBUG(dbgs() << "Captured by: " << *U->getUser() << "\n");
 
       Captured = true;
       return true;
     }
 
void tooManyUses() override {
       EarliestCapture = &*F.getEntryBlock().begin();
     }
 
     bool captured(const Use *U) override {
       Instruction *I = cast<Instruction>(U->getUser());
       if (isa<ReturnInst>(I) && !ReturnCaptures)
         return false;
 
-      if (EphValues.contains(I))
+      // Consider ephemeral calls reading or writing memory as capturing to avoid memory optimizations that may result in UB after inlining such calls.
+      if (EphValues.contains(I) && !I->mayReadOrWriteMemory())
         return false;
 
       if (!EarliestCapture)
         EarliestCapture = I;
       else
         EarliestCapture = DT.findNearestCommonDominator(EarliestCapture, I);
       Captured = true;
 

llvm/test/Transforms/PhaseOrdering/dse-ephemeral-value-captures.ll

 else:
   ret i1 0
 }
 
 ; FIXME: At the moment, the function is incorrectly simplified to unreachable.
 define i32 @test() {
 ; CHECK-LABEL: define i32 @test() {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    unreachable
+; CHECK-NEXT:    br label [[THEN_I:%.*]]
+; CHECK:       then.i:
+; CHECK-NEXT:    [[RES_I:%.*]] = call i1 @cond()
+; CHECK-NEXT:    br label [[CHECK_COND_EXIT:%.*]]
+; CHECK:       check_cond.exit:
+; CHECK-NEXT:    call void @llvm.assume(i1 [[RES_I]])
+; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %a = alloca i32, align 4
   call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %a)
   store i32 1, ptr %a, align 4
   %res = call i1 @check_cond(ptr %a)
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %a)
   call void @llvm.assume(i1 %res)
   ret i32 0
 }
 
 attributes #0 = { nounwind readonly willreturn }