[move-function] Add initial debug info support to move checker passes.

Specifically in this commit we:

1. Add support to the move checkers for marking alloc_stack that are moved or
the debug_value of values that are moved with the [moved] flag. In a subsequent
PR, I am going to add support in IRGen for emitting llvm.dbg.addr instead of
llvm.dbg.declare for such variables. This will ensure that debug info for values
that aren't moved get the same codegen.

2. I changed the move checkers to begin emitting debug_value undef at the move
site. This ensures that after that point the moved value will be unavailable in
the debugger.

3. I also found a small bug that was around terminators that was exposed by some
of my tests.

What is not in this patch:

1. IRGen part of this patch.
2. DebugInfoCanonicalization that pushes debug_info into coroutine func lets to
avoid issues with Swift's coroutine splitting at the LLVM level.

rdar://85020571

Author: gottesmm

include/swift/SIL/DebugUtils.h

@@ -325,34 +325,61 @@ struct DebugVarCarryingInst {
       llvm_unreachable("Not implemented");
     }
   }
-};
 
-/// Attempt to discover a StringRef varName for the value \p value. If we fail,
-/// we return the name "unknown".
-inline StringRef getDebugVarName(SILValue value) {
-  if (auto *asi = dyn_cast<AllocStackInst>(value)) {
-    DebugVarCarryingInst debugVar(asi);
-    if (auto varInfo = debugVar.getVarInfo()) {
-      return varInfo->Name;
-    } else {
-      if (auto *decl = debugVar.getDecl()) {
-        return decl->getBaseName().userFacingName();
-      }
+  void markAsMoved() {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      cast<DebugValueInst>(inst)->markAsMoved();
+      break;
+    case Kind::AllocStack:
+      cast<AllocStackInst>(inst)->markAsMoved();
+      break;
+    case Kind::AllocBox:
+      llvm_unreachable("Not implemented");
     }
   }
 
-  StringRef varName = "unknown";
-  if (auto *use = getSingleDebugUse(value)) {
-    DebugVarCarryingInst debugVar(use->getUser());
-    if (auto varInfo = debugVar.getVarInfo()) {
+  /// If \p value is an alloc_stack, alloc_box use that. Otherwise, see if \p
+  /// value has a single debug user, return that. Otherwise return the invalid
+  /// DebugVarCarryingInst.
+  static DebugVarCarryingInst getFromValue(SILValue value);
+
+  /// Take in \p inst, a potentially invalid DebugVarCarryingInst, and returns a
+  /// name for it. If we have an invalid value or don't find var info or a decl,
+  /// return "unknown".
+  ///
+  /// The reason this isn't a method is that in all the other parts of
+  /// DebugVarCarryingInst, we use Invalid to signal early error.
+  static StringRef getName(DebugVarCarryingInst inst) {
+    if (!inst)
+      return "unknown";
+    StringRef varName = "unknown";
+    if (auto varInfo = inst.getVarInfo()) {
       varName = varInfo->Name;
-    } else {
-      if (auto *decl = debugVar.getDecl()) {
-        varName = decl->getBaseName().userFacingName();
-      }
+    } else if (auto *decl = inst.getDecl()) {
+      varName = decl->getBaseName().userFacingName();
     }
+    return varName;
   }
-  return varName;
+};
+
+inline DebugVarCarryingInst DebugVarCarryingInst::getFromValue(SILValue value) {
+  if (isa<AllocStackInst>(value) || isa<AllocBoxInst>(value))
+    return DebugVarCarryingInst(cast<SingleValueInstruction>(value));
+
+  if (auto *use = getSingleDebugUse(value))
+    return DebugVarCarryingInst(use->getUser());
+
+  return DebugVarCarryingInst();
+}
+
+/// Attempt to discover a StringRef varName for the value \p value. If we fail,
+/// we return the name "unknown".
+inline StringRef getDebugVarName(SILValue value) {
+  auto inst = DebugVarCarryingInst::getFromValue(value);
+  return DebugVarCarryingInst::getName(inst);
 }
 
 } // end namespace swift

lib/SILOptimizer/Mandatory/MoveKillsCopyableAddressesChecker.cpp

@@ -1494,8 +1494,13 @@ bool DataflowState::cleanupAllDestroyAddr(
                                  "we processed takes of the given move.\n");
       // Insert a destroy_addr here since the block isn't reachable from any of
       // our moves.
-      SILBuilderWithScope builder(
-          std::prev(next->getTerminator()->getIterator()));
+      SILBasicBlock::iterator iter;
+      if (!isa<TermInst>(next->front())) {
+        iter = std::prev(next->getTerminator()->getIterator());
+      } else {
+        iter = next->begin();
+      }
+      SILBuilderWithScope builder(iter);
       auto *dvi = builder.createDestroyAddr(
           RegularLocation::getAutoGeneratedLocation(), address);
       useState.destroys.insert(dvi);
@@ -1755,12 +1760,26 @@ bool DataflowState::process(
     } else {
       builder.createCopyAddr(mvi->getLoc(), mvi->getSrc(), mvi->getDest(),
                              IsTake, IsInitialization);
+
+      // Now that we have processed all of our mark_moves, eliminate all of the
+      // destroy_addr and set our debug value as being moved.
+      if (auto debug = DebugVarCarryingInst::getFromValue(address)) {
+        debug.markAsMoved();
+        if (auto varInfo = debug.getVarInfo()) {
+          builder.createDebugValue(
+              mvi->getLoc(),
+              SILUndef::get(address->getType(), builder.getModule()), *varInfo,
+              false /*poison*/, true /*was moved*/);
+        }
+      }
+
       // Flush our SetVector into the visitedByNewMove.
       for (auto *block : visitedBlocks) {
         blocksVisitedWhenProcessingNewTakes.insert(block);
       }
       convertedMarkMoveToTake = true;
     }
+
     mvi->eraseFromParent();
     madeChange = true;
   }
@@ -1890,6 +1909,18 @@ static bool performSingleBasicBlockAnalysis(DataflowState &dataflowState,
     SILBuilderWithScope builder(mvi);
     builder.createCopyAddr(mvi->getLoc(), mvi->getSrc(), mvi->getDest(), IsTake,
                            IsInitialization);
+    // Also, mark the alloc_stack as being moved at some point.
+    if (auto debug = DebugVarCarryingInst::getFromValue(address)) {
+      if (auto varInfo = debug.getVarInfo()) {
+        builder.createDebugValue(
+            mvi->getLoc(),
+            SILUndef::get(address->getType(), builder.getModule()), *varInfo,
+            false,
+            /*was moved*/ true);
+      }
+      debug.markAsMoved();
+    }
+
     useState.destroys.erase(dvi);
     mvi->eraseFromParent();
     dvi->eraseFromParent();
@@ -1981,11 +2012,22 @@ static bool performSingleBasicBlockAnalysis(DataflowState &dataflowState,
     assert(!interestingUse);
     assert(interestingUser);
 
+    // If we have a reinit, then we have a successful move.
     convertMemoryReinitToInitForm(interestingUser);
     useState.reinits.erase(interestingUser);
     SILBuilderWithScope builder(mvi);
     builder.createCopyAddr(mvi->getLoc(), mvi->getSrc(), mvi->getDest(), IsTake,
                            IsInitialization);
+    if (auto debug = DebugVarCarryingInst::getFromValue(address)) {
+      if (auto varInfo = debug.getVarInfo()) {
+        builder.createDebugValue(
+            mvi->getLoc(),
+            SILUndef::get(address->getType(), builder.getModule()), *varInfo,
+            false,
+            /*was moved*/ true);
+      }
+      debug.markAsMoved();
+    }
     mvi->eraseFromParent();
     return false;
   }
@@ -2015,6 +2057,16 @@ static bool performSingleBasicBlockAnalysis(DataflowState &dataflowState,
     LLVM_DEBUG(llvm::dbgs() << "Found apply site to clone: " << **fas);
     LLVM_DEBUG(llvm::dbgs() << "BitVector: ";
                dumpBitVector(llvm::dbgs(), bitVector); llvm::dbgs() << '\n');
+    if (auto debug = DebugVarCarryingInst::getFromValue(address)) {
+      if (auto varInfo = debug.getVarInfo()) {
+        builder.createDebugValue(
+            mvi->getLoc(),
+            SILUndef::get(address->getType(), builder.getModule()), *varInfo,
+            false,
+            /*was moved*/ true);
+      }
+      debug.markAsMoved();
+    }
     mvi->eraseFromParent();
     return false;
   }

lib/SILOptimizer/Mandatory/MoveKillsCopyableValuesChecker.cpp

@@ -20,6 +20,7 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILUndef.h"
@@ -355,16 +356,12 @@ bool MoveKillsCopyableValuesChecker::check() {
   LLVM_DEBUG(llvm::dbgs() << "Visiting Function: " << fn->getName() << "\n");
   auto valuesToProcess =
       llvm::makeArrayRef(valuesToCheck.begin(), valuesToCheck.end());
-
+  auto &mod = fn->getModule();
   while (!valuesToProcess.empty()) {
     auto lexicalValue = valuesToProcess.front();
     valuesToProcess = valuesToProcess.drop_front(1);
     LLVM_DEBUG(llvm::dbgs() << "Visiting: " << *lexicalValue);
 
-    // Before we do anything, see if we can find a name for our value. We do
-    // this early since we need this for all of our diagnostics below.
-    StringRef varName = getDebugVarName(lexicalValue);
-
     // Then compute liveness.
     SWIFT_DEFER { livenessInfo.clear(); };
     livenessInfo.initDef(lexicalValue);
@@ -377,6 +374,9 @@ bool MoveKillsCopyableValuesChecker::check() {
 
     // Then look at all of our found consuming uses. See if any of these are
     // _move that are within the boundary.
+    bool foundMove = false;
+    auto dbgVarInfo = DebugVarCarryingInst::getFromValue(lexicalValue);
+    StringRef varName = DebugVarCarryingInst::getName(dbgVarInfo);
     for (auto *use : livenessInfo.consumingUse) {
       if (auto *mvi = dyn_cast<MoveValueInst>(use->getUser())) {
         // Only emit diagnostics if our move value allows us to.
@@ -394,9 +394,26 @@ bool MoveKillsCopyableValuesChecker::check() {
           emitDiagnosticForMove(lexicalValue, varName, mvi);
         } else {
           LLVM_DEBUG(llvm::dbgs() << "    WithinBoundary: No!\n");
+          if (auto varInfo = dbgVarInfo.getVarInfo()) {
+            auto *next = mvi->getNextInstruction();
+            SILBuilderWithScope builder(next);
+            // Use an autogenerated location to ensure that if we are next to a
+            // terminator, we don't assert.
+            builder.createDebugValue(
+                RegularLocation::getAutoGeneratedLocation(),
+                SILUndef::get(mvi->getOperand()->getType(), mod), *varInfo,
+                false /*poison*/, true /*moved*/);
+          }
         }
+        foundMove = true;
       }
     }
+
+    // If we found a move, mark our debug var inst as having a moved value. This
+    // ensures we emit llvm.dbg.addr instead of llvm.dbg.declare in IRGen.
+    if (foundMove) {
+      dbgVarInfo.markAsMoved();
+    }
   }
 
   return false;

test/SILGen/moveonly_builtin.swift

@@ -31,6 +31,7 @@ class Klass {}
 // CHECK-SIL-NEXT: debug_value
 // CHECK-SIL-NEXT: strong_retain
 // CHECK-SIL-NEXT: move_value
+// CHECK-SIL-NEXT: debug_value [moved] undef
 // CHECK-SIL-NEXT: tuple
 // CHECK-SIL-NEXT: tuple
 // CHECK-SIL-NEXT: strong_release
@@ -64,6 +65,7 @@ func useMove(_ k: __owned Klass) -> Klass {
 // CHECK-SIL-NEXT: debug_value
 // CHECK-SIL-NEXT: strong_retain
 // CHECK-SIL-NEXT: move_value
+// CHECK-SIL-NEXT: debug_value [moved] undef
 // CHECK-SIL-NEXT: tuple
 // CHECK-SIL-NEXT: tuple
 // CHECK-SIL-NEXT: strong_release

test/SILOptimizer/move_function_kills_addresses_dbginfo.sil

@@ -0,0 +1,73 @@
+// RUN: %target-sil-opt %s -sil-move-kills-copyable-addresses-checker | %FileCheck %s
+
+// REQUIRES: optimized_stdlib
+
+sil_stage raw
+
+import Builtin
+
+// Make sure that when we process a move_addr on an alloc_stack/debug_value that
+// we properly put the [moved] marker on them.
+
+// CHECK-LABEL: sil [ossa] @singleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK:   [[SRC_ADDR:%.*]] = alloc_stack [lexical] [moved] $Builtin.NativeObject, let, name "[[VAR_NAME:.*]]"
+// CHECK:   [[DEST_ADDR:%.*]] = alloc_stack $Builtin.NativeObject
+// CHECK:   copy_addr [take] [[SRC_ADDR]] to [initialization] [[DEST_ADDR]]
+// CHECK-NEXT: debug_value [moved] undef
+// CHECK: } // end sil function 'singleBlock'
+sil [ossa] @singleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  %1 = alloc_stack [lexical] $Builtin.NativeObject, let, name "myName"
+  %2 = copy_value %0 : $Builtin.NativeObject
+  store %2 to [init] %1 : $*Builtin.NativeObject
+
+  %dest = alloc_stack $Builtin.NativeObject
+  mark_unresolved_move_addr %1 to %dest : $*Builtin.NativeObject
+
+  destroy_addr %dest : $*Builtin.NativeObject
+  dealloc_stack %dest : $*Builtin.NativeObject
+
+  destroy_addr %1 : $*Builtin.NativeObject
+  dealloc_stack %1 : $*Builtin.NativeObject
+
+  destroy_value %0 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @multipleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: bb0(
+// CHECK:   [[SRC_ADDR:%.*]] = alloc_stack [lexical] [moved] $Builtin.NativeObject, let, name "[[VAR_NAME:.*]]"
+// CHECK:   [[DEST_ADDR:%.*]] = alloc_stack $Builtin.NativeObject
+// CHECK:   cond_br undef, bb1, bb2
+//
+// CHECK: bb1:
+// CHECK:   copy_addr [take] [[SRC_ADDR]] to [initialization] [[DEST_ADDR]]
+// CHECK:   debug_value [moved] undef : $*Builtin.NativeObject, let, name "[[VAR_NAME]]"
+// CHECK:   br bb3
+//
+// CHECK: } // end sil function 'multipleBlock'
+sil [ossa] @multipleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  %1 = alloc_stack [lexical] $Builtin.NativeObject, let, name "myName"
+  %2 = copy_value %0 : $Builtin.NativeObject
+  store %2 to [init] %1 : $*Builtin.NativeObject
+  %dest = alloc_stack $Builtin.NativeObject
+  cond_br undef, bb1, bb2
+
+bb1:
+  mark_unresolved_move_addr %1 to %dest : $*Builtin.NativeObject
+  destroy_addr %dest : $*Builtin.NativeObject
+  br bb3
+
+bb2:
+  br bb3
+
+bb3:
+  dealloc_stack %dest : $*Builtin.NativeObject
+  destroy_addr %1 : $*Builtin.NativeObject
+  dealloc_stack %1 : $*Builtin.NativeObject
+  destroy_value %0 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}

test/SILOptimizer/move_function_kills_values_dbginfo.sil

@@ -0,0 +1,53 @@
+// RUN: %target-sil-opt %s -sil-move-kills-copyable-values-checker | %FileCheck %s
+
+// REQUIRES: optimized_stdlib
+
+sil_stage raw
+
+import Builtin
+
+// Make sure that when we process a move_addr on an alloc_stack/debug_value that
+// we properly put the [moved] marker on them.
+
+// CHECK-LABEL: sil [ossa] @singleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK: debug_value [moved] [[ARG]] : $Builtin.NativeObject, let, name "myName"
+// CHECK: [[MOVED_VAL:%.*]] = move_value [[ARG]]
+// CHECK: debug_value [moved] undef : $Builtin.NativeObject, let, name "myName"
+// CHECK: } // end sil function 'singleBlock'
+sil [ossa] @singleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  debug_value %0 : $Builtin.NativeObject, let, name "myName"
+  %1 = move_value [allows_diagnostics] %0 : $Builtin.NativeObject
+  destroy_value %1 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @multipleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK:   debug_value [moved] [[ARG]]
+// CHECK:   cond_br undef, bb1, bb2
+//
+// CHECK: bb1:
+// CHECK:   [[MV:%.*]] = move_value [[ARG]]
+// CHECK:   debug_value [moved] undef : $Builtin.NativeObject, let, name "myName"
+// CHECK: } // end sil function 'multipleBlock'
+sil [ossa] @multipleBlock : $@convention(thin) (@owned Builtin.NativeObject) -> () {
+bb0(%0 : @owned $Builtin.NativeObject):
+  debug_value %0 : $Builtin.NativeObject, let, name "myName"
+  cond_br undef, bb1, bb2
+
+bb1:
+  %1 = move_value [allows_diagnostics] %0 : $Builtin.NativeObject
+  destroy_value %1 : $Builtin.NativeObject
+  br bb3
+
+bb2:
+  destroy_value %0 : $Builtin.NativeObject
+  br bb3
+
+bb3:
+  %9999 = tuple()
+  return %9999 : $()
+}