[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

1251

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

2195

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

2219

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

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

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

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.ReuseFrameSlot);
         }
       }
 
       // 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 ReuseFrameSlot) {
   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
void coro::salvageDebugInfo(
   }
   if (!Storage)
     return;
 
   // 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 (!ReuseFrameSlot && !EnableReuseStorageInFrame)
+    if (auto *Arg = dyn_cast<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);
     }
   DDI->replaceVariableLocationOp(OriginalStorage, Storage);
   DDI->setExpression(Expr);
-  if (auto *InsertPt = dyn_cast_or_null<Instruction>(Storage))
+  if (auto *InsertPt = dyn_cast<Instruction>(Storage))
     DDI->moveAfter(InsertPt);
+  else if (isa<Argument>(Storage))
+    DDI->moveAfter(F->getEntryBlock().getFirstNonPHI());
 }
 
 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 &&

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 ReuseFrameSlot);
 
 // 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;
 
+  /// This would only be true if optimization are enabled.
   bool ReuseFrameSlot;
 
   struct SwitchLoweringStorage {
     SwitchInst *ResumeSwitch;
     AllocaInst *PromiseAlloca;
     BasicBlock *ResumeEntryBlock;
     unsigned IndexField;
     bool HasFinalSuspend;

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.ReuseFrameSlot);
 
   // 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) {
     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()))
             ++Uses;
       if (!Uses)

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

+; RUN: opt < %s -coro-early -coro-split -reuse-storage-in-coroutine-frame -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)
+
+
+
+
+
+