[Mem2Reg] Recognize store_borrows for debug_value.

When `debug_value`s are visited, if their operand is the stack address,
they are rewritten as `debug_value`s of the stored value, provided it is
known.

Previously, the check for whether the operand is the stack address,
however, just compared the `debug_value`'s operand with the
`alloc_stack`.  For owned `alloc_stack`s (i.e. those that are not
"store_borrow locations"), that was correct.  For guaranteed
`alloc_stack`s (i.e. those that are "store_borrow locations"), however,
this failed to recognize the the values produced by the `store_borrow`
instructions (which amount to aliases for the `alloc_stack`) as the
stack address.

Here, this is fixed by checking whether the `debug_value`'s operand is
either (1) the `alloc_stack` itself or (2) some `store_borrow` whose
destination is the `alloc_stack`.

rdar://109894792

Author: nate-chandler

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -300,6 +300,23 @@ replaceDestroy(DestroyAddrInst *dai, SILValue newValue, SILBuilderContext &ctx,
   prepareForDeletion(dai, instructionsToDelete);
 }
 
+/// Whether the specified debug_value's operand names the address at the
+/// indicated alloc_stack.
+///
+/// If it's a guaranteed alloc_stack (i.e. a store_borrow location), that
+/// includes the values produced by any store_borrows whose destinations are the
+/// alloc_stack since those values amount to aliases for the alloc_stack's
+/// storage.
+static bool isDebugValueOfAllocStack(DebugValueInst *dvi, AllocStackInst *asi) {
+  auto value = dvi->getOperand();
+  if (value == asi)
+    return true;
+  auto *sbi = dyn_cast<StoreBorrowInst>(value);
+  if (!sbi)
+    return false;
+  return sbi->getDest() == asi;
+}
+
 /// Promote a DebugValue w/ address value to a DebugValue of non-address value.
 static void promoteDebugValueAddr(DebugValueInst *dvai, SILValue value,
                                   SILBuilderContext &ctx,
@@ -1191,7 +1208,7 @@ SILInstruction *StackAllocationPromoter::promoteAllocationInBlock(
     // if we have a valid value to use at this point. Otherwise we'll
     // promote this when we deal with hooking up phis.
     if (auto *dvi = DebugValueInst::hasAddrVal(inst)) {
-      if (dvi->getOperand() == asi && runningVals)
+      if (isDebugValueOfAllocStack(dvi, asi) && runningVals)
         promoteDebugValueAddr(dvi, runningVals->value.replacement(asi, dvi),
                               ctx, deleter);
       continue;
@@ -2034,7 +2051,7 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
     // Replace debug_value w/ address value with debug_value of
     // the promoted value.
     if (auto *dvi = DebugValueInst::hasAddrVal(inst)) {
-      if (dvi->getOperand() == asi) {
+      if (isDebugValueOfAllocStack(dvi, asi)) {
         if (runningVals) {
           promoteDebugValueAddr(dvi, runningVals->value.replacement(asi, dvi),
                                 ctx, deleter);

test/SILOptimizer/mem2reg_ossa.sil

@@ -40,6 +40,12 @@ struct LargeCodesizeStruct {
   var s5: SmallCodesizeStruct
 }
 
+class C {}
+
+struct S {
+  var field: C
+}
+
 ///////////
 // Tests //
 ///////////
@@ -657,3 +663,68 @@ bb16:
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: sil [ossa] @debug_value_of_store_borrow_addr_multi_block : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[INSTANCE]]
+// CHECK:         debug_value [[LIFETIME]]
+// CHECK-LABEL: } // end sil function 'debug_value_of_store_borrow_addr_multi_block'
+sil [ossa] @debug_value_of_store_borrow_addr_multi_block : $@convention(thin) (@owned S) -> () {
+entry(%instance : @owned $S):
+  br header
+
+header:
+  %lifetime = begin_borrow %instance : $S
+  %stack = alloc_stack $S
+  %stack_borrow = store_borrow %lifetime to %stack : $*S
+  debug_value %stack_borrow : $*S
+  br body
+
+body:
+  %field_addr = struct_element_addr %stack_borrow : $*S, #S.field
+  %field = load [copy] %field_addr : $*C
+  end_borrow %stack_borrow : $*S
+  dealloc_stack %stack : $*S
+  end_borrow %lifetime : $S
+  destroy_value %field : $C
+  cond_br undef, backedge, exit
+
+backedge:
+  br header
+
+exit:
+  destroy_value %instance : $S
+  %retval = tuple ()
+  return %retval : $()
+}
+
+// CHECK-LABEL: sil [ossa] @debug_value_of_store_borrow_addr_single_block : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] :
+// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[INSTANCE]]
+// CHECK:         debug_value [[LIFETIME]]
+// CHECK-LABEL: } // end sil function 'debug_value_of_store_borrow_addr_single_block'
+sil [ossa] @debug_value_of_store_borrow_addr_single_block : $@convention(thin) (@owned S) -> () {
+entry(%instance : @owned $S):
+  br header
+
+header:
+  %lifetime = begin_borrow %instance : $S
+  %stack = alloc_stack $S
+  %stack_borrow = store_borrow %lifetime to %stack : $*S
+  debug_value %stack_borrow : $*S
+  %field_addr = struct_element_addr %stack_borrow : $*S, #S.field
+  %field = load [copy] %field_addr : $*C
+  end_borrow %stack_borrow : $*S
+  dealloc_stack %stack : $*S
+  end_borrow %lifetime : $S
+  destroy_value %field : $C
+  cond_br undef, backedge, exit
+
+backedge:
+  br header
+
+exit:
+  destroy_value %instance : $S
+  %retval = tuple ()
+  return %retval : $()
+}