Merge pull request #6624 from adrian-prantl/107687703

Implement a workaround to acrtificially extend the lifetime of async

Author: adrian-prantl

lldb/test/API/lang/swift/async/variables/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+SWIFTFLAGS_EXTRAS := -parse-as-library
+include Makefile.rules

lldb/test/API/lang/swift/async/variables/TestSwiftAsyncVariables.py

@@ -0,0 +1,23 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+
+class TestSwiftAsyncVariables(lldbtest.TestBase):
+
+    mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+    @swiftTest
+    @skipIf(oslist=['windows', 'linux'])
+    def test(self):
+        """Test local variables in async functions"""
+        self.build()
+        src = lldb.SBFileSpec('main.swift')
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, 'break here', src)
+
+        while process.selected_thread.stop_reason == lldb.eStopReasonBreakpoint:
+            self.expect("frame variable x", substrs=["23"])
+            process.Continue()

lldb/test/API/lang/swift/async/variables/main.swift

@@ -0,0 +1,23 @@
+import Swift
+func use<T>(_ t: T) {}
+func sink<T>(_ t: T) {}
+
+func split() async {}
+
+func f(_ xs: [Int?]) async {
+  for x in xs {
+    let x = x!
+    sink(x) // break here
+  }
+  await split()
+  for x in xs {
+    let x = x!
+    sink(x) // break here
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    await f([23])
+  }
+}

llvm/include/llvm/CodeGen/DebugHandlerBase.h

@@ -98,7 +98,8 @@ class DebugHandlerBase : public AsmPrinterHandler {
 
   /// Ensure that a label will be emitted before MI.
   void requestLabelBeforeInsn(const MachineInstr *MI) {
-    LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
+    if (!LabelsBeforeInsn.count(MI))
+      LabelsBeforeInsn.insert(std::make_pair(MI, nullptr));
   }
 
   /// Ensure that a label will be emitted after MI.

llvm/include/llvm/CodeGen/MachineInstr.h

@@ -1946,6 +1946,10 @@ struct MachineInstrExpressionTrait : DenseMapInfo<MachineInstr*> {
   }
 };
 
+// BEGIN SWIFT
+bool isSwiftAsyncContext(const MachineFunction &MF, Register Reg);
+// END SWIFT
+  
 //===----------------------------------------------------------------------===//
 // Debugging Support
 

llvm/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

@@ -16,6 +16,7 @@
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
@@ -182,6 +183,25 @@ void DbgValueHistoryMap::trimLocationRanges(
       if (!EI->isDbgValue())
         continue;
 
+      // BEGIN SWIFT
+      // Swift async function handling.
+      {
+        bool skipAsyncEntryValue = false;
+        auto &MI = *EI->getInstr();
+        auto *Expr = MI.getDebugExpression();
+        for (const MachineOperand &MO : MI.debug_operands()) {
+          if (MO.isReg() && MO.getReg() != 0)
+            if (Expr && Expr->isEntryValue() &&
+                isSwiftAsyncContext(MF, MO.getReg())) {
+              skipAsyncEntryValue = true;
+              break;
+            }
+        }
+        if (skipAsyncEntryValue)
+          continue;
+      }
+      // END SWIFT
+
       // Index of the entry which closes this range.
       EntryIndex EndIndex = EI->getEndIndex();
       // If this range is closed bump the reference count of the closing entry.

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

@@ -300,6 +300,7 @@ void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
         Entries.front().getInstr()->getDebugVariable();
     if (DIVar->isParameter() &&
         getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) {
+
       if (!IsDescribedByReg(Entries.front().getInstr()))
         LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
       if (Entries.front().getInstr()->getDebugExpression()->isFragment()) {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -1562,6 +1562,20 @@ static bool validThroughout(LexicalScopes &LScopes,
   if (LSRange.size() == 0)
     return false;
 
+  // BEGIN SWIFT
+  // Swift async function handling.
+  {
+    auto &MI = *DbgValue;
+    auto MF = MBB->getParent();
+    auto *Expr = MI.getDebugExpression();
+    if (Expr && Expr->isEntryValue())
+      for (const MachineOperand &MO : MI.debug_operands())
+        if (MO.isReg() && MO.getReg() != 0)
+          if (isSwiftAsyncContext(*MF, MO.getReg()))
+            return true;
+  }
+  // END SWIFT
+
   const MachineInstr *LScopeBegin = LSRange.front().first;
   // If the scope starts before the DBG_VALUE then we may have a negative
   // result. Otherwise the location is live coming into the scope and we

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

@@ -155,23 +155,6 @@ static cl::opt<unsigned>
                          cl::desc("livedebugvalues-stack-ws-limit"),
                          cl::init(250));
 
-// BEGIN SWIFT
-static bool isSwiftAsyncContext(const MachineFunction &MF, Register Reg) {
-  const llvm::Function &F = MF.getFunction();
-  if (!MF.getProperties().hasProperty(
-          MachineFunctionProperties::Property::TracksLiveness))
-    return false;
-  unsigned I = 0;
-  for (auto R : MF.getRegInfo().liveins()) {
-    if (R.first == (unsigned)Reg &&
-        F.hasParamAttribute(I, Attribute::SwiftAsync))
-      return true;
-    ++I;
-  }
-  return false;
-}
-// END SWIFT
-
 DbgOpID DbgOpID::UndefID = DbgOpID(0xffffffff);
 
 /// Tracker for converting machine value locations and variable values into

llvm/lib/CodeGen/MachineRegisterInfo.cpp

@@ -671,3 +671,20 @@ bool MachineRegisterInfo::isGeneralPurposeRegister(const MachineFunction &MF,
                                                    MCRegister Reg) const {
   return getTargetRegisterInfo()->isGeneralPurposeRegister(MF, Reg);
 }
+
+// BEGIN SWIFT
+bool llvm::isSwiftAsyncContext(const MachineFunction &MF, Register Reg) {
+  const llvm::Function &F = MF.getFunction();
+  if (!MF.getProperties().hasProperty(
+          MachineFunctionProperties::Property::TracksLiveness))
+    return false;
+  unsigned I = 0;
+  for (auto R : MF.getRegInfo().liveins()) {
+    if (R.first == (unsigned)Reg &&
+        F.hasParamAttribute(I, Attribute::SwiftAsync))
+      return true;
+    ++I;
+  }
+  return false;
+}
+// END SWIFT