Implement a workaround to artificially extend the lifetime of async DBG_VALUEs.

A better solution would be to lower async dbg.declare intrinsics into
MMI side-table entries. This patch, however, is less risky to
implement in the swift/release/5.9 branch.

rdar://107687703

Author: adrian-prantl

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