[RFC] [Coroutine] [Debug] Insert dbg.declare to entry.resume to print alloca in the coroutine frame under O2

[ChuanqiXu]

Summary

Try to insert dbg.declare to entry.resume basic block in resume function. In this way, we could print alloca such as __promise in gdb/lldb under O2, which would be beneficial to debug coroutine program.

I am not sure whether this change is correct. I only test it by C++ programs locally. I would update the test case if needed. It could print __promise in all of the C++ coroutines I tested.

By the way, I think it is very beneficial to print the coroutine frame by keywords like __coro_frame. But I find it seems a little hard to implement.

Test-Plan: check-llvm

[ChuanqiXu]

The document (https://llvm.org/docs/SourceLevelDebugging.html#llvm-dbg-declare) says that dbg.declare is deprecated since it may obscure the optimization.
I think it is OK to use dbg.declare here. Since once we built the frame, it is hard to optimize the coroutine frame from my view.

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

1221

If we search for the dbg.value uses for parameters here and insert dbg.declare uses for the parameters, we could debug some parameter under O2 (for example this). But I am not sure if this is a good idea.

[junparser]

This comment was removed by junparser.

[junparser]

Does this change keeps the debug behavior in O0? @aprantl any next step with coroutine debug info?

[ChuanqiXu]

In D96938#2576088, @junparser wrote:

Does this change keeps the debug behavior in O0? @aprantl any next step with coroutine debug info?

In my local tests, it did keep debug behavior in O0.

[ChuanqiXu]

@aprantl @bruno gentle ping~

[aprantl]

Could you post an example that you are interested in at -O2 and show the diff of the LLVM IR for your example before/after this patch? I find it unintuitive that removing the shadow copy improved the debug info, but if don't need it and removing it doesn't pessimize the situation at -O0 we could remove it.

[ChuanqiXu]

Update test example under O2.

[ChuanqiXu]

In D96938#2583339, @aprantl wrote:

Could you post an example that you are interested in at -O2 and show the diff of the LLVM IR for your example before/after this patch? I find it unintuitive that removing the shadow copy improved the debug info, but if don't need it and removing it doesn't pessimize the situation at -O0 we could remove it.

The diff at -O2 before and after this patch is as follows:

 define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) {
 entry.resume:
-   call void @llvm.dbg.value(metadata %f.Frame* undef, metadata !19, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 16)), !dbg !21
-   %vFrame = bitcast %f.Frame* %FramePtr to i8*, !dbg !21
+  %vFrame = bitcast %f.Frame* %FramePtr to i8*, !dbg !19
+  call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata !21, metadata !DIExpression(DW_OP_plus_uconst, 16)), !dbg !19

Since the original version would emit the following codes in resume function:

define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) {
 entry.resume:
   %FramePtr.debug = alloca %f.Frame*, align 8, !dbg !19
  call void @llvm.dbg.declare(metadata %f.Frame** %FramePtr.debug, metadata !21, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 16)), !dbg !19

And %FramePtr.debug would be eliminated in SROA pass which would run after Coro-split pass at -O2. So the value for the corresponding declare would be undef finally.

I find it unintuitive that removing the shadow copy improved the debug info, but if don't need it and removing it doesn't pessimize the situation at -O0 we could remove it.

At O0, the difference before and after this patch would be:

define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) {
 entry.resume:
-   %FramePtr.debug = alloca %f.Frame*, align 8, !dbg !19
-   call void @llvm.dbg.declare(metadata %f.Frame** %FramePtr.debug, metadata !21, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 16)), !dbg !19
+  call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata !21, metadata !DIExpression(DW_OP_plus_uconst, 16)), !dbg !19

Due to the limits of my knowledge for debug information, I can't prove the semantics remain the same. I could only test for it in C++. And for now it looks like this patch keeps the debug behavior.

[aprantl]

Thanks for posting your analysis @ChuanqiXu! I would very much prefer to fix the pipeline such that after LowerDbgDeclare does its work the resulting dbg.value can be salvaged. I we can pull that off it would benefit the entire LLVM optimized code debug info story. I'll try to debug what's happening to see how feasible that is.

[ChuanqiXu]

In D96938#2588966, @aprantl wrote:

