Merge pull request swiftlang#35444 from adrian-prantl/async-box-di

Add debug info support for boxed arguments in async functions.

Author: adrian-prantl

lib/IRGen/IRGenDebugInfo.cpp

@@ -199,6 +199,10 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
                         llvm::DILocalVariable *Var, llvm::DIExpression *Expr,
                         unsigned Line, unsigned Col, llvm::DILocalScope *Scope,
                         const SILDebugScope *DS, bool InCoroContext = false);
+#ifndef NDEBUG
+  bool verifyCoroutineArgument(llvm::Value *Addr);
+#endif
+
   void emitGlobalVariableDeclaration(llvm::GlobalVariable *Storage,
                                      StringRef Name, StringRef LinkageName,
                                      DebugTypeInfo DebugType,
@@ -1611,6 +1615,8 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       return getOrCreateDesugaredType(CanTy, DbgTy);
     }
 
+    // SILBox should appear only inside of coroutine contexts.
+    case TypeKind::SILBox:
     case TypeKind::DependentMember:
     case TypeKind::GenericTypeParam: {
       // FIXME: Provide a more meaningful debug type.
@@ -1628,7 +1634,6 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     case TypeKind::Hole:
     case TypeKind::Module:
     case TypeKind::SILBlockStorage:
-    case TypeKind::SILBox:
     case TypeKind::SILToken:
     case TypeKind::BuiltinUnsafeValueBuffer:
     case TypeKind::BuiltinDefaultActorStorage:
@@ -1652,7 +1657,6 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     switch (Ty->getKind()) {
     case TypeKind::GenericFunction: // Not yet supported.
     case TypeKind::SILBlockStorage: // Not supported at all.
-    case TypeKind::SILBox:
       return false;
     default:
       return true;
@@ -2455,6 +2459,28 @@ void IRGenDebugInfoImpl::emitDbgIntrinsic(
   }
 }
 
+#ifndef NDEBUG
+bool IRGenDebugInfoImpl::verifyCoroutineArgument(llvm::Value *Addr) {
+  llvm::Value *Storage = Addr;
+  while (Storage) {
+    if (auto *LdInst = dyn_cast<llvm::LoadInst>(Storage))
+      Storage = LdInst->getOperand(0);
+    else if (auto *GEPInst = dyn_cast<llvm::GetElementPtrInst>(Storage))
+      Storage = GEPInst->getOperand(0);
+    else if (auto *BCInst = dyn_cast<llvm::BitCastInst>(Storage))
+      Storage = BCInst->getOperand(0);
+    else if (auto *CallInst = dyn_cast<llvm::CallInst>(Storage)) {
+      assert(CallInst->getCalledFunction() == IGM.getProjectBoxFn() &&
+             "unhandled projection");
+      Storage = CallInst->getArgOperand(0);
+    } else
+
+      break;
+  }
+  return llvm::isa<llvm::Argument>(Storage);
+}
+#endif
+
 void IRGenDebugInfoImpl::emitGlobalVariableDeclaration(
     llvm::GlobalVariable *Var, StringRef Name, StringRef LinkageName,
     DebugTypeInfo DbgTy, bool IsLocalToUnit, bool InFixedBuffer,
@@ -2638,6 +2664,12 @@ void IRGenDebugInfo::emitDbgIntrinsic(IRBuilder &Builder, llvm::Value *Storage,
       Builder, Storage, Var, Expr, Line, Col, Scope, DS, InCoroContext);
 }
 
+#ifndef NDEBUG
+bool IRGenDebugInfo::verifyCoroutineArgument(llvm::Value *Addr) {
+  return static_cast<IRGenDebugInfoImpl *>(this)->verifyCoroutineArgument(Addr);
+}
+#endif
+
 void IRGenDebugInfo::emitGlobalVariableDeclaration(
     llvm::GlobalVariable *Storage, StringRef Name, StringRef LinkageName,
     DebugTypeInfo DebugType, bool IsLocalToUnit, bool InFixedBuffer,

lib/IRGen/IRGenDebugInfo.h

@@ -150,6 +150,10 @@ class IRGenDebugInfo {
                         llvm::DILocalVariable *Var, llvm::DIExpression *Expr,
                         unsigned Line, unsigned Col, llvm::DILocalScope *Scope,
                         const SILDebugScope *DS, bool InCoroContext = false);
+#ifndef NDEBUG
+  /// Verify that Addr can be processed by llvm's CoroFrame/CoroSplit.
+  bool verifyCoroutineArgument(llvm::Value *Addr);
+#endif
 
   enum { NotHeapAllocated = false };
 

lib/IRGen/IRGenSIL.cpp

@@ -4360,26 +4360,23 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
       (IsLoadablyByAddress) ? DirectValue : IndirectValue;
   VarInfo->Name = getVarName(i, IsAnonymous);
   auto *Addr = getLoweredAddress(SILVal).getAddress();
+  SILType SILTy = SILVal->getType();
+  auto RealType = SILTy.getASTType();
   if (CurSILFn->isAsync() && VarInfo->ArgNo) {
-#ifndef NDEBUG
-    llvm::Value *Storage = Addr;
-    while (Storage) {
-      if (auto *LdInst = dyn_cast<llvm::LoadInst>(Storage))
-        Storage = LdInst->getOperand(0);
-      else if (auto *GEPInst = dyn_cast<llvm::GetElementPtrInst>(Storage))
-        Storage = GEPInst->getOperand(0);
-      else if (auto *BCInst = dyn_cast<llvm::BitCastInst>(Storage))
-        Storage = BCInst->getOperand(0);
-      else 
-        break;
-    }
-    assert(llvm::isa<llvm::Argument>(Storage) &&
-           "arg expected to be load from inside swift.context");
-#endif
+    if (IGM.DebugInfo)
+      assert(IGM.DebugInfo->verifyCoroutineArgument(Addr) &&
+             "arg expected to be load from inside %swift.context");
     Indirection = CoroIndirectValue;
+    if (auto *PBI = dyn_cast<ProjectBoxInst>(i->getOperand())) {
+      // Usually debug info only ever describes the *result* of a projectBox
+      // call. To allow the debugger to display a boxed parameter of an async
+      // continuation object, however, the debug info can only describe the box
+      // itself and thus also needs to emit a box type for it so the debugger
+      // knows to call into Remote Mirrors to unbox the value.
+      RealType = PBI->getOperand()->getType().getASTType();
+      assert(isa<SILBoxType>(RealType));
+    }
   }
-  SILType SILTy = SILVal->getType();
-  auto RealType = SILTy.getASTType();
 
   auto DbgTy = DebugTypeInfo::getLocalVariable(
       Decl, RealType, getTypeInfo(SILVal->getType()));

test/DebugInfo/async-boxed-arg.swift

@@ -0,0 +1,20 @@
+// RUN: %target-swift-frontend %s -emit-ir -g -o - -parse-as-library \
+// RUN:    -module-name M -enable-experimental-concurrency | %FileCheck %s
+// REQUIRES: concurrency
+
+extension Collection {
+  public func f() async throws {
+    return await try Task.withGroup(resultType: Element.self) { group in
+      var i = self.startIndex
+      func doit() async throws {
+        await group.add { [i] in
+          return self[i]
+        }
+      }
+      await try doit()
+    }
+  }
+}
+
+// CHECK: ![[BOXTY:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$s5IndexSlQzz_x_SlRzlXXD"
+// CHECK: !DILocalVariable(name: "i", arg: 3, {{.*}}type: ![[BOXTY]]