Add support for llvm.dbg.coroframe_entry in the CoroSplitter pass.

Make sure the CoroSplitter pass correctly handles
llvm.dbg.coroframe_entry intrinsics. Also, convert them to
llvm.dbg.declares so that any subsquent passes do not need to be amended
to support the llvm.dbg.coroframe_entry intrinsic.

rdar://157299589

rdar://157509307

Author: rastogishubham

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

@@ -555,6 +555,8 @@ static void cacheDIVar(FrameDataInfo &FrameData,
     };
     CacheIt(findDbgDeclares(V));
     CacheIt(findDVRDeclares(V));
+    CacheIt(findDbgCoroFrameEntrys(V));
+    CacheIt(findDVRCoroFrameEntrys(V));
   }
 }
 
@@ -1156,6 +1158,46 @@ static void insertSpills(const FrameDataInfo &FrameData, coro::Shape &Shape) {
         for_each(DVRs, SalvageOne);
       }
 
+      TinyPtrVector<DbgCoroFrameEntryInst *> DICoros =
+          findDbgCoroFrameEntrys(Def);
+      TinyPtrVector<DbgVariableRecord *> DVRCoros = findDVRCoroFrameEntrys(Def);
+      // Try best to find dbg.coroframe_entry. If the spill is a temp, there may
+      // not be a direct dbg.coroframe_entry. Walk up the load chain to find one
+      // from an alias.
+      if (F->getSubprogram()) {
+        auto *CurDef = Def;
+        while (DICoros.empty() && DVRCoros.empty() && isa<LoadInst>(CurDef)) {
+          auto *LdInst = cast<LoadInst>(CurDef);
+          // Only consider ptr to ptr same type load.
+          if (LdInst->getPointerOperandType() != LdInst->getType())
+            break;
+          CurDef = LdInst->getPointerOperand();
+          if (!isa<AllocaInst, LoadInst>(CurDef))
+            break;
+          DICoros = findDbgCoroFrameEntrys(CurDef);
+          DVRCoros = findDVRCoroFrameEntrys(CurDef);
+        }
+      }
+
+      auto SalvageOneCoro = [&](auto *DDI) {
+        // This dbg.coroframe_entry is preserved for all coro-split function
+        // fragments. It will be unreachable in the main function, and
+        // processed by coro::salvageDebugInfo() by the Cloner. However, convert
+        // it to a dbg.declare to make sure future passes don't have to deal
+        // with a dbg.coroframe_entry.
+        DbgVariableRecord *NewDVR = new DbgVariableRecord(
+            ValueAsMetadata::get(CurrentReload), DDI->getVariable(),
+            DDI->getExpression(), DDI->getDebugLoc(),
+            DbgVariableRecord::LocationType::Declare);
+        Builder.GetInsertPoint()->getParent()->insertDbgRecordBefore(
+            NewDVR, Builder.GetInsertPoint());
+        // This dbg.coroframe_entry is for the main function entry point.  It
+        // will be deleted in all coro-split functions.
+        coro::salvageDebugInfo(ArgToAllocaMap, *DDI, false /*UseEntryValue*/);
+      };
+      for_each(DICoros, SalvageOneCoro);
+      for_each(DVRCoros, SalvageOneCoro);
+
       // 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 normalizing them in the rewritePHIs function).
@@ -1954,10 +1996,10 @@ void coro::salvageDebugInfo(
 
   DVI.replaceVariableLocationOp(OriginalStorage, Storage);
   DVI.setExpression(Expr);
-  // We only hoist dbg.declare today since it doesn't make sense to hoist
-  // dbg.value since it does not have the same function wide guarantees that
-  // dbg.declare does.
-  if (isa<DbgDeclareInst>(DVI)) {
+  // We only hoist dbg.declare and dbg.coroframe_entry today since it doesn't
+  // make sense to hoist dbg.value since it does not have the same function wide
+  // guarantees that dbg.declare and dbg.coroframe_entry do.
+  if (isa<DbgDeclareInst>(DVI) || isa<DbgCoroFrameEntryInst>(DVI)) {
     std::optional<BasicBlock::iterator> InsertPt;
     if (auto *I = dyn_cast<Instruction>(Storage)) {
       InsertPt = I->getInsertionPointAfterDef();
@@ -1982,7 +2024,7 @@ void coro::salvageDebugInfo(
   Function *F = DVR.getFunction();
   // Follow the pointer arithmetic all the way to the incoming
   // function argument and convert into a DIExpression.
-  bool SkipOutermostLoad = DVR.isDbgDeclare();
+  bool SkipOutermostLoad = DVR.isDbgDeclare() || DVR.isDbgCoroFrameEntry();
   Value *OriginalStorage = DVR.getVariableLocationOp(0);
 
   auto SalvagedInfo =
@@ -1996,10 +2038,11 @@ void coro::salvageDebugInfo(
 
   DVR.replaceVariableLocationOp(OriginalStorage, Storage);
   DVR.setExpression(Expr);
-  // We only hoist dbg.declare today since it doesn't make sense to hoist
-  // dbg.value since it does not have the same function wide guarantees that
-  // dbg.declare does.
-  if (DVR.getType() == DbgVariableRecord::LocationType::Declare) {
+  // We only hoist dbg.declare and dbg.coroframe_entry today since it doesn't
+  // make sense to hoist dbg.value since it does not have the same function wide
+  // guarantees that dbg.declare and dbg.coroframe_entry do.
+  if (DVR.getType() == DbgVariableRecord::LocationType::Declare ||
+      DVR.getType() == DbgVariableRecord::LocationType::CoroFrameEntry) {
     std::optional<BasicBlock::iterator> InsertPt;
     if (auto *I = dyn_cast<Instruction>(Storage)) {
       InsertPt = I->getInsertionPointAfterDef();
@@ -2014,6 +2057,11 @@ void coro::salvageDebugInfo(
       InsertPt = F->getEntryBlock().begin();
     if (InsertPt) {
       DVR.removeFromParent();
+      // If there is a dbg.coroframe_entry being reinserted, insert it as a
+      // dbg.declare instead, so that subsequent passes don't have to deal with
+      // a dbg.coroframe_entry.
+      if (DVR.getType() == DbgVariableRecord::LocationType::CoroFrameEntry)
+        DVR.Type = DbgVariableRecord::LocationType::Declare;
       (*InsertPt)->getParent()->insertDbgRecordBefore(&DVR, *InsertPt);
     }
   }