Implement Swift async context entry value support in InstrRefBasedLDV.

rdar://85560130

Author: adrian-prantl

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

@@ -148,6 +148,21 @@ static cl::opt<bool> EmulateOldLDV("emulate-old-livedebugvalues", cl::Hidden,
                                    cl::desc("Act like old LiveDebugValues did"),
                                    cl::init(false));
 
+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;
+}
+
 /// Tracker for converting machine value locations and variable values into
 /// variable locations (the output of LiveDebugValues), recorded as DBG_VALUEs
 /// specifying block live-in locations and transfers within blocks.
@@ -420,18 +435,20 @@ class TransferTracker {
     if (!ShouldEmitDebugEntryValues)
       return false;
 
-    // Is the variable appropriate for entry values (i.e., is a parameter).
-    if (!isEntryValueVariable(Var, Prop.DIExpr))
-      return false;
-
     // Is the value assigned to this variable still the entry value?
     if (!isEntryValueValue(Num))
       return false;
 
+    Register Reg = MTracker->LocIdxToLocID[Num.getLoc()];
+
+    // Is the variable appropriate for entry values (i.e., is a parameter).
+    if (!isEntryValueVariable(Var, Prop.DIExpr) &&
+        !isSwiftAsyncContext(MF, Reg))
+      return false;
+
     // Emit a variable location using an entry value expression.
     DIExpression *NewExpr =
         DIExpression::prepend(Prop.DIExpr, DIExpression::EntryValue);
-    Register Reg = MTracker->LocIdxToLocID[Num.getLoc()];
     MachineOperand MO = MachineOperand::CreateReg(Reg, false);
 
     PendingDbgValues.push_back(emitMOLoc(MO, Var, {NewExpr, Prop.Indirect}));
@@ -958,8 +975,18 @@ bool InstrRefBasedLDV::transferDebugValue(const MachineInstr &MI) {
 
   // MLocTracker needs to know that this register is read, even if it's only
   // read by a debug inst.
-  if (MO.isReg() && MO.getReg() != 0)
+  if (MO.isReg() && MO.getReg() != 0) {
     (void)MTracker->readReg(MO.getReg());
+    auto *Expr = MI.getDebugExpression();
+    const llvm::MachineFunction *MF = MI.getParent()->getParent();
+    if (!(Expr && Expr->isEntryValue()) &&
+        isSwiftAsyncContext(*MF, MO.getReg())) {
+      // In Swift async functions entry values are preferred, since they
+      // can be evaluated in both live frames and virtual backtraces.
+      const_cast<MachineInstr *>(&MI)->getOperand(3).setMetadata(
+          DIExpression::prepend(Expr, DIExpression::EntryValue));
+    }
+  }
 
   // If we're preparing for the second analysis (variables), the machine value
   // locations are already solved, and we report this DBG_VALUE and the value

llvm/test/DebugInfo/MIR/X86/swift-async-entryvalues.mir

@@ -244,6 +244,6 @@ body:             |
     CALL64r killed renamable $rax, csr_64, implicit $rsp, implicit $ssp, implicit killed $rdi, implicit killed $rsi, implicit killed $r14, implicit-def $rsp, implicit-def $ssp, debug-location !65
     $rsp = frame-destroy ADD64ri8 $rsp, 32, implicit-def dead $eflags, debug-location !65
     $r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !65
-    RETQ debug-location !65
+    RET64 debug-location !65
 
 ...