Thanks for posting your analysis @ChuanqiXu! I would very much prefer to fix the pipeline such that after LowerDbgDeclare does its work the resulting dbg.value can be salvaged. I we can pull that off it would benefit the entire LLVM optimized code debug info story. I'll try to debug what's happening to see how feasible that is.

From my point of view, the root reason why original version can't work at -O2 is that when the optimization passes (may be not only SROA ) eliminate/transform the alloca, these passes simply replace the value in the related dbg.declare/dbg.value with undef. So LowerDbgDeclare may not be the problem to me. So it seems like we need fix a lot optimization passes. It looks like a large and hard work.

[aprantl]

llvm/test/Transforms/Coroutines/coro-debug-O2.ll

13

this is missing a !dbg !8

[aprantl]

I looked at your example in the debugger and the problem seems to be that SROA is being run before LowerDbgDeclare (from Local.cpp). I believe reversing the order might work. Alternatively we could just not create an alloca in coro::salvageDebugInfo if optimizations are enabled, but I am not sure if this is known to the pass.

[ChuanqiXu]

Don't emit temporary alloca for arguments if optimization is enabled.

[ChuanqiXu]

In D96938#2601444, @aprantl wrote:

I looked at your example in the debugger and the problem seems to be that SROA is being run before LowerDbgDeclare (from Local.cpp). I believe reversing the order might work. Alternatively we could just not create an alloca in coro::salvageDebugInfo if optimizations are enabled, but I am not sure if this is known to the pass.

It looks OK to skip the creation for the alloca if optimizations are enabled.

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

2196

This style looks really ugly. Is there any way to fix it? Can we use a goto in the if statement?

[ChuanqiXu]

@aprantl gentle ping~

[ChuanqiXu]

@aprantl gentle ping~

[aprantl]

I think it would better to keep the orginal, more descriptive name ReuseFrameSlot and explain in a comment that this is only true if optimizations are enabled. With that change, this is fine.

[aprantl]

Added one more question inline.

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

666

I don't understand this change. Is this covered by your test? Are we even emitting dbg.declares when optimizations are turned on?

[ChuanqiXu]

Edit as the comment.

[ChuanqiXu]

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

2222

After salvage the debug information, if the Storage is Argument (which means the FramePtr in resume function), we should insert DDI just in the entry block of the resume function. I am not clear about whether the design is suitable for swift and mlir.

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

666

I moved this change to SalvageDebugInfo at CoroFrame.cpp.

666

With the the optimization are turned on, the debug information for promise (which would be part of coroutine by the standard) is dbg.declare. I am not clear if this is just a miss match or by design. As a result, it makes it easy to print the promise. And I think it should be OK to emit dbg.declare for promise. Since it would be put in the coroutine frame, I think the chance to optimize it is rare.

llvm/include/llvm/Transforms/Coroutines.h

 
 /// Add all coroutine passes to appropriate extension points.
 void addCoroutinePassesToExtensionPoints(PassManagerBuilder &Builder);
 
 /// Lower coroutine intrinsics that are not needed by later passes.
 Pass *createCoroEarlyLegacyPass();
 
 /// Split up coroutines into multiple functions driving their state machines.
-Pass *createCoroSplitLegacyPass(bool ReuseFrameSlot = false);
+Pass *createCoroSplitLegacyPass(bool IsOptimizing = false);
 
 /// Analyze coroutines use sites, devirtualize resume/destroy calls and elide
 /// heap allocation for coroutine frame where possible.
 Pass *createCoroElideLegacyPass();
 
 /// Lower all remaining coroutine intrinsics.
 Pass *createCoroCleanupLegacyPass();
 
 }
 
 #endif

llvm/include/llvm/Transforms/Coroutines/CoroSplit.h

 
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct CoroSplitPass : PassInfoMixin<CoroSplitPass> {
-  CoroSplitPass(bool ReuseFrameSlot = false) : ReuseFrameSlot(ReuseFrameSlot) {}
+  CoroSplitPass(bool IsOptimizing = false) : IsOptimizing(IsOptimizing) {}
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
   static bool isRequired() { return true; }
 
-  bool ReuseFrameSlot;
+  // Would be true if the Optimization level isn't O0.
+  bool IsOptimizing;
 };
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_COROUTINES_COROSPLIT_H

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

 #include <algorithm>
 
 using namespace llvm;
 
 // The "coro-suspend-crossing" flag is very noisy. There is another debug type,
 // "coro-frame", which results in leaner debug spew.
 #define DEBUG_TYPE "coro-suspend-crossing"
 
