[DSE] Use cached escape info for calls.

[fhahn]

Summary

This patch uses the caching added in D109844 to analyze calls. It adds a
variant of callCapturesBefore which should only be called if the object
does not escape before the call. I am happy to adjust the naming and
structure of the changes in CaptureTracking and I'll add a doc-comment
once everything is settled.

Fixes PR50220.

[asbirlea]

Please document in detail that callCapturesBefore should only be called if the object does not escape before the call. Even if the public API is not available with this patch, it can be added in the future due to oversight if a comment does not explain this choice.

llvm/lib/Analysis/AliasAnalysis.cpp

741

Define the API only for a CallBase; simplify checks below.

[fhahn]

In D109907#3005187, @asbirlea wrote:

Please document in detail that callCapturesBefore should only be called if the object does not escape before the call. Even if the public API is not available with this patch, it can be added in the future due to oversight if a comment does not explain this choice.

I added a comment to callCaptures, removed callKnownNoCapture and exposed callCaptures as public function instead. I also removed the redundant DT argument.

[fhahn]

llvm/lib/Analysis/AliasAnalysis.cpp

741

I simplified the API here by just exposing callCaptures which only takes a CallBase and an object.

[nikic]

llvm/include/llvm/Analysis/AliasAnalysis.h

812

I'm really confused by this API. My understanding is that it computes the ModRefInfo of the call under the assumption that the object is not captured before *or at* the call. The implementation skips over non-nocapture arguments on the premise that these must have already been checked. It only checks whether there are arguments that may mod/ref the object without capturing. With that in mind, the API name seems to be the opposite of what it actually does.

[fhahn]

Adjust naming callCaptures to callNoCapturesBefore.

[fhahn]

llvm/include/llvm/Analysis/AliasAnalysis.h

812

I changed it to callNoCapturesBefore, which should be more in line with callCapturesBefore which runs the capture-before checks. The naming is still not that great, I'd appreciate any suggestions.

[nikic]

llvm/include/llvm/Analysis/AliasAnalysis.h

812

It's a mouthful, but maybe getModRefInfoAssumingNoCapture()?

I think it would be good to adjust the comment here to say "does not escape before or at the call".

llvm/lib/Analysis/AliasAnalysis.cpp

748

Just as a side-note, as this is a preexisting issue in this code: This only checks that Object itself is called, but not whether something that aliases Object is called.

Probably doesn't matter much in practice as calling a local object seems like a really weird thing to do.

[fhahn]

Updated to use getModRefInfoAssumingNoCapture.

[nikic]

This one should no longer be necessary?

[fhahn]

In D109907#3025787, @nikic wrote:

This one should no longer be necessary?

Yep, I also closed PR50220

llvm/include/llvm/Analysis/AliasAnalysis.h

public:
   }
 
   /// A convenience wrapper to synthesize a memory location.
   ModRefInfo callCapturesBefore(const Instruction *I, const Value *P,
                                 LocationSize Size, DominatorTree *DT) {
     return callCapturesBefore(I, MemoryLocation(P, Size), DT);
   }
 
+  /// Return information about whether a particular call site modifies or reads
+  /// the specified memory object \p Object. The caller must ensure the object
+  /// is not captured before the call.
+  ModRefInfo getModRefInfoAssumingNoCapture(const CallBase *Call,
+                                            const Value *Object) {
+    AAQueryInfo AAQIP;
+    return getModRefInfoAssumingNoCapture(Call, Object, AAQIP);
+  }
+
   /// @}
   //===--------------------------------------------------------------------===//
   /// \name Higher level methods for querying mod/ref information.
   /// @{
 
   /// Check if it is possible for execution of the specified basic block to
   /// modify the location Loc.
   bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc);
private:
   ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc,
                            AAQueryInfo &AAQI);
   ModRefInfo getModRefInfo(const Instruction *I,
                            const Optional<MemoryLocation> &OptLoc,
                            AAQueryInfo &AAQIP);
   ModRefInfo callCapturesBefore(const Instruction *I,
                                 const MemoryLocation &MemLoc, DominatorTree *DT,
                                 AAQueryInfo &AAQIP);
