[Coroutines] Look for dbg.declare for temp spills

[weiwang]

Summary

A temp spill may not have direct dbg.declare attached. This can cause problem for debugger when it wants to print the value in resume/destroy/cleanup functions.

In particular, we found this happening to "this" pointer that a temp is used to store its value in entry block and spilled later.

[ChuanqiXu]

In fact, we did similar things in the downstream too. But we didn't contribute it since we feel it might not be so good. Since it is a little bit dirty and it is natural that the debug information is missing. If you still want to do this, I feel CoroCloner::salvageDebugInfo() may be a better place.

[weiwang]

In D146543#4211913, @ChuanqiXu wrote:

In fact, we did similar things in the downstream too. But we didn't contribute it since we feel it might not be so good. Since it is a little bit dirty and it is natural that the debug information is missing. If you still want to do this, I feel CoroCloner::salvageDebugInfo() may be a better place.

Ha, I was wonder why nobody reported this issue before :)

For us, we've seen that "this" pointer debug info is gone after the first suspension point. And there are quite some reports internally, so this is really hurting the debug experiences. The current proposal is very specific to the "this" pointer problem we have. For some reason the "this" pointer is stored into some temp reg at entry block which complicates the look-up of dbg.declare. For example, in https://godbolt.org/z/q3rP77919

define linkonce_odr dso_local ptr @_ZN9Container3fooEi(ptr noundef nonnull align 4 dereferenceable(4) %this, i32 noundef %arg)
entry:
  %this.addr = alloca ptr, align 8
  %arg.addr = alloca i32, align 4
  %arg2 = alloca i32, align 4
  ... ...
  store ptr %this, ptr %this.addr, align 8
  call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !658, metadata !DIExpression()), !dbg !660
  store i32 %arg, ptr %arg.addr, align 4
  call void @llvm.dbg.declare(metadata ptr %arg.addr, metadata !661, metadata !DIExpression()), !dbg !662
  %this1 = load ptr, ptr %this.addr, align 8

coro.init:
  call void @llvm.lifetime.start.p0(i64 4, ptr %arg2) #5, !dbg !665
  call void @llvm.dbg.declare(metadata ptr %arg2, metadata !661, metadata !DIExpression()), !dbg !660
  %6 = load i32, ptr %arg.addr, align 4, !dbg !665
  store i32 %6, ptr %arg2, align 4, !dbg !665

There is no use of %this.addr after this, so %this or %this.addr won't be in coro frame, but %this1 is.

A side note: the other function parameter arg is stored into an alloca %args2, which has a dbg.declare. Not sure why frontend treats them differently. If this1 is an alloca instead of a temp, it could already have a dbg.declare. Maybe this is another angle.

Anyway, I feel that in order to have the same level of debug info availability as its non-async counterparts, coroutine function needs to make sure debug info of frame lived value is preserved across suspension points if that value maps to a source variable. From the examples I've seen, I think allocas are generally fine here. They usually come with needed debug info. And most temps do not map to source variable, no need of debug info. That comes down to those temps that map to source variable.

Does your downstream patch address the same issue? Maybe we can consolidate here.

The reason I put the change in coro::buildCoroutineFrame before spilt happens is that the missing dbg.declare can be created at the reload site so that after split and in CoroCloner::salvageDebugInfo, it would automatically be converted to a dbg.declare of DEREF from frame offset. And we only need to do that once in the original function. So this from the original function (dbg.declare is created in coro::buildCoroutineFrame)

%this1.reload.addr = getelementptr inbounds %_ZN9Container3fooEi.Frame, ptr %0, i32 0, i32 4, !dbg !1794
%this1.reload = load ptr, ptr %this1.reload.addr, align 8, !dbg !1794
call void @llvm.dbg.declare(metadata ptr %this1.reload, metadata !1779, metadata !DIExpression()), !dbg !1780

becomes

call void @llvm.dbg.declare(metadata ptr %.debug, metadata !1781, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 32)), !dbg !1783

in the entry block of resume/destroy/cleanup function.

This seems to be the most direct way of adding the missing debug info, but if there is a better way, please advise.

[ChuanqiXu]