-static cl::opt<bool> EnableReuseStorageInFrame(
-    "reuse-storage-in-coroutine-frame", cl::Hidden,
-    cl::desc(
-        "Enable the optimization which would reuse the storage in the coroutine \
-         frame for allocas whose liferanges are not overlapped, for testing purposes"),
+static cl::opt<bool> EnableCoroutineOptimization(
+    "enable-coroutine-optimization", cl::Hidden,
+    cl::desc("Enable the optimization, for testing purposes only."),
     llvm::cl::init(false));
 
 enum { SmallVectorThreshold = 32 };
 
 // Provides two way mapping between the blocks and numbers.
 namespace {
 class BlockToIndexMapping {
   SmallVector<BasicBlock *, SmallVectorThreshold> V;
struct RTTIHelper {
     for (auto AllocaList : NonOverlapedAllocas) {
       auto *LargestAI = *AllocaList.begin();
       FieldIDType Id = addFieldForAlloca(LargestAI);
       for (auto *Alloca : AllocaList)
         FrameData.setFieldIndex(Alloca, Id);
     }
   });
 
-  if (!Shape.ReuseFrameSlot && !EnableReuseStorageInFrame) {
+  if (!Shape.IsOptimizing && !EnableCoroutineOptimization) {
     for (const auto &A : FrameData.Allocas) {
       AllocaInst *Alloca = A.Alloca;
       NonOverlapedAllocas.emplace_back(AllocaSetType(1, Alloca));
     }
     return;
   }
 
   // Because there are pathes from the lifetime.start to coro.end
for (auto *U : E.second) {
           // fragments. It will be unreachable in the main function, and
           // 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(DbgPtrAllocaCache, DDI);
+          coro::salvageDebugInfo(DbgPtrAllocaCache, DDI, Shape.IsOptimizing);
         }
       }
 
       // 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 &&
                "unexpected number of incoming "
                "values in the PHINode");
         PN->replaceAllUsesWith(CurrentReload);
if (!Visitor.getShouldLiveOnFrame())
       continue;
     Allocas.emplace_back(AI, Visitor.getAliasesCopy(),
                          Visitor.getMayWriteBeforeCoroBegin());
   }
 }
 
 void coro::salvageDebugInfo(
     SmallDenseMap<llvm::Value *, llvm::AllocaInst *, 4> &DbgPtrAllocaCache,
-    DbgDeclareInst *DDI) {
+    DbgDeclareInst *DDI, bool IsOptimizing) {
   Function *F = DDI->getFunction();
   IRBuilder<> Builder(F->getContext());
   auto InsertPt = F->getEntryBlock().getFirstInsertionPt();
   while (isa<IntrinsicInst>(InsertPt))
     ++InsertPt;
   Builder.SetInsertPoint(&F->getEntryBlock(), InsertPt);
   DIExpression *Expr = DDI->getExpression();
   // Follow the pointer arithmetic all the way to the incoming
if (auto *LdInst = dyn_cast<LoadInst>(Storage)) {
       Storage = BCInst->getOperand(0);
     else
       break;
   }
   // Store a pointer to the coroutine frame object in an alloca so it
   // is available throughout the function when producing unoptimized
   // code. Extending the lifetime this way is correct because the
   // variable has been declared by a dbg.declare intrinsic.
-  if (auto Arg = dyn_cast_or_null<llvm::Argument>(Storage)) {
+  //
+  // Avoid to create the alloca would be eliminated by optimization
+  // passes and the corresponding dbg.declares would be invalid.
+  if (!IsOptimizing && !EnableCoroutineOptimization)
+    if (auto *Arg = dyn_cast_or_null<llvm::Argument>(Storage)) {
       auto &Cached = DbgPtrAllocaCache[Storage];
       if (!Cached) {
         Cached = Builder.CreateAlloca(Storage->getType(), 0, nullptr,
                                       Arg->getName() + ".debug");
         Builder.CreateStore(Storage, Cached);
       }
       Storage = Cached;
       // FIXME: LLVM lacks nuanced semantics to differentiate between
       // memory and direct locations at the IR level. The backend will
       // turn a dbg.declare(alloca, ..., DIExpression()) into a memory
       // location. Thus, if there are deref and offset operations in the
       // expression, we need to add a DW_OP_deref at the *start* of the
       // expression to first load the contents of the alloca before
       // adjusting it with the expression.
       if (Expr && Expr->isComplex())
         Expr = DIExpression::prepend(Expr, DIExpression::DerefBefore);
     }
   auto &VMContext = DDI->getFunction()->getContext();
   DDI->setOperand(
       0, MetadataAsValue::get(VMContext, ValueAsMetadata::get(Storage)));
   DDI->setOperand(2, MetadataAsValue::get(VMContext, Expr));
   if (auto *InsertPt = dyn_cast_or_null<Instruction>(Storage))
     DDI->moveAfter(InsertPt);
 }
 
 void coro::buildCoroutineFrame(Function &F, Shape &Shape) {
   // Don't eliminate swifterror in async functions that won't be split.
   if (Shape.ABI != coro::ABI::Async || !Shape.CoroSuspends.empty())
     eliminateSwiftError(F, Shape);
 
   if (Shape.ABI == coro::ABI::Switch &&
       Shape.SwitchLowering.PromiseAlloca) {
     Shape.getSwitchCoroId()->clearPromise();

llvm/lib/Transforms/Coroutines/CoroInternal.h

bool declaresIntrinsics(const Module &M,
                         const std::initializer_list<StringRef>);
 void replaceCoroFree(CoroIdInst *CoroId, bool Elide);
 void updateCallGraph(Function &Caller, ArrayRef<Function *> Funcs,
                      CallGraph &CG, CallGraphSCC &SCC);
 /// Recover a dbg.declare prepared by the frontend and emit an alloca
 /// holding a pointer to the coroutine frame.
 void salvageDebugInfo(
     SmallDenseMap<llvm::Value *, llvm::AllocaInst *, 4> &DbgPtrAllocaCache,
-    DbgDeclareInst *DDI);
+    DbgDeclareInst *DDI, bool IsOptimizing);
 
 // Keeps data and helper functions for lowering coroutine intrinsics.
 struct LowererBase {
   Module &TheModule;
   LLVMContext &Context;
   PointerType *const Int8Ptr;
   FunctionType *const ResumeFnType;
   ConstantPointerNull *const NullPtr;
struct LLVM_LIBRARY_VISIBILITY Shape {
   coro::ABI ABI;
 
   StructType *FrameTy;
   Align FrameAlign;
   uint64_t FrameSize;
   Instruction *FramePtr;
   BasicBlock *AllocaSpillBlock;
 
-  bool ReuseFrameSlot;
+  bool IsOptimizing;
 
   struct SwitchLoweringStorage {
     SwitchInst *ResumeSwitch;
     AllocaInst *PromiseAlloca;
     BasicBlock *ResumeEntryBlock;
     unsigned IndexField;
     bool HasFinalSuspend;
   };
struct LLVM_LIBRARY_VISIBILITY Shape {
   Value *emitAlloc(IRBuilder<> &Builder, Value *Size, CallGraph *CG) const;
 
   /// Deallocate memory according to the rules of the active lowering.
   ///
   /// \param CG - if non-null, will be updated for the new call
   void emitDealloc(IRBuilder<> &Builder, Value *Ptr, CallGraph *CG) const;
 
   Shape() = default;
-  explicit Shape(Function &F, bool ReuseFrameSlot = false)
-      : ReuseFrameSlot(ReuseFrameSlot) {
+  explicit Shape(Function &F, bool IsOptimizing = false)
+      : IsOptimizing(IsOptimizing) {
     buildFrom(F);
   }
   void buildFrom(Function &F);
 };
 
 void buildCoroutineFrame(Function &F, Shape &Shape);
 CallInst *createMustTailCall(DebugLoc Loc, Function *MustTailCallFn,
                              ArrayRef<Value *> Arguments, IRBuilder<> &);
 } // End namespace coro.
 } // End namespace llvm
 
 #endif

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

 void CoroCloner::salvageDebugInfo() {
   SmallVector<DbgDeclareInst *, 8> Worklist;
   SmallDenseMap<llvm::Value *, llvm::AllocaInst *, 4> DbgPtrAllocaCache;
   for (auto &BB : *NewF)
     for (auto &I : BB)
       if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
         Worklist.push_back(DDI);
   for (DbgDeclareInst *DDI : Worklist)
-    coro::salvageDebugInfo(DbgPtrAllocaCache, DDI);
+    coro::salvageDebugInfo(DbgPtrAllocaCache, DDI, Shape.IsOptimizing);
 
   // Remove all salvaged dbg.declare intrinsics that became
   // either unreachable or stale due to the CoroSplit transformation.
   auto IsUnreachableBlock = [&](BasicBlock *BB) {
     return BB->hasNPredecessors(0) && BB != &NewF->getEntryBlock();
   };
   for (DbgDeclareInst *DDI : Worklist) {
+    auto *Storage = DDI->getAddress();
+    if (isa<Argument>(Storage)) {
+      auto &Entry = NewF->getEntryBlock();
+      auto *InsertPt = Entry.getFirstNonPHI();
+      DDI->moveAfter(InsertPt);
+      continue;
+    }
+
     if (IsUnreachableBlock(DDI->getParent()))
       DDI->eraseFromParent();
     else if (dyn_cast_or_null<AllocaInst>(DDI->getAddress())) {
       // Count all non-debuginfo uses in reachable blocks.
       unsigned Uses = 0;
       for (auto *User : DDI->getAddress()->users())
         if (auto *I = dyn_cast<Instruction>(User))
           if (!isa<AllocaInst>(I) && !IsUnreachableBlock(I->getParent()))
void print(raw_ostream &OS) const override {
       F.printAsOperand(OS, /*print type*/ false, F.getParent());
       OS << "\n";
     }
   };
 }
 
 static coro::Shape splitCoroutine(Function &F,
                                   SmallVectorImpl<Function *> &Clones,
-                                  bool ReuseFrameSlot) {
+                                  bool IsOptimizing) {
   PrettyStackTraceFunction prettyStackTrace(F);
 
   // The suspend-crossing algorithm in buildCoroutineFrame get tripped
   // up by uses in unreachable blocks, so remove them as a first pass.
   removeUnreachableBlocks(F);
 
-  coro::Shape Shape(F, ReuseFrameSlot);
+  coro::Shape Shape(F, IsOptimizing);
   if (!Shape.CoroBegin)
     return Shape;
 
   simplifySuspendPoints(Shape);
   buildCoroutineFrame(F, Shape);
   replaceFrameSize(Shape);
 
   // If there are no suspend points, no split required, just remove
if (Value == UNPREPARED_FOR_SPLIT) {
       // Enqueue a second iteration of the CGSCC pipeline on this SCC.
       UR.CWorklist.insert(&C);
       F.addFnAttr(CORO_PRESPLIT_ATTR, PREPARED_FOR_SPLIT);
       continue;
     }
     F.removeFnAttr(CORO_PRESPLIT_ATTR);
 
     SmallVector<Function *, 4> Clones;
-    const coro::Shape Shape = splitCoroutine(F, Clones, ReuseFrameSlot);
+    const coro::Shape Shape = splitCoroutine(F, Clones, IsOptimizing);
     updateCallGraphAfterCoroutineSplit(*N, Shape, Clones, C, CG, AM, UR, FAM);
 
     if ((Shape.ABI == coro::ABI::Async || Shape.ABI == coro::ABI::Retcon ||
          Shape.ABI == coro::ABI::RetconOnce) &&
         !Shape.CoroSuspends.empty()) {
       // Run the CGSCC pipeline on the newly split functions.
       // All clones will be in the same RefSCC, so choose a random clone.
       UR.RCWorklist.insert(CG.lookupRefSCC(CG.get(*Clones[0])));

 // eligible to be inlined into its callers, we split up the coroutine into parts
 // corresponding to initial, resume and destroy invocations of the coroutine,
 // add them to the current SCC and restart the IPO pipeline to optimize the
 // coroutine subfunctions we extracted before proceeding to the caller of the
 // coroutine.
 struct CoroSplitLegacy : public CallGraphSCCPass {
   static char ID; // Pass identification, replacement for typeid
 
-  CoroSplitLegacy(bool ReuseFrameSlot = false)
-      : CallGraphSCCPass(ID), ReuseFrameSlot(ReuseFrameSlot) {
+  CoroSplitLegacy(bool IsOptimizing = false)
+      : CallGraphSCCPass(ID), IsOptimizing(IsOptimizing) {
     initializeCoroSplitLegacyPass(*PassRegistry::getPassRegistry());
   }
 
   bool Run = false;
-  bool ReuseFrameSlot;
+  bool IsOptimizing;
 
   // A coroutine is identified by the presence of coro.begin intrinsic, if
   // we don't have any, this pass has nothing to do.
   bool doInitialization(CallGraph &CG) override {
     Run = declaresCoroSplitIntrinsics(CG.getModule());
     return CallGraphSCCPass::doInitialization(CG);
   }
 
for (Function *F : Coroutines) {
       }
       if (Value == UNPREPARED_FOR_SPLIT) {
         prepareForSplit(*F, CG);
         continue;
       }
       F->removeFnAttr(CORO_PRESPLIT_ATTR);
 
       SmallVector<Function *, 4> Clones;
-      const coro::Shape Shape = splitCoroutine(*F, Clones, ReuseFrameSlot);
+      const coro::Shape Shape = splitCoroutine(*F, Clones, IsOptimizing);
       updateCallGraphAfterCoroutineSplit(*F, Shape, Clones, CG, SCC);
       if (Shape.ABI == coro::ABI::Async) {
         // Restart SCC passes.
         // Mark function for CoroElide pass. It will devirtualize causing a
         // restart of the SCC pipeline.
         prepareForSplit(*F, CG, true /*MarkForAsyncRestart*/);
       }
     }
INITIALIZE_PASS_BEGIN(
     "Split coroutine into a set of functions driving its state machine", false,
     false)
 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_END(
     CoroSplitLegacy, "coro-split",
     "Split coroutine into a set of functions driving its state machine", false,
     false)
 
-Pass *llvm::createCoroSplitLegacyPass(bool ReuseFrameSlot) {
-  return new CoroSplitLegacy(ReuseFrameSlot);
+Pass *llvm::createCoroSplitLegacyPass(bool IsOptimizing) {
+  return new CoroSplitLegacy(IsOptimizing);
 }

llvm/test/Transforms/Coroutines/coro-debug-O2.ll

+; RUN: opt < %s -coro-early -coro-split -enable-coroutine-optimization -coro-split -sroa -S | FileCheck %s
+
+; Checks whether the dbg.declare for `__promise` remains valid under O2.
+
+; CHECK-LABEL: define internal fastcc void @f.resume({{.*}})
+; CHECK:       entry.resume:
+; CHECK:        call void @llvm.dbg.declare(metadata %f.Frame* %FramePtr, metadata ![[PROMISEVAR_RESUME:[0-9]+]], metadata !DIExpression(
+;
+; CHECK: ![[PROMISEVAR_RESUME]] = !DILocalVariable(name: "__promise"
+%promise_type = type { i32, i32, double }
+
+define void @f() !dbg !8 {
+entry:
+    %__promise = alloca %promise_type, align 8
+    %0 = bitcast %promise_type* %__promise to i8*
+    %id = call token @llvm.coro.id(i32 16, i8* %0, i8* null, i8* null)
+    %alloc = call i1 @llvm.coro.alloc(token %id)
+    br i1 %alloc, label %coro.alloc, label %coro.init
+
+coro.alloc:                                       ; preds = %entry
+    %size = call i64 @llvm.coro.size.i64()
+    %memory = call i8* @new(i64 %size)
+    br label %coro.init
+
+coro.init:                                        ; preds = %coro.alloc, %entry
+    %phi.entry.alloc = phi i8* [ null, %entry ], [ %memory, %coro.alloc ]
+    %begin = call i8* @llvm.coro.begin(token %id, i8* %phi.entry.alloc)
+    call void @llvm.dbg.declare(metadata %promise_type* %__promise, metadata !6, metadata !DIExpression()), !dbg !18
+    %i.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 0
+    store i32 1, i32* %i.i, align 8
+    %j.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 1
+    store i32 2, i32* %j.i, align 4
+    %k.i = getelementptr inbounds %promise_type, %promise_type* %__promise, i64 0, i32 2
+    store double 3.000000e+00, double* %k.i, align 8
+    %ready = call i1 @await_ready()
+    br i1 %ready, label %init.ready, label %init.suspend
+
+init.suspend:                                     ; preds = %coro.init
+    %save = call token @llvm.coro.save(i8* null)
+    call void @await_suspend()
+    %suspend = call i8 @llvm.coro.suspend(token %save, i1 false)
+    switch i8 %suspend, label %coro.ret [
+        i8 0, label %init.ready
+        i8 1, label %init.cleanup
+    ]
+
+init.cleanup:                                     ; preds = %init.suspend
+    br label %cleanup
+
+init.ready:                                       ; preds = %init.suspend, %coro.init
+    call void @await_resume()
+    %ready.again = call zeroext i1 @await_ready()
+    br i1 %ready.again, label %await.ready, label %await.suspend
+
+await.suspend:                                    ; preds = %init.ready
+    %save.again = call token @llvm.coro.save(i8* null)
+    %from.address = call i8* @from_address(i8* %begin)
+    call void @await_suspend()
+    %suspend.again = call i8 @llvm.coro.suspend(token %save.again, i1 false)
+    switch i8 %suspend.again, label %coro.ret [
+        i8 0, label %await.ready
+        i8 1, label %await.cleanup
+    ]
+
+await.cleanup:                                    ; preds = %await.suspend
+    br label %cleanup
+
+await.ready:                                      ; preds = %await.suspend, %init.ready
+    call void @await_resume()
+    call void @return_void()
+    br label %coro.final
+
+coro.final:                                       ; preds = %await.ready
+    call void @final_suspend()
+    %coro.final.await_ready = call i1 @await_ready()
+    br i1 %coro.final.await_ready, label %final.ready, label %final.suspend
+
+final.suspend:                                    ; preds = %coro.final
+    %final.suspend.coro.save = call token @llvm.coro.save(i8* null)
+    %final.suspend.from_address = call i8* @from_address(i8* %begin)
+    call void @await_suspend()
+    %final.suspend.coro.suspend = call i8 @llvm.coro.suspend(token %final.suspend.coro.save, i1 true)
+    switch i8 %final.suspend.coro.suspend, label %coro.ret [
+        i8 0, label %final.ready
+        i8 1, label %final.cleanup
+    ]
+
+final.cleanup:                                    ; preds = %final.suspend
+    br label %cleanup
+
+final.ready:                                      ; preds = %final.suspend, %coro.final
+    call void @await_resume()
+    br label %cleanup
+
+cleanup:                                          ; preds = %final.ready, %final.cleanup, %await.cleanup, %init.cleanup
+    %cleanup.dest.slot.0 = phi i32 [ 0, %final.ready ], [ 2, %final.cleanup ], [ 2, %await.cleanup ], [ 2, %init.cleanup ]
+    %free.memory = call i8* @llvm.coro.free(token %id, i8* %begin)
+    %free = icmp ne i8* %free.memory, null
+    br i1 %free, label %coro.free, label %after.coro.free
+
+coro.free:                                        ; preds = %cleanup
+    call void @delete(i8* %free.memory)
+    br label %after.coro.free
+
+after.coro.free:                                  ; preds = %coro.free, %cleanup
+    switch i32 %cleanup.dest.slot.0, label %unreachable [
+        i32 0, label %cleanup.cont
+        i32 2, label %coro.ret
+    ]
+
+cleanup.cont:                                     ; preds = %after.coro.free
+    br label %coro.ret
+
+coro.ret:                                         ; preds = %cleanup.cont, %after.coro.free, %final.suspend, %await.suspend, %init.suspend
+    %end = call i1 @llvm.coro.end(i8* null, i1 false)
+    ret void
+
+unreachable:                                      ; preds = %after.coro.free
+    unreachable
+
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
+declare i1 @llvm.coro.alloc(token)
+declare i64 @llvm.coro.size.i64()
+declare token @llvm.coro.save(i8*)
+declare i8* @llvm.coro.begin(token, i8* writeonly)
+declare i8 @llvm.coro.suspend(token, i1)
+declare i8* @llvm.coro.free(token, i8* nocapture readonly)
+declare i1 @llvm.coro.end(i8*, i1)
+
+declare i8* @new(i64)
+declare void @delete(i8*)
+declare i1 @await_ready()
+declare void @await_suspend()
+declare void @await_resume()
+declare void @print(i32)
+declare i8* @from_address(i8*)
+declare void @return_void()
+declare void @final_suspend()
+
+!llvm.dbg.cu = !{!0}
+!llvm.linker.options = !{}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 11.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "coro-debug.cpp", directory: ".")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 11.0.0"}
+!6 = !DILocalVariable(name: "__promise", scope: !7, file: !1, line: 24, type: !10)
+!7 = distinct !DILexicalBlock(scope: !8, file: !1, line: 23, column: 12)
+!8 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !8, file: !1, line: 23, type: !9, scopeLine: 23, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!9 = !DISubroutineType(types: !2)
+!10 = !DIDerivedType(tag: DW_TAG_typedef, name: "promise_type", scope: !8, file: !1, line: 15, baseType: !11)
+!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "promise_type", scope: !8, file: !1, line: 10, size: 128, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !12, identifier: "_ZTSN4coro12promise_typeE")
+!12 = !{!13, !14, !15}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !8, file: !1, line: 10, baseType: !16, size: 32)
+!14 = !DIDerivedType(tag: DW_TAG_member, name: "j", scope: !8, file: !1, line: 10, baseType: !16, size: 32, offset: 32)
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "k", scope: !8, file: !1, line: 10, baseType: !17, size: 64, offset: 64)
+!16 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!17 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!18 = !DILocation(line: 0, scope: !7)
+
+
+
+
+
+

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-00.ll

 ; Check that we can handle spills of array allocas
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
-; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
+; RUN: opt < %s -coro-split -enable-coroutine-optimization -S | FileCheck %s
+; RUN: opt < %s -passes=coro-split -enable-coroutine-optimization -S | FileCheck %s
 
 %struct.big_structure = type { [500 x i8] }
 declare void @consume(%struct.big_structure*)
 
 ; Function Attrs: noinline optnone uwtable
 define i8* @f(i1 %cond) "coroutine.presplit"="1" {
 entry:
   %data = alloca %struct.big_structure, align 1

 declare i1 @llvm.coro.end(i8*, i1)
 
 declare noalias i8* @malloc(i32)
 declare double @print(double)
 declare void @free(i8*)
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 No newline at end of file

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-01.ll

 ; Tests that variables in a Corotuine whose lifetime range is not overlapping each other
 ; re-use the same slot in Coroutine frame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
-; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
+; RUN: opt < %s -coro-split -enable-coroutine-optimization -S | FileCheck %s
+; RUN: opt < %s -passes=coro-split -enable-coroutine-optimization -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 define void @a(i1 zeroext %cond) "coroutine.presplit"="1" {
 entry:
   %__promise = alloca %"struct.task::promise_type", align 1

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-02.ll

 ; Tests that variables of different type in a Corotuine whose lifetime range is not overlapping each other
 ; re-use the same slot in Coroutine frame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
-; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
+; RUN: opt < %s -coro-split -enable-coroutine-optimization -S | FileCheck %s
+; RUN: opt < %s -passes=coro-split -enable-coroutine-optimization -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [300 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)
 define void @a(i1 zeroext %cond) "coroutine.presplit"="1" {

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-04.ll

 ; Tests that variables of different type with incompatible alignment in a Corotuine whose lifetime 
 ; range is not overlapping each other should not re-use the same slot in Coroutine frame. 
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
-; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
+; RUN: opt < %s -coro-split -enable-coroutine-optimization -S | FileCheck %s
+; RUN: opt < %s -passes=coro-split -enable-coroutine-optimization -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [300 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)
 define void @a(i1 zeroext %cond) "coroutine.presplit"="1" {

llvm/test/Transforms/Coroutines/coro-frame-reuse-alloca-05.ll

 ; Tests that variables of different type with incompatible alignment in a Corotuine whose 
 ; lifetime range is not overlapping each other re-use the same slot in CorotuineFrame.
-; RUN: opt < %s -coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
-; RUN: opt < %s -passes=coro-split -reuse-storage-in-coroutine-frame -S | FileCheck %s
+; RUN: opt < %s -coro-split -enable-coroutine-optimization -S | FileCheck %s
+; RUN: opt < %s -passes=coro-split -enable-coroutine-optimization -S | FileCheck %s
 %"struct.task::promise_type" = type { i8 }
 %struct.awaitable = type { i8 }
 %struct.big_structure = type { [500 x i8] }
 %struct.big_structure.2 = type { [400 x i8] }
 declare i8* @malloc(i64)
 declare void @consume(%struct.big_structure*)
 declare void @consume.2(%struct.big_structure.2*)
 define void @a(i1 zeroext %cond) "coroutine.presplit"="1" {