Merge pull request swiftlang#41959 from gottesmm/alloc_stack_propagation_and_hoist

[move-function] Add support for propagating from vars

Author: gottesmm

include/swift/SIL/DebugUtils.h

@@ -341,6 +341,39 @@ struct DebugVarCarryingInst {
     }
   }
 
+  /// Returns true if this DebugVarCarryingInst was moved.
+  bool getWasMoved() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getWasMoved();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst)->getWasMoved();
+    case Kind::AllocBox:
+      llvm_unreachable("Not implemented");
+    }
+  }
+
+  /// If we are attempting to create a "debug_value" clone of this debug var
+  /// carrying inst, return the appropriate SILValue to use as the operand of
+  /// that debug value.
+  ///
+  /// For a debug_value, we just return the actual operand, otherwise we return
+  /// the pointer address.
+  SILValue getOperandForDebugValueClone() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getOperand();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst);
+    case Kind::AllocBox:
+      llvm_unreachable("Not implemented");
+    }
+  }
+
   /// 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.

lib/LLVMPasses/DbgAddrBlockSplitter.cpp

@@ -39,6 +39,8 @@ struct SwiftDbgAddrBlockSplitter : FunctionPass {
 bool SwiftDbgAddrBlockSplitter::runOnFunction(Function &fn) {
   SmallVector<Instruction *, 32> breakBlockPoints;
 
+  // If we are in the first block,
+
   for (auto &block : fn) {
     for (auto &inst : block) {
       if (isa<DbgAddrIntrinsic>(&inst)) {

lib/SILOptimizer/Mandatory/DebugInfoCanonicalizer.cpp

@@ -50,6 +50,7 @@
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/BasicBlockBits.h"
 #include "swift/SIL/BasicBlockDatastructures.h"
+#include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILUndef.h"
@@ -68,22 +69,22 @@ using namespace swift;
 //                                  Utility
 //===----------------------------------------------------------------------===//
 
-static SILInstruction *cloneDebugValue(DebugValueInst *original,
+static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
                                        SILInstruction *insertPt) {
   SILBuilderWithScope builder(std::next(insertPt->getIterator()));
   builder.setCurrentDebugScope(original->getDebugScope());
-  return builder.createDebugValue(original->getLoc(), original->getOperand(),
-                                  *original->getVarInfo(), false,
-                                  true /*was moved*/);
+  return builder.createDebugValue(
+      original->getLoc(), original.getOperandForDebugValueClone(),
+      *original.getVarInfo(), false, true /*was moved*/);
 }
 
-static SILInstruction *cloneDebugValue(DebugValueInst *original,
+static SILInstruction *cloneDebugValue(DebugVarCarryingInst original,
                                        SILBasicBlock *block) {
   SILBuilderWithScope builder(&block->front());
   builder.setCurrentDebugScope(original->getDebugScope());
-  return builder.createDebugValue(original->getLoc(), original->getOperand(),
-                                  *original->getVarInfo(), false,
-                                  true /*was moved*/);
+  return builder.createDebugValue(
+      original->getLoc(), original.getOperandForDebugValueClone(),
+      *original.getVarInfo(), false, true /*was moved*/);
 }
 
 //===----------------------------------------------------------------------===//
@@ -93,7 +94,7 @@ static SILInstruction *cloneDebugValue(DebugValueInst *original,
 namespace {
 
 struct BlockState {
-  llvm::SmallMapVector<SILDebugVariable, DebugValueInst *, 4> debugValues;
+  llvm::SmallMapVector<SILDebugVariable, DebugVarCarryingInst, 4> debugValues;
 };
 
 struct DebugInfoCanonicalizer {
@@ -202,13 +203,20 @@ bool DebugInfoCanonicalizer::process() {
     // Then for each inst in the block...
     for (auto &inst : *block) {
       LLVM_DEBUG(llvm::dbgs() << "    Inst: " << inst);
-      // If we have a debug_value that was moved, store state for it.
-      if (auto *dvi = dyn_cast<DebugValueInst>(&inst)) {
-        if (!dvi->getWasMoved())
+
+      // Skip any alloc box inst we see, we do not support them yet.
+      if (isa<AllocBoxInst>(&inst))
+        continue;
+
+      // If we have a debug_value or alloc_stack that was moved, store state for
+      // it. Once the isa check above is removed, this will handle alloc_box as
+      // well.
+      if (auto dvi = DebugVarCarryingInst(&inst)) {
+        if (!dvi.getWasMoved())
           continue;
 
         LLVM_DEBUG(llvm::dbgs() << "        Found DebugValueInst!\n");
-        auto debugInfo = dvi->getVarInfo();
+        auto debugInfo = dvi.getVarInfo();
         if (!debugInfo) {
           LLVM_DEBUG(llvm::dbgs() << "        Has no var info?! Skipping!\n");
           continue;

test/DebugInfo/move_function_dbginfo_async.swift

@@ -165,6 +165,7 @@ public func letSimpleTest<T>(_ msg: __owned T) async {
 // DWARF:    [0x{{[a-f0-9]+}}, 0x{{[a-f0-9]+}}): DW_OP_breg6 RBP-88, DW_OP_deref, DW_OP_plus_uconst 0x10, DW_OP_plus_uconst 0x8, DW_OP_deref)
 // DWARF: DW_AT_name	("msg")
 
+// Change name to varSimpleTestArg
 public func varSimpleTest<T>(_ msg: inout T, _ msg2: T) async {
     await forceSplit()
     use(_move(msg))
@@ -175,3 +176,43 @@ public func varSimpleTest<T>(_ msg: inout T, _ msg2: T) async {
     msg = msg2
     await forceSplit()
 }
+
+// We don't have an argument here, so we shouldn't have an llvm.dbg.addr in the
+// initial function.
+//
+// CHECK-LABEL: define swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaF"(%swift.context* swiftasync %0)
+// CHECK-NOT: llvm.dbg.addr
+//
+// CHECK-LABEL: define internal swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaFTY0_"(i8* swiftasync %0)
+// CHECK: call void @llvm.dbg.addr(metadata i8* %0, metadata !{{[0-9]+}}, metadata !DIExpression(DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8))
+//
+// CHECK-LABEL: define internal swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaFTQ1_"(i8* swiftasync %0)
+// CHECK: call void @llvm.dbg.addr(metadata i8* %0, metadata !{{[0-9]+}}, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8))
+
+// CHECK-LABEL: define internal swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaFTY2_"(i8* swiftasync %0)
+// CHECK: call void @llvm.dbg.addr(metadata i8* %0, metadata ![[METADATA:[0-9]+]], metadata !DIExpression(DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)), !dbg ![[ADDR_LOC:[0-9]+]]
+// CHECK: call void @llvm.dbg.value(metadata %T27move_function_dbginfo_async5KlassC** undef, metadata ![[METADATA]], metadata !DIExpression()), !dbg ![[ADDR_LOC]]
+
+// CHECK-LABEL: define internal swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaFTQ3_"(i8* swiftasync %0)
+// We should only see an llvm.dbg.value here.
+// CHECK-NOT: llvm.dbg.addr
+// CHECK: call void @llvm.dbg.value(metadata %T27move_function_dbginfo_async5KlassC** undef,
+// CHECK-NOT: llvm.dbg.addr
+//
+// We should see first a llvm.dbg.value to undef the value until we reinit. Then
+// we should see a llvm.dbg.addr to reinit.
+//
+// CHECK-LABEL: define internal swifttailcc void @"$s27move_function_dbginfo_async16varSimpleTestVaryyYaFTY4_"(i8* swiftasync %0)
+// CHECK: call void @llvm.dbg.value(metadata %T27move_function_dbginfo_async5KlassC** undef, metadata ![[METADATA:[0-9]+]], metadata !DIExpression()), !dbg ![[ADDR_LOC:[0-9]+]]
+// CHECK: call void @llvm.dbg.addr(metadata i8* %0, metadata ![[METADATA]], metadata !DIExpression(DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)), !dbg ![[ADDR_LOC]]
+public func varSimpleTestVar() async {
+    var k = Klass()
+    k.doSomething()
+    await forceSplit()
+    let m = _move(k)
+    m.doSomething()
+    await forceSplit()
+    k = Klass()
+    k.doSomething()
+    print("stop here")
+}