Does your downstream patch address the same issue? Maybe we can consolidate here.

Oh, not exactly. It looks like you're saving the debug information under O0. While we're trying to save the debug information within optimization, which might not be so natural. And it looks like the problem occurs within opaque pointer and our downstream compiler didn't start to use opaque pointer yet. So in another word, this should be regression bug if I understand things correctly.

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

1850–1860

We handled similar thing in https://github.com/llvm/llvm-project/blob/47bff1cc46b5de96841fd1592df0c828e1d38e35/llvm/lib/Transforms/Coroutines/CoroFrame.cpp#L2815-L2825. Let's handle this there too to avoid redundant code.

[weiwang]

In D146543#4215777, @ChuanqiXu wrote:

Does your downstream patch address the same issue? Maybe we can consolidate here.

Oh, not exactly. It looks like you're saving the debug information under O0. While we're trying to save the debug information within optimization, which might not be so natural. And it looks like the problem occurs within opaque pointer and our downstream compiler didn't start to use opaque pointer yet. So in another word, this should be regression bug if I understand things correctly.

Yeah, we generally use -O0 for better debugging experiences. The issue was first reported from our internal release, which is based on clang-12, so I think it exists before and after opaque pointer. My plan is to fix upstream and then backport.

[ChuanqiXu]

In D146543#4217194, @weiwang wrote:

In D146543#4215777, @ChuanqiXu wrote:

Does your downstream patch address the same issue? Maybe we can consolidate here.

Oh, not exactly. It looks like you're saving the debug information under O0. While we're trying to save the debug information within optimization, which might not be so natural. And it looks like the problem occurs within opaque pointer and our downstream compiler didn't start to use opaque pointer yet. So in another word, this should be regression bug if I understand things correctly.

Yeah, we generally use -O0 for better debugging experiences. The issue was first reported from our internal release, which is based on clang-12, so I think it exists before and after opaque pointer. My plan is to fix upstream and then backport.

Got it. But let's first try to handle it in coro::salvageDebugInfo() to make the code smell better.

[weiwang]

In D146543#4218316, @ChuanqiXu wrote:

In D146543#4217194, @weiwang wrote:

In D146543#4215777, @ChuanqiXu wrote:

Does your downstream patch address the same issue? Maybe we can consolidate here.

Oh, not exactly. It looks like you're saving the debug information under O0. While we're trying to save the debug information within optimization, which might not be so natural. And it looks like the problem occurs within opaque pointer and our downstream compiler didn't start to use opaque pointer yet. So in another word, this should be regression bug if I understand things correctly.

Yeah, we generally use -O0 for better debugging experiences. The issue was first reported from our internal release, which is based on clang-12, so I think it exists before and after opaque pointer. My plan is to fix upstream and then backport.

Got it. But let's first try to handle it in coro::salvageDebugInfo() to make the code smell better.

I took a look at coro::salvageDebugInfo(), but can't find an easy way to handle my case there.

In particular, I have the following code, in which the dbg.declare is for %this.addr, and its alias %this1 is spilled.

%this.addr = alloca ptr, align 8
call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !658, metadata !DIExpression()), !dbg !660
%this1 = load ptr, ptr %this.addr, align 8
... ...
; spill
%this1.spill.addr = getelementptr inbounds %_ZN9Container3fooEi.Frame, ptr %0, i32 0, i32 4, !dbg !1782
store ptr %this1, ptr %this1.spill.addr, align 8, !dbg !1782
.. ...
; reload
%this1.reload.addr = getelementptr inbounds %_ZN9Container3fooEi.Frame, ptr %0, i32 0, i32 4, !dbg !1794
%this1.reload = load ptr, ptr %this1.reload.addr, align 8, !dbg !1794

And I need to update the dbg.declare to describe the reload GEP %this1.reload.addr, something like

call void @llvm.dbg.declare(metadata ptr %this1.reload.addr, metadata !658, metadata !DIExpression(DW_OP_plus_uconst, 32)), !dbg !660

Under -O0, it would be

call void @llvm.dbg.declare(metadata ptr %frame, metadata !658, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 32)), !dbg !660