+  /// Return information about whether a particular call site modifies or reads
+  /// the specified memory object \p Object. The caller must ensure the object
+  /// is not captured before the call.
+  ModRefInfo getModRefInfoAssumingNoCapture(const CallBase *Call,
+                                            const Value *Object,
+                                            AAQueryInfo &AAQIP);
 
   class Concept;
 
   template <typename T> class Model;
 
   template <typename T> friend class AAResultBase;
 
   const TargetLibraryInfo &TLI;

llvm/lib/Analysis/AliasAnalysis.cpp

ModRefInfo AAResults::callCapturesBefore(const Instruction *I,
   if (!Call || Call == Object)
     return ModRefInfo::ModRef;
 
   if (PointerMayBeCapturedBefore(Object, /* ReturnCaptures */ true,
                                  /* StoreCaptures */ true, I, DT,
                                  /* include Object */ true))
     return ModRefInfo::ModRef;
 
+  return getModRefInfoAssumingNoCapture(Call, Object, AAQI);
+}
+
+ModRefInfo AAResults::getModRefInfoAssumingNoCapture(const CallBase *Call,
+                                                     const Value *Object,
+                                                     AAQueryInfo &AAQI) {
+  assert(isIdentifiedFunctionLocal(Object) &&
+         "Must be called with local objects only!");
+
+  if (Call == Object)
+    return ModRefInfo::ModRef;
+
   unsigned ArgNo = 0;
   ModRefInfo R = ModRefInfo::NoModRef;
   bool IsMustAlias = true;
   // Set flag only if no May found and all operands processed.
   for (auto CI = Call->data_operands_begin(), CE = Call->data_operands_end();
        CI != CE; ++CI, ++ArgNo) {
     // Only look at the no-capture or byval pointer arguments.  If this
     // pointer were passed to arguments that were neither of these, then it

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

if (auto *LI = dyn_cast<LoadInst>(UseInst)) {
           notCapturedBeforeOrAt(DefUO, UseInst)) {
         assert(
             !PointerMayBeCapturedBefore(DefLoc.Ptr, false, true, UseInst, &DT,
                                         false, 0, &this->LI) &&
             "cached analysis disagrees with fresh PointerMayBeCapturedBefore");
         return false;
       }
     }
+    ModRefInfo MR = BatchAA.getModRefInfo(UseInst, DefLoc);
+    // If necessary, perform additional analysis.
+    if (isRefSet(MR)) {
+      if (auto *CB = dyn_cast<CallBase>(UseInst)) {
+        auto *DefUO = getUnderlyingObject(DefLoc.Ptr);
+        if (DefUO && notCapturedBeforeOrAt(DefUO, UseInst)) {
+          assert(!PointerMayBeCapturedBefore(DefLoc.Ptr, false, true, UseInst,
+                                             &DT, false, 0, &this->LI) &&
+                 "cached analysis disagrees with fresh "
+                 "PointerMayBeCapturedBefore");
+          MR = AA.getModRefInfoAssumingNoCapture(CB, DefUO);
+        }
+      }
+    }
 
-    // NOTE: For calls, the number of stores removed could be slightly improved
-    // by using AA.callCapturesBefore(UseInst, DefLoc, &DT), but that showed to
-    // be expensive compared to the benefits in practice. For now, avoid more
-    // expensive analysis to limit compile-time.
-    return isRefSet(BatchAA.getModRefInfo(UseInst, DefLoc));
+    return isRefSet(MR);
   }
 
   /// Returns true if a dependency between \p Current and \p KillingDef is
   /// guaranteed to be loop invariant for the loops that they are in. Either
   /// because they are known to be in the same block, in the same loop level or
   /// by guaranteeing that \p CurrentLoc only references a single MemoryLocation
   /// during execution of the containing function.
   bool isGuaranteedLoopIndependent(const Instruction *Current,

llvm/test/Transforms/DeadStoreElimination/captures-before-call.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes='dse' -S %s | FileCheck %s
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Test case from PR50220.
 define i32 @other_value_escapes_before_call() {
 ; CHECK-LABEL: @other_value_escapes_before_call(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[V1:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[V2:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 0, i32* [[V1]], align 4
 ; CHECK-NEXT:    call void @escape(i32* nonnull [[V1]])
-; CHECK-NEXT:    store i32 55555, i32* [[V2]], align 4
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 [[CALL]], i32* [[V2]], align 4
 ; CHECK-NEXT:    call void @escape(i32* nonnull [[V2]])
 ; CHECK-NEXT:    [[LOAD_V2:%.*]] = load i32, i32* [[V2]], align 4
 ; CHECK-NEXT:    [[LOAD_V1:%.*]] = load i32, i32* [[V1]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[LOAD_V2]], [[LOAD_V1]]
 ; CHECK-NEXT:    ret i32 [[ADD]]
 ;

 
 declare void @escape_and_clobber(i32*)
 declare void @escape_writeonly(i32*) writeonly
 declare void @clobber()
 
 define i32 @test_not_captured_before_call_same_bb() {
 ; CHECK-LABEL: @test_not_captured_before_call_same_bb(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %a = alloca i32, align 4
   store i32 55, i32* %a
   %r = call i32 @getval()
   store i32 99, i32* %a, align 4
   call void @escape_and_clobber(i32* %a)
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_call_same_bb_escape_unreachable_block() {
 ; CHECK-LABEL: @test_not_captured_before_call_same_bb_escape_unreachable_block(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ; CHECK:       unreach:
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 0
 ;
;
   store i32 99, i32* %a, align 4
   call void @clobber()
   ret i32 %r
 }
 
 define i32 @test_captured_after_call_same_bb_2_clobbered_later() {
 ; CHECK-LABEL: @test_captured_after_call_same_bb_2_clobbered_later(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %a = alloca i32, align 4
   store i32 55, i32* %a
   %r = call i32 @getval()
   call void @escape_writeonly(i32* %a)
   store i32 99, i32* %a, align 4
   call void @clobber()
   ret i32 %r
 }
 
 define i32 @test_captured_sibling_path_to_call_other_blocks_1(i1 %c.1) {
 ; CHECK-LABEL: @test_captured_sibling_path_to_call_other_blocks_1(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
exit:
   call void @escape_writeonly(i32* %a)
   call void @clobber()
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_call_other_blocks_1(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_1(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:

 exit:
   call void @escape_and_clobber(i32* %a)
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_call_other_blocks_2(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_2(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])

 
 exit:
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_call_other_blocks_3(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_3(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    br label [[EXIT]]

 
 exit:
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_call_other_blocks_4(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_4(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[ELSE:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       else:
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
exit:
   call void @clobber()
   ret i32 %p
 }
 
 define i32 @test_not_captured_before_call_other_blocks_5(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[EXIT:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ [[R]], [[THEN]] ], [ 0, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
exit:
   call void @clobber()
   ret i32 %p
 }
 
 define i32 @test_not_captured_before_call_other_blocks_7(i1 %c.1) {
 ; CHECK-LABEL: @test_not_captured_before_call_other_blocks_7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[THEN:%.*]], label [[EXIT:%.*]]
 ; CHECK:       then:
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ 0, [[THEN]] ], [ [[R]], [[ENTRY:%.*]] ]
;
   call void @escape_and_clobber(i32* %a)
   %res = add i32 %r, %lv
   ret i32 %res
 }
 
 define i32 @test_captured_after_loop(i1 %c.1) {
 ; CHECK-LABEL: @test_captured_after_loop(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    br i1 [[C_1:%.*]], label [[LOOP]], label [[EXIT:%.*]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[R]]

 }
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)
 define void @test_escaping_store_removed(i8* %src, i64** %escape) {
 ; CHECK-LABEL: @test_escaping_store_removed(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i64, align 8
 ; CHECK-NEXT:    [[EXT_A:%.*]] = bitcast i64* [[A]] to i8*
-; CHECK-NEXT:    store i64 0, i64* [[A]], align 8
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[EXT_A]], i8* [[SRC:%.*]], i64 8, i1 false)
 ; CHECK-NEXT:    store i64* [[A]], i64** [[ESCAPE:%.*]], align 8
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    store i64 99, i64* [[A]], align 8
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    ret void
 ;
bb:
   ret void
 }
 
 
 define void @test_invoke_captures() personality i8* undef {
 ; CHECK-LABEL: @test_invoke_captures(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    invoke void @clobber()
 ; CHECK-NEXT:    to label [[BB2:%.*]] unwind label [[BB5:%.*]]
 ; CHECK:       bb2:
 ; CHECK-NEXT:    store i32 0, i32* [[A]], align 8
 ; CHECK-NEXT:    invoke void @escape(i32* [[A]])
 ; CHECK-NEXT:    to label [[BB9:%.*]] unwind label [[BB10:%.*]]
 ; CHECK:       bb4:
 ; CHECK-NEXT:    ret void

 }
 
 declare noalias i32* @alloc() nounwind
 declare i32 @getval_nounwind() nounwind
 
 define i32 @test_not_captured_before_load_same_bb_noalias_call() {
 ; CHECK-LABEL: @test_not_captured_before_load_same_bb_noalias_call(
 ; CHECK-NEXT:    [[A:%.*]] = call i32* @alloc()
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval_nounwind()
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   %a = call i32* @alloc()
   store i32 55, i32* %a
   %r = call i32 @getval_nounwind()
   store i32 99, i32* %a, align 4
   call void @escape_and_clobber(i32* %a)
   ret i32 %r
 }
 
 define i32 @test_not_captured_before_load_same_bb_noalias_arg(i32* noalias %a) {
 ; CHECK-LABEL: @test_not_captured_before_load_same_bb_noalias_arg(
-; CHECK-NEXT:    store i32 55, i32* [[A:%.*]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = call i32 @getval_nounwind()
-; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
+; CHECK-NEXT:    store i32 99, i32* [[A:%.*]], align 4
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ;
   store i32 55, i32* %a
   %r = call i32 @getval_nounwind()
   store i32 99, i32* %a, align 4
   call void @escape_and_clobber(i32* %a)
   ret i32 %r
 }

llvm/test/Transforms/DeadStoreElimination/captures-before-load.ll

;
   store i32 99, i32* %a, align 4
   call void @clobber()
   ret i32 %in.lv.2
 }
 
 define i32 @test_not_captured_before_load_same_bb_clobber(i32** %in.ptr) {
 ; CHECK-LABEL: @test_not_captured_before_load_same_bb_clobber(
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    store i32 55, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    [[IN_LV_1:%.*]] = load i32*, i32** [[IN_PTR:%.*]], align 2
 ; CHECK-NEXT:    [[IN_LV_2:%.*]] = load i32, i32* [[IN_LV_1]], align 2
 ; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @escape_and_clobber(i32* [[A]])
 ; CHECK-NEXT:    ret i32 [[IN_LV_2]]
 ;
   %a = alloca i32, align 4

 ; CHECK:       then:
 ; CHECK-NEXT:    call void @escape_writeonly(i32* [[A]])
 ; CHECK-NEXT:    ret i32 0
 ; CHECK:       else:
 ; CHECK-NEXT:    [[IN_LV_1:%.*]] = load i32*, i32** [[IN_PTR:%.*]], align 2
 ; CHECK-NEXT:    [[IN_LV_2:%.*]] = load i32, i32* [[IN_LV_1]], align 2
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       exit:
-; CHECK-NEXT:    store i32 99, i32* [[A]], align 4
 ; CHECK-NEXT:    call void @clobber()
 ; CHECK-NEXT:    ret i32 [[IN_LV_2]]
 ;
   %a = alloca i32, align 4
   store i32 55, i32* %a
   br i1 %c.1, label %then, label %else
 
 then: