[CoroSplit][DebugInfo] Don't use entry_value for async args in 32-bit targets

[fdeazeve]

Summary

Only X86_64 and ARM64 have a reserved register for async arguments, and so the
debugger is only able to handle those targets. For other architectures, we use a
non-entry-value expression and let the debugger do its best with that.

[fdeazeve]

Reword a comment

[fdeazeve]

Apparently this is failing to link on the nvidia MLIR bot. Investigating

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

for (auto *U : E.second) {
           // processed by coro::salvageDebugInfo() by CoroCloner.
           DIBuilder(*CurrentBlock->getParent()->getParent(), AllowUnresolved)
               .insertDeclare(CurrentReload, DDI->getVariable(),
                              DDI->getExpression(), DDI->getDebugLoc(),
                              &*Builder.GetInsertPoint());
           // This dbg.declare is for the main function entry point.  It
           // will be deleted in all coro-split functions.
           coro::salvageDebugInfo(ArgToAllocaMap, DDI, Shape.OptimizeFrame,
-                                 true /*IsEntryPoint*/);
+                                 false /*UseEntryValue*/);
         }
       }
 
       // If we have a single edge PHINode, remove it and replace it with a
       // reload from the coroutine frame. (We already took care of multi edge
       // PHINodes by rewriting them in the rewritePHIs function).
       if (auto *PN = dyn_cast<PHINode>(U)) {
         assert(PN->getNumIncomingValues() == 1 &&
static void collectFrameAlloca(AllocaInst *AI, coro::Shape &Shape,
   if (!Visitor.getShouldLiveOnFrame())
     return;
   Allocas.emplace_back(AI, Visitor.getAliasesCopy(),
                        Visitor.getMayWriteBeforeCoroBegin());
 }
 
 void coro::salvageDebugInfo(
     SmallDenseMap<Argument *, AllocaInst *, 4> &ArgToAllocaMap,
-    DbgVariableIntrinsic *DVI, bool OptimizeFrame, bool IsEntryPoint) {
+    DbgVariableIntrinsic *DVI, bool OptimizeFrame, bool UseEntryValue) {
   Function *F = DVI->getFunction();
   IRBuilder<> Builder(F->getContext());
   auto InsertPt = F->getEntryBlock().getFirstInsertionPt();
   while (isa<IntrinsicInst>(InsertPt))
     ++InsertPt;
   Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt);
   DIExpression *Expr = DVI->getExpression();
   // Follow the pointer arithmetic all the way to the incoming
void coro::salvageDebugInfo(
   const bool IsSwiftAsyncArg =
       StorageAsArg && StorageAsArg->hasAttribute(Attribute::SwiftAsync);
 
   // Swift async arguments are described by an entry value of the ABI-defined
   // register containing the coroutine context.
   // For the EntryPoint funclet, don't use EntryValues. This funclet can be
   // inlined, which would remove the guarantee that this intrinsic targets an
   // Argument.
-  if (IsSwiftAsyncArg && !IsEntryPoint && !Expr->isEntryValue())
+  if (IsSwiftAsyncArg && UseEntryValue && !Expr->isEntryValue())
     Expr = DIExpression::prepend(Expr, DIExpression::EntryValue);
 
   // If the coroutine frame is an Argument, store it in an alloca to improve
   // its availability (e.g. registers may be clobbered).
   // Avoid this if optimizations are enabled (they would remove the alloca) or
   // if the value is guaranteed to be available through other means (e.g. swift
   // ABI guarantees).
   if (StorageAsArg && !OptimizeFrame && !IsSwiftAsyncArg) {

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

 void CoroCloner::replaceSwiftErrorOps() {
   ::replaceSwiftErrorOps(*NewF, Shape, &VMap);
 }
 
 void CoroCloner::salvageDebugInfo() {
   SmallVector<DbgVariableIntrinsic *, 8> Worklist =
       collectDbgVariableIntrinsics(*NewF);
   SmallDenseMap<Argument *, AllocaInst *, 4> ArgToAllocaMap;
+
+  // Only 64-bit ABIs have a register we can refer to with the entry value.
+  bool UseEntryValue =
+      llvm::Triple(OrigF.getParent()->getTargetTriple()).isArch64Bit();
   for (DbgVariableIntrinsic *DVI : Worklist)
     coro::salvageDebugInfo(ArgToAllocaMap, DVI, Shape.OptimizeFrame,
-                           false /*IsEntryPoint*/);
+                           UseEntryValue);
 
   // Remove all salvaged dbg.declare intrinsics that became
   // either unreachable or stale due to the CoroSplit transformation.
   DominatorTree DomTree(*NewF);
   auto IsUnreachableBlock = [&](BasicBlock *BB) {
     return !isPotentiallyReachable(&NewF->getEntryBlock(), BB, nullptr,
                                    &DomTree);
   };
splitCoroutine(Function &F, SmallVectorImpl<Function *> &Clones,
   replaceSwiftErrorOps(F, Shape, nullptr);
 
   // Salvage debug intrinsics that point into the coroutine frame in the
   // original function. The Cloner has already salvaged debug info in the new
   // coroutine funclets.
   SmallDenseMap<Argument *, AllocaInst *, 4> ArgToAllocaMap;
   for (auto *DDI : collectDbgVariableIntrinsics(F))
     coro::salvageDebugInfo(ArgToAllocaMap, DDI, Shape.OptimizeFrame,
-                           true /*IsEntryPoint*/);
+                           false /*UseEntryValue*/);
 
   return Shape;
 }
 
 /// Remove calls to llvm.coro.end in the original function.
 static void removeCoroEnds(const coro::Shape &Shape) {
   for (auto *End : Shape.CoroEnds) {
     replaceCoroEnd(End, Shape, Shape.FramePtr, /*in resume*/ false, nullptr);

llvm/test/Transforms/Coroutines/swift-async-dbg.ll

-; RUN: opt %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s
+; RUN: opt -mtriple='arm64-' %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s
+; RUN: opt -mtriple='x86_64' %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s
+; RUN: opt -mtriple='i386-' %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s --check-prefix=NOENTRY
+; RUN: opt -mtriple='armv7-' %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s --check-prefix=NOENTRY
+; NOENTRY-NOT: OP_llvm_entry_value
+
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
-target triple = "arm64-apple-macosx13.0.0"
 
 ; This coroutine has one split point and two variables defined by:
 ;   %var_with_dbg_value,   which has multiple dbg.value intrinsics associated with
 ;                          it, one per split point.
 ;   %var_with_dbg_declare, which has a single dbg.declare intrinsic associated
 ;                          with it at the coroutine entry.
 ; We check that, for each funclet, the debug intrinsics are propagated properly AND that
 ; an `entry_value` operation is created.