And if the spill has multiple reloads, I'll need one dbg.declare for every reload.

In coro::salvageDebugInfo(), I'll need to trace from %this.addr to its reload GEP %this1.reload.addr. I feel I need to have an extra struct to record spill to its reloads (probably when the reloads are created in insertSpills()). Also since I don't know if an alloca is an alias of a spill and leads to a reload GEP (such information is easier to get in insertSpills()), I'll have to do such check on every alloca, which is extra overhead.

Any suggestions?

[ChuanqiXu]

Oh, you're right. It is indeed easier to handle them in the early place.

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

1853

Let's add a fast check here to avoid fall in loop if the program is not compiled with debug information.

[weiwang]

1. Rebase
2. Add check of function has debug info or not before going into the loop.

[weiwang]

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

1853

Good catch! Updated.

[fdeazeve]

While debugging a crash in the compiler (see my comment about GlobalVariable) below, I found this patch and I am struggling to understand if we are doing the right thing here.

Besides the crash, I am not sure this patch is correct with respect to the debug intrinsics. Consider this:

%indirect_storage = ptr ...
%AliveAccrossAplit = load ptr %indirect_storage
call void llvm.dbg.declare(%indirect_storage, ...)

... split point ...

use %UseAliveAccrossAplit

With this patch, we rewrite the above into:

%indirect_storage = ptr ...
%AliveAccrossSplit = load ptr %indirect_storage
call void llvm.dbg.declare(%indirect_storage, !MyVar, ...)

... split point ...

%reload = ... reload of %AliveAccrossSplit inside the coroutine frame ...
call void llvm.dbg.declare(%reload, !MyVar, ...)

Note that the dbg.declare after the rewrite is *not* equivalent to the original intrinsic: we are now claiming the address of !MyVar is %reload, and %reload == %AliveAccrossSplit.

Does this make sense? In fact, the debug instruction that is being created doesn't even show up in the test added by this patch. If we run this test on a debugger and put a breakpoint in this line:

-> 1881           coro::salvageDebugInfo(ArgToAllocaMap, DDI, Shape.OptimizeFrame,
   1882                                  false /*UseEntryValue*/);

We should this:

(lldb) p CurrentBlock->dump()

resume:                                           ; preds = %AfterCoroSuspend
  %this1.reload.addr = getelementptr inbounds %foo.Frame, ptr %hdl, i32 0, i32 4
  %this1.reload = load ptr, ptr %this1.reload.addr, align 8
  call void @llvm.dbg.declare(metadata ptr %this1.reload, metadata !34, metadata !DIExpression()), !dbg !36
  call void @bar(ptr %this1)
  br label %cleanup

Note that this dbg.declare doesn't survive the end of this test (it is not in the final output).

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

1852

I'm not sure alias is the right term here: if we walk up a load chain, we are not finding aliases, instead we're adding levels of pointer indirections. These pointers don't alias, they point to different addresses.

1858

What is this load trying to check? LdInst->getPointerOperandType() always returns the type ptr.
This is the same as if(!isa<PointerType<(LdInst->getType()), was this the intention?

I was a bit confused with the wording of the comment about, would appreciate your help rewording it.

1861

Note that this will crash the compiler if CurDef is a GlobalVariable.

[weiwang]

In D146543#4655197, @fdeazeve wrote:

While debugging a crash in the compiler (see my comment about GlobalVariable) below, I found this patch and I am struggling to understand if we are doing the right thing here.

Besides the crash, I am not sure this patch is correct with respect to the debug intrinsics. Consider this:

%indirect_storage = ptr ...
%AliveAccrossAplit = load ptr %indirect_storage
call void llvm.dbg.declare(%indirect_storage, ...)

... split point ...

use %UseAliveAccrossAplit

With this patch, we rewrite the above into:

%indirect_storage = ptr ...
%AliveAccrossSplit = load ptr %indirect_storage
call void llvm.dbg.declare(%indirect_storage, !MyVar, ...)

... split point ...

%reload = ... reload of %AliveAccrossSplit inside the coroutine frame ...
call void llvm.dbg.declare(%reload, !MyVar, ...)

Note that the dbg.declare after the rewrite is *not* equivalent to the original intrinsic: we are now claiming the address of !MyVar is %reload, and %reload == %AliveAccrossSplit.

Does this make sense? In fact, the debug instruction that is being created doesn't even show up in the test added by this patch. If we run this test on a debugger and put a breakpoint in this line:

-> 1881           coro::salvageDebugInfo(ArgToAllocaMap, DDI, Shape.OptimizeFrame,
   1882                                  false /*UseEntryValue*/);

We should this:

(lldb) p CurrentBlock->dump()

resume:                                           ; preds = %AfterCoroSuspend
  %this1.reload.addr = getelementptr inbounds %foo.Frame, ptr %hdl, i32 0, i32 4
  %this1.reload = load ptr, ptr %this1.reload.addr, align 8
  call void @llvm.dbg.declare(metadata ptr %this1.reload, metadata !34, metadata !DIExpression()), !dbg !36
  call void @bar(ptr %this1)
  br label %cleanup

Note that this dbg.declare doesn't survive the end of this test (it is not in the final output).

I'm fairly sure that if we revert this patch and rerun the test, it will still pass.

Thanks for the comment. Yeah, I think there are issues with the change here. And the wording of "alias" is misleading.

The issue that this change specifically tries to fix is that, we saw the debug info for "this" pointer no loner exists after coroutine resumes. i.e. https://godbolt.org/z/sWxa4f94j, we can print "this" in lldb at line 24, but not at line 26. This is because "this" is stored into a temp that does not have debug info.

define ptr @foo(ptr noundef nonnull align 1 dereferenceable(1) %this) !dbg !11 {
entry:
  %this.addr = alloca ptr, align 8
  call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !34, metadata !DIExpression()), !dbg !36
  %__promise = alloca i8, align 1
  call void @llvm.dbg.declare(metadata ptr %__promise, metadata !37, metadata !DIExpression()), !dbg !36
  store ptr %this, ptr %this.addr, align 8
  %this1 = load ptr, ptr %this.addr, align 8

... ...

PostSpill:                                        ; preds = %AllocaSpillBB
  %this1.spill.addr = getelementptr inbounds %foo.Frame, ptr %hdl, i32 0, i32 4
  store ptr %this1, ptr %this1.spill.addr, align 8

So this change walks up the pointer Deref chain and tries to find the llvm.dbg.declare for %this.addr and use it for the temp %this1.

In the test included with the change.

Before:

define internal fastcc void @foo.resume(ptr noundef nonnull align 8 dereferenceable(32) %hdl) !dbg !38 {
entry.resume:
  %hdl.debug = alloca ptr, align 8
  call void @llvm.dbg.declare(metadata ptr %hdl.debug, metadata !40, metadata !DIExpression(DW_OP_deref)), !dbg !41

... ...

!40 = !DILocalVariable(name: "__coro_frame", scope: !38, file: !1, type: !22, flags: DIFlagArtificial)

After:

define internal fastcc void @foo.resume(ptr noundef nonnull align 8 dereferenceable(32) %hdl) !dbg !38 {
entry.resume:
  %hdl.debug = alloca ptr, align 8
  call void @llvm.dbg.declare(metadata ptr %hdl.debug, metadata !41, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 24)), !dbg !42
  call void @llvm.dbg.declare(metadata ptr %hdl.debug, metadata !40, metadata !DIExpression(DW_OP_deref)), !dbg !42

... ...

!40 = !DILocalVariable(name: "__coro_frame", scope: !38, file: !1, type: !22, flags: DIFlagArtificial)
!41 = !DILocalVariable(name: "this", arg: 1, scope: !38, type: !35, flags: DIFlagArtificial | DIFlagObjectPointer)

Note that this will crash the compiler if CurDef is a GlobalVariable.

You are right, and we also observed the crash and fixed in https://reviews.llvm.org/D157423. Since the original change is targeting a very specific case, the fix puts more restriction on the case it can affect.

Do you have any suggestions on how can we make it more generic and applicable to more use cases?

[fdeazeve]

Thank you for the quick response!

Note that this will crash the compiler if CurDef is a GlobalVariable.

You are right, and we also observed the crash and fixed in https://reviews.llvm.org/D157423. Since the original change is targeting a very specific case, the fix puts more restriction on the case it can affect.

Thank you for the pointers, glad to hear it was fixed in a subsequent commit. I was working on a slightly older version of the codebase.

Do you have any suggestions on how can we make it more generic and applicable to more use cases?

After:

define internal fastcc void @foo.resume(ptr noundef nonnull align 8 dereferenceable(32) %hdl) !dbg !38 {
entry.resume:
  %hdl.debug = alloca ptr, align 8
  call void @llvm.dbg.declare(metadata ptr %hdl.debug, metadata !41, metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 24)), !dbg !42
  call void @llvm.dbg.declare(metadata ptr %hdl.debug, metadata !40, metadata !DIExpression(DW_OP_deref)), !dbg !42

... ...

!40 = !DILocalVariable(name: "__coro_frame", scope: !38, file: !1, type: !22, flags: DIFlagArtificial)
!41 = !DILocalVariable(name: "this", arg: 1, scope: !38, type: !35, flags: DIFlagArtificial | DIFlagObjectPointer)

I understand the problem the patch is solving, but I haven't been able to figure out how we are going from that dbg.declare that I mentioned to the one that ends up in the final output of the compiler. Do you see the problem that I was trying to point to? The _first_ dbg.declare that we create -- the one shown in the output of p CurrentBlock->dump()-- is not equivalent to the original dbg.declare. And yet, somehow, this "invalid" dbg.declare disappears and the correct one shows up later. To be very specific, when we do:

DIBuilder(*CurrentBlock->getParent()->getParent(), AllowUnresolved)
              .insertDeclare(CurrentReload, DDI->getVariable(),
                             DDI->getExpression(), DDI->getDebugLoc(),
                             &*Builder.GetInsertPoint());

The CurrentReload argument seems incorrect if we stripped some of the loads along the way. Does that make sense?

[weiwang]

In D146543#4655210, @fdeazeve wrote:

I understand the problem the patch is solving, but I haven't been able to figure out how we are going from that dbg.declare that I mentioned to the one that ends up in the final output of the compiler. Do you see the problem that I was trying to point to? The _first_ dbg.declare that we create -- the one shown in the output of p CurrentBlock->dump()-- is not equivalent to the original dbg.declare. And yet, somehow, this "invalid" dbg.declare disappears and the correct one shows up later. To be very specific, when we do:

DIBuilder(*CurrentBlock->getParent()->getParent(), AllowUnresolved)
              .insertDeclare(CurrentReload, DDI->getVariable(),
                             DDI->getExpression(), DDI->getDebugLoc(),
                             &*Builder.GetInsertPoint());

The CurrentReload argument seems incorrect if we stripped some of the loads along the way. Does that make sense?

I think the reason is that the reload %this1.reload is after a suspend point, so the DbgDeclareInst (DDI) is unreachable from the ramp function and removed later. But since it is reachable in resume and destroy copies, it shows up there.

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

 //
 //  PostSpill:
 //    whatever
 //
 //
 static void insertSpills(const FrameDataInfo &FrameData, coro::Shape &Shape) {
   auto *CB = Shape.CoroBegin;
   LLVMContext &C = CB->getContext();
+  Function *F = CB->getFunction();
   IRBuilder<> Builder(C);
   StructType *FrameTy = Shape.FrameTy;
   Value *FramePtr = Shape.FramePtr;
-  DominatorTree DT(*CB->getFunction());
+  DominatorTree DT(*F);
   SmallDenseMap<llvm::Value *, llvm::AllocaInst *, 4> DbgPtrAllocaCache;
 
   // Create a GEP with the given index into the coroutine frame for the original
   // value Orig. Appends an extra 0 index for array-allocas, preserving the
   // original type.
   auto GetFramePointer = [&](Value *Orig) -> Value * {
     FieldIDType Index = FrameData.getFieldIndex(Orig);
     SmallVector<Value *, 3> Indices = {
for (auto *U : E.second) {
         if (ByValTy)
           CurrentReload = GEP;
         else
           CurrentReload = Builder.CreateAlignedLoad(
               FrameTy->getElementType(FrameData.getFieldIndex(E.first)), GEP,
               SpillAlignment, E.first->getName() + Twine(".reload"));
 
         TinyPtrVector<DbgDeclareInst *> DIs = FindDbgDeclareUses(Def);
+        // Try best to find dbg.declare. If the spill is a temp, there may not
+        // be a direct dbg.declare. Walk up the load chain to find one from an
+        // alias.
+        if (F->getSubprogram()) {
+          auto *CurDef = Def;
+          while (DIs.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();
+            DIs = FindDbgDeclareUses(CurDef);
+          }
+        }
+
         for (DbgDeclareInst *DDI : DIs) {
           bool AllowUnresolved = false;
           // This dbg.declare is preserved for all coro-split function
           // 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(),

llvm/test/Transforms/Coroutines/coro-debug-spill-dbg.declare.ll

+; Test spilling a temp generates dbg.declare in resume/destroy/cleanup functions.
+;
+; RUN: opt < %s -passes='cgscc(coro-split)' -S | FileCheck %s
+;
+; The test case simulates a coroutine method in a class.
+;
+; class Container {
+;  public:
+;    Container() : field(12) {}
+;    Task foo() {
+;      co_await std::suspend_always{};
+;      auto *copy = this;
+;      co_return;
+;    }
+;    int field;
+; };
+;
+; We want to make sure that the "this" pointer is accessable in debugger before and after the suspension point.
+;
+; CHECK: define internal fastcc void @foo.resume(ptr noundef nonnull align 8 dereferenceable(32) %[[HDL:.*]])
+; CHECK-NEXT: entry.resume:
+; CHECK-NEXT:   %[[HDL]].debug = alloca ptr, align 8
+; CHECK-NEXT:   call void @llvm.dbg.declare(metadata ptr %[[HDL]].debug, metadata ![[THIS_RESUME:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 24))
+;
+; CHECK: define internal fastcc void @foo.destroy(ptr noundef nonnull align 8 dereferenceable(32) %[[HDL]])
+; CHECK-NEXT: entry.destroy:
+; CHECK-NEXT:   %[[HDL]].debug = alloca ptr, align 8
+; CHECK-NEXT:   call void @llvm.dbg.declare(metadata ptr %[[HDL]].debug, metadata ![[THIS_DESTROY:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 24))
+;
+; CHECK: define internal fastcc void @foo.cleanup(ptr noundef nonnull align 8 dereferenceable(32) %[[HDL]])
+; CHECK-NEXT: entry.cleanup:
+; CHECK-NEXT:   %[[HDL]].debug = alloca ptr, align 8
+; CHECK-NEXT:   call void @llvm.dbg.declare(metadata ptr %[[HDL]].debug, metadata ![[THIS_CLEANUP:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 24))
+;
+; CHECK: ![[THIS_RESUME]] = !DILocalVariable(name: "this"
+; CHECK: ![[THIS_DESTROY]] = !DILocalVariable(name: "this"
+; CHECK: ![[THIS_CLEANUP]] = !DILocalVariable(name: "this"
+
+; Function Attrs: presplitcoroutine
+define ptr @foo(ptr noundef nonnull align 1 dereferenceable(1) %this) #0 !dbg !11 {
+entry:
+  %this.addr = alloca ptr, align 8
+  %__promise = alloca i8, align 1
+  store ptr %this, ptr %this.addr, align 8
+  call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !20, metadata !DIExpression()), !dbg !22
+  %this1 = load ptr, ptr %this.addr, align 8
+  %0 = bitcast ptr %__promise to ptr
+  %id = call token @llvm.coro.id(i32 16, ptr %0, ptr null, ptr null)
+  %need.dyn.alloc = call i1 @llvm.coro.alloc(token %id)
+  br i1 %need.dyn.alloc, label %dyn.alloc, label %coro.begin
+
+dyn.alloc:                                        ; preds = %entry
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call ptr @malloc(i32 %size)
+  br label %coro.begin
+
+coro.begin:                                       ; preds = %dyn.alloc, %entry
+  %phi = phi ptr [ null, %entry ], [ %alloc, %dyn.alloc ]
+  %hdl = call ptr @llvm.coro.begin(token %id, ptr %phi)
+  call void @llvm.dbg.declare(metadata ptr %__promise, metadata !23, metadata !DIExpression()), !dbg !22
+  %1 = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %1, label %suspend [
+    i8 0, label %resume
+    i8 1, label %cleanup
+  ]
+
+resume:                                           ; preds = %coro.begin
+  call void @bar(ptr %this1)
+  br label %cleanup
+
+cleanup:                                          ; preds = %resume, %coro.begin
+  %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+  call void @free(ptr %mem)
+  br label %suspend
+
+suspend:                                          ; preds = %cleanup, %coro.begin
+  %2 = call i1 @llvm.coro.end(ptr %hdl, i1 false)
+  ret ptr %hdl
+}
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind memory(argmem: read)
+declare ptr @llvm.coro.free(token, ptr nocapture readonly) #2
+
+; Function Attrs: nounwind memory(none)
+declare i32 @llvm.coro.size.i32() #3
+
+; Function Attrs: nounwind
+declare i8 @llvm.coro.suspend(token, i1) #4
+
+declare void @llvm.coro.resume(ptr)
+
+declare void @llvm.coro.destroy(ptr)
+
+; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read)
+declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr) #5
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.alloc(token) #4
+
+; Function Attrs: nounwind
+declare ptr @llvm.coro.begin(token, ptr writeonly) #4
+
+; Function Attrs: nounwind
+declare i1 @llvm.coro.end(ptr, i1) #4
+
+declare noalias ptr @malloc(i32)
+
+declare void @free(ptr)
+
+declare void @bar(ptr)
+
+attributes #0 = { presplitcoroutine }
+attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #2 = { nounwind memory(argmem: read) }
+attributes #3 = { nounwind memory(none) }
+attributes #4 = { nounwind }
+attributes #5 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
+
+!llvm.dbg.cu = !{!0}
+!llvm.linker.options = !{}
+!llvm.module.flags = !{!3, !4, !5, !6, !7, !8, !9}
+!llvm.ident = !{!10}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 17.0.20210610", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, retainedTypes: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.cpp", directory: ".")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 8, !"PIC Level", i32 2}
+!7 = !{i32 7, !"PIE Level", i32 2}
+!8 = !{i32 7, !"uwtable", i32 2}
+!9 = !{i32 7, !"frame-pointer", i32 2}
+!10 = !{!"clang version 17.0.20210610"}
+!11 = distinct !DISubprogram(name: "foo", linkageName: "_ZN9Container3fooEv", scope: !1, file: !1, line: 20, type: !12, scopeLine: 20, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, declaration: !13, retainedNodes: !2)
+!12 = !DISubroutineType(types: !2)
+!13 = !DISubprogram(name: "foo", linkageName: "_ZN9Container3fooEv", scope: !14, file: !1, line: 20, type: !12, scopeLine: 20, flags: DIFlagPublic | DIFlagPrototyped, spFlags: 0)
+!14 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "Container", file: !1, line: 17, size: 8, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !15, identifier: "_ZTS9Container")
+!15 = !{!16, !13}
+!16 = !DISubprogram(name: "Container", scope: !14, file: !1, line: 19, type: !17, scopeLine: 19, flags: DIFlagPublic | DIFlagPrototyped, spFlags: 0)
+!17 = !DISubroutineType(types: !18)
+!18 = !{null, !19}
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !14, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!20 = !DILocalVariable(name: "this", arg: 1, scope: !11, type: !21, flags: DIFlagArtificial | DIFlagObjectPointer)
+!21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !14, size: 64)
+!22 = !DILocation(line: 0, scope: !11)
+!23 = !DILocalVariable(name: "__promise", scope: !11, type: !24, flags: DIFlagArtificial)
+!24 = !DIDerivedType(tag: DW_TAG_typedef, name: "promise_type", scope: !11, file: !1, line: 40, baseType: !25)
+!25 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "promise_type", scope: !11, file: !1, line: 6, size: 8, flags: DIFlagTypePassByValue, elements: !2, identifier: "_ZTSN4Task12promise_typeE")