[Coroutines] Don't mark the parameter attribute of resume function as noalias

[ChuanqiXu]

Summary

Close https://github.com/llvm/llvm-project/issues/59221.

The root cause for the problem is that we marked the parameter of the resume/destroy functions as noalias previously. But this is not true. There are a lot of getelementptr uses for the parameter in the resume/destroy functions. This violates the assumption of noalias. So it would be better to remove this attribute.

[ChuanqiXu]

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

519–525

It is dead. It would be covered by the following change.

849–853

The documentation says the NonNull attribute should be used in the combination of NoUndef.

850–851

Although I suspect the Retcon ABI has the similar problem, this maintains the same behavior with Retcon ABI.

[rjmccall]

I don't know what you mean about GEPs violating noalias. As I understand it, noalias is like restrict; it says that it can be assumed that nothing aliases the parameter except pointers derived from it. GEPs derive pointers in a way that is explicitly permitted under that.

[ChuanqiXu]

In D139295#3971557, @rjmccall wrote:

I don't know what you mean about GEPs violating noalias. As I understand it, noalias is like restrict; it says that it can be assumed that nothing aliases the parameter except pointers derived from it. GEPs derive pointers in a way that is explicitly permitted under that.

Here are my understanding: in the LLVM IR language manual (https://llvm.org/docs/LangRef.html#parameter-attributes), it says:

noalias

This indicates that memory locations accessed via pointer values based on the argument or return value are not also accessed, during the execution of the function, via pointer values not based on the argument or return value.

And in the pointer aliasing rules section (https://llvm.org/docs/LangRef.html#pointer-aliasing-rules), it says:

A pointer value is based on another pointer value according to the following rules:

• A pointer value formed from a scalar getelementptr operation is based on the pointer-typed operand of the getelementptr.

So a gep result is a pointer value based on the argument. And since the parameter is marked as noalias, we shouldn't access the pointer during the execution of the function. Here is my reading. I am not 100% sure I got things right. @nikic could you take a look?

[nikic]

@ChuanqiXu It's fine to access both the "plain" noalias argument and a GEP of the noalias argument. What is forbidden is to access the object the noalias argument points to through some other pointer that is unrelated to the argument. It's not really clear to me whether this is the case here, would it be possible to provide the IR directly after the CoroSplit pass?

[ChuanqiXu]

In D139295#3973246, @nikic wrote:

@ChuanqiXu It's fine to access both the "plain" noalias argument and a GEP of the noalias argument. What is forbidden is to access the object the noalias argument points to through some other pointer that is unrelated to the argument. It's not really clear to me whether this is the case here, would it be possible to provide the IR directly after the CoroSplit pass?

Oh, so I got things wrong. Here is the IR after the CoroSplit pass for test() (and some other optimization):

define internal fastcc void @_ZL4testv.resume(ptr noalias nonnull align 8 dereferenceable(80) %0) #3 personality ptr @__gxx_personality_v0 {
resume.entry:
  %index.addr = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 4
  %index = load i2, ptr %index.addr, align 8
  %switch = icmp eq i2 %index, 0
  br i1 %switch, label %AfterCoroSave, label %AfterCoroSave65

AfterCoroSave:                                    ; preds = %resume.entry
  %.reload.addr = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3
  %destroy.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 8
  store ptr @_ZL1av.cleanup, ptr %destroy.addr.i, align 8
  %__promise.reload.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 16
  %index.addr32.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 32
  store i1 false, ptr %index.addr32.i, align 8
  store i2 1, ptr %index.addr, align 8
  %caller.i.i69 = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 24
  store ptr %0, ptr %caller.i.i69, align 8, !tbaa.struct !10
  tail call void @llvm.experimental.noalias.scope.decl(metadata !18)
  store i32 42, ptr %__promise.reload.addr.i, align 8, !tbaa !3, !alias.scope !18
  store ptr null, ptr %.reload.addr, align 8, !alias.scope !18
  %1 = load ptr, ptr %0, align 8
  musttail call fastcc void %1(ptr nonnull %0) #5, !noalias !18
  ret void

AfterCoroSave65:                                  ; preds = %resume.entry
  %__promise.reload.addr = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2
  %__promise.reload.addr.i68 = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 16
  %2 = load i32, ptr %__promise.reload.addr.i68, align 8, !tbaa !3
  store i32 %2, ptr %__promise.reload.addr, align 8, !tbaa !3
  store ptr null, ptr %0, align 8
  %caller.i53 = getelementptr inbounds i8, ptr %0, i64 24
  %retval.sroa.0.0.copyload.i = load ptr, ptr %caller.i53, align 8, !tbaa.struct !10
  %3 = load ptr, ptr %retval.sroa.0.0.copyload.i, align 8
  musttail call fastcc void %3(ptr nonnull %retval.sroa.0.0.copyload.i) #5
  ret void
}

And this code is actually correct. Problems happens with its caller, the main function:

; Function Attrs: norecurse uwtable
define dso_local noundef i32 @main() local_unnamed_addr #1 personality ptr @__gxx_personality_v0 {
entry:
  %0 = alloca [80 x i8], align 8
  store ptr @_ZL4testv.resume, ptr %0, align 8
  %destroy.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 1
  store ptr @_ZL4testv.cleanup, ptr %destroy.addr.i, align 8
  %__promise.reload.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2
  store i32 123, ptr %__promise.reload.addr.i, align 8, !tbaa !3
  %caller.i.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2, i32 1
  store ptr @_ZNSt7__n486114__noop_coro_frE, ptr %caller.i.i, align 8, !tbaa.struct !10
  %index.addr70.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 4
  store i2 0, ptr %index.addr70.i, align 8
  call fastcc void @_ZL4testv.resume(ptr nonnull %0)
  %.pre = load i32, ptr %__promise.reload.addr.i, align 8, !tbaa !3
  %call1 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, i32 noundef %.pre)
  call fastcc void @_ZL4testv.cleanup(ptr nonnull %0)
  ret i32 0
}

And after inlining _ZL4testv.resume into main, the main becomes:

; Function Attrs: norecurse uwtable
define dso_local noundef i32 @main() local_unnamed_addr #1 personality ptr @__gxx_personality_v0 {
entry:
  %0 = alloca [80 x i8], align 8
  store ptr @_ZL4testv.resume, ptr %0, align 8
  %destroy.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 1
  store ptr @_ZL4testv.cleanup, ptr %destroy.addr.i, align 8
  %__promise.reload.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2
  store i32 123, ptr %__promise.reload.addr.i, align 8, !tbaa !3
  %caller.i.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2, i32 1
  store ptr @_ZNSt7__n486114__noop_coro_frE, ptr %caller.i.i, align 8, !tbaa.struct !10
  %index.addr70.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 4
  store i2 0, ptr %index.addr70.i, align 8
  call void @llvm.experimental.noalias.scope.decl(metadata !12)
  %index.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 4
  %index.i = load i2, ptr %index.addr.i, align 8, !alias.scope !12
  %switch.i = icmp eq i2 %index.i, 0
  br i1 %switch.i, label %AfterCoroSave.i, label %AfterCoroSave65.i

AfterCoroSave.i:                                  ; preds = %entry
  %.reload.addr.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3
  %destroy.addr.i.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 8
  store ptr @_ZL1av.cleanup, ptr %destroy.addr.i.i, align 8, !alias.scope !12
  %__promise.reload.addr.i.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 16
  %index.addr32.i.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 32
  store i1 false, ptr %index.addr32.i.i, align 8, !alias.scope !12
  store i2 1, ptr %index.addr.i, align 8, !alias.scope !12
  %caller.i.i69.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 24
  store ptr %0, ptr %caller.i.i69.i, align 8, !tbaa.struct !10, !alias.scope !12
  call void @llvm.experimental.noalias.scope.decl(metadata !15)
  store i32 42, ptr %__promise.reload.addr.i.i, align 8, !tbaa !3, !alias.scope !18
  store ptr null, ptr %.reload.addr.i, align 8, !alias.scope !18
  %1 = call ptr @llvm.coro.subfn.addr(ptr nonnull %0, i8 0), !alias.scope !12, !noalias !15
  call fastcc void %1(ptr nonnull %0) #6, !noalias !15
  br label %_ZL4testv.resume.exit

AfterCoroSave65.i:                                ; preds = %entry
  %__promise.reload.addr.i6 = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 2
  %__promise.reload.addr.i68.i = getelementptr inbounds %_ZL4testv.Frame, ptr %0, i64 0, i32 3, i64 16
  %2 = load i32, ptr %__promise.reload.addr.i68.i, align 8, !tbaa !3, !alias.scope !12
  store i32 %2, ptr %__promise.reload.addr.i6, align 8, !tbaa !3, !alias.scope !12
  store ptr null, ptr %0, align 8, !alias.scope !12
  %caller.i53.i = getelementptr inbounds i8, ptr %0, i64 24
  %retval.sroa.0.0.copyload.i.i = load ptr, ptr %caller.i53.i, align 8, !tbaa.struct !10, !alias.scope !12
  %3 = call ptr @llvm.coro.subfn.addr(ptr %retval.sroa.0.0.copyload.i.i, i8 0), !noalias !12
  call fastcc void %3(ptr %retval.sroa.0.0.copyload.i.i) #6, !noalias !12
  br label %_ZL4testv.resume.exit

_ZL4testv.resume.exit:                            ; preds = %AfterCoroSave65.i, %AfterCoroSave.i
  %.pre = load i32, ptr %__promise.reload.addr.i, align 8, !tbaa !3
  %call1 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str, i32 noundef %.pre)
  ret i32 0
}

Note that now the store i32 42, ptr %__promise.reload.addr.i.i is in !alias.scope !18, and the call call fastcc void %1(ptr nonnull %0) lives in !noalias !15. So that the DSE think the store is dead. And in https://github.com/llvm/llvm-project/blob/3cfe412e4c90718a3c5abe0aaf2209053a490982/llvm/lib/Transforms/Utils/InlineFunction.cpp#L1140-L1154, I see the noalias scope metadata is added if the parameter is noalias. So I thought I found the solution. And here is the patch. Remind me if you need a module level IR reproducer (since it may take some time to reduce it..)

[nikic]

@ChuanqiXu Your first function already contains:

store i32 42, ptr %__promise.reload.addr.i.i, align 8, !tbaa !3, !alias.scope !18
store ptr null, ptr %.reload.addr, align 8, !alias.scope !18
%1 = load ptr, ptr %0, align 8
musttail call fastcc void %1(ptr nonnull %0) #5, !noalias !18

which says that the store and the call don't alias. I don't think the noalias argument on the function would even matter in that case. The incorrect noalias metadata must be introduced at some earlier point already.

[ChuanqiXu]

In D139295#3978335, @nikic wrote:

@ChuanqiXu Your first function already contains:

store i32 42, ptr %__promise.reload.addr.i.i, align 8, !tbaa !3, !alias.scope !18
store ptr null, ptr %.reload.addr, align 8, !alias.scope !18
%1 = load ptr, ptr %0, align 8
musttail call fastcc void %1(ptr nonnull %0) #5, !noalias !18

which says that the store and the call don't alias. I don't think the noalias argument on the function would even matter in that case. The incorrect noalias metadata must be introduced at some earlier point already.

Oh, so I misunderstood the semantics of !noalias before. So this patch may not be correct. BTW, do you have any ideas why the store in the first function would't be optimized out?

[nikic]

In D139295#3983358, @ChuanqiXu wrote:

In D139295#3978335, @nikic wrote:

@ChuanqiXu Your first function already contains:

store i32 42, ptr %__promise.reload.addr.i.i, align 8, !tbaa !3, !alias.scope !18
store ptr null, ptr %.reload.addr, align 8, !alias.scope !18
%1 = load ptr, ptr %0, align 8
musttail call fastcc void %1(ptr nonnull %0) #5, !noalias !18

which says that the store and the call don't alias. I don't think the noalias argument on the function would even matter in that case. The incorrect noalias metadata must be introduced at some earlier point already.

Oh, so I misunderstood the semantics of !noalias before. So this patch may not be correct. BTW, do you have any ideas why the store in the first function would't be optimized out?

This is because the caller may read it. After inlining, we see that it's an alloca that nobody reads afterwards.

[ChuanqiXu]

In D139295#3986273, @nikic wrote:

In D139295#3983358, @ChuanqiXu wrote:

In D139295#3978335, @nikic wrote:

@ChuanqiXu Your first function already contains:

store i32 42, ptr %__promise.reload.addr.i.i, align 8, !tbaa !3, !alias.scope !18
store ptr null, ptr %.reload.addr, align 8, !alias.scope !18
%1 = load ptr, ptr %0, align 8
musttail call fastcc void %1(ptr nonnull %0) #5, !noalias !18

which says that the store and the call don't alias. I don't think the noalias argument on the function would even matter in that case. The incorrect noalias metadata must be introduced at some earlier point already.

Oh, so I misunderstood the semantics of !noalias before. So this patch may not be correct. BTW, do you have any ideas why the store in the first function would't be optimized out?

This is because the caller may read it. After inlining, we see that it's an alloca that nobody reads afterwards.

Oh, I got it. Thanks for clarification!

[ChuanqiXu]

Although there were some misunderstandings, now this one looks like the correct fix still. See https://github.com/llvm/llvm-project/issues/59221 for the details. Long story short, for this C++ program (https://compiler-explorer.com/z/6qGcozG93), the optimized frame will be something like:

struct test_frame {
    void (*__resume_)(), // a function pointer points to the `test.resume` function, which can be imaged as the test() function in the example.
    ....
    struct a_frame {
          ...
          void **caller; // may points to test_frame at runtime.
    };
};

And the function a and function test looks just like:

define i32 @a(ptr noalias %alloc_8) {
  %alloc_8_16 = getelementptr ptr, ptr %alloc_8, i64 16
  store i32 42, ptr %alloc_8_16, align 8
  %alloc_8_8 = getelementptr ptr, ptr %alloc_8, i64 8
  %alloc = load ptr, ptr %alloc_8_8, align 8
  %p = load ptr, ptr %alloc, align 8
  %r = call i32 %p(ptr %alloc)
  ret i32 %r
}

define i32 @b(ptr %p) {
entry:
  %alloc = alloca [128 x i8], align 8
  %alloc_8 = getelementptr ptr, ptr %alloc, i64 8
  %alloc_8_8 = getelementptr ptr, ptr %alloc_8, i64 8
  store ptr %alloc, ptr %alloc_8_8, align 8
  store ptr %p, ptr %alloc, align 8
  %r = call i32 @a(ptr nonnull %alloc_8)
  ret i32 %r
}

Here inside the function a, we can access the parameter %alloc_8 by %alloc and we pass %alloc to an unknown function. So it breaks the assumption of noalias parameter.

Note that although only CoroElide optimization can put a frame inside another frame directly, the following case is not valid too:

struct test_frame {
    ....
   void **a_frame; // may points to a_frame at runtime.
};

 struct a_frame {
    void **caller; // may points to test_frame at runtime.
};

Since the C++ language allows the programmer to get the address of coroutine frames, we can't assume the above case wouldn't happen in the source codes. So we can't set the parameter as noalias no matter if CoroElide applies or not. And for other languages, it may be safe if they don't allow the programmers to get the address of coroutine frames.

[nikic]

LG

clang/test/CodeGenCoroutines/pr59221.cpp

86

mitoptimized -> misoptimized?

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

849–853

dereferenceable implies noundef, but I guess it doesn't hurt to be explicit about it.

850

I'd move this FIXME to the call for the retcon ABI.

[ChuanqiXu]

Address comments.

clang/test/CodeGenCoroutines/pr59221.cpp

+// Test for PR59221. Tests the compiler wouldn't misoptimize the final result.
+//
+// REQUIRES: x86-registered-target
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 %s -O3 -S -emit-llvm -o - | FileCheck %s
+
+#include "Inputs/coroutine.h"
+
+template <typename T> struct task {
+  struct promise_type {
+    T value{123};
+    std::coroutine_handle<> caller{std::noop_coroutine()};
+    
+    struct final_awaiter: std::suspend_always {
+      auto await_suspend(std::coroutine_handle<promise_type> me) const noexcept {
+        return me.promise().caller;
+      }
+    };
+
+    constexpr auto initial_suspend() const noexcept {
+      return std::suspend_always();
+    }
+    constexpr auto final_suspend() const noexcept {
+      return final_awaiter{};
+    }
+    auto unhandled_exception() noexcept {
+      // ignore
+    }
+    constexpr void return_value(T v) noexcept {
+      value = v;
+    } 
+    constexpr auto & get_return_object() noexcept {
+      return *this;
+    }
+  };
+  
+  using coroutine_handle = std::coroutine_handle<promise_type>;
+  
+  promise_type & promise{nullptr};
+  
+  task(promise_type & p) noexcept: promise{p} { }
+  
+  ~task() noexcept {
+    coroutine_handle::from_promise(promise).destroy();
+  }
+  
+  auto await_ready() noexcept {
+        return false;
+    }
+
+    auto await_suspend(std::coroutine_handle<> caller) noexcept {
+        promise.caller = caller;
+        return coroutine_handle::from_promise(promise);
+    }
+
+    constexpr auto await_resume() const noexcept {
+        return promise.value;
+    }
+  
+  // non-coroutine access to result
+  auto get() noexcept {
+    const auto handle = coroutine_handle::from_promise(promise);
+    
+    if (!handle.done()) {
+      handle.resume();
+    }
+
+        return promise.value;
+  }
+};
+
+
+static inline auto a() noexcept -> task<int> {
+  co_return 42;
+}
+
+static inline auto test() noexcept -> task<int> {
+  co_return co_await a();
+}
+
+int foo() {
+  return test().get();
+}
+
+// Checks that the store for the result value 42 is not misoptimized out.
+// CHECK: define{{.*}}_Z3foov(
+// CHECK: store i32 42, ptr %{{.*}}
+// CHECK: }

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

static Function *createCloneDeclaration(Function &OrigF, coro::Shape &Shape,
   Module *M = OrigF.getParent();
   auto *FnTy = (Shape.ABI != coro::ABI::Async)
                    ? Shape.getResumeFunctionType()
                    : getFunctionTypeFromAsyncSuspend(ActiveSuspend);
 
   Function *NewF =
       Function::Create(FnTy, GlobalValue::LinkageTypes::InternalLinkage,
                        OrigF.getName() + Suffix);
-  if (Shape.ABI != coro::ABI::Async)
-    NewF->addParamAttr(0, Attribute::NonNull);
-
-  // For the async lowering ABI we can't guarantee that the context argument is
-  // not access via a different pointer not based on the argument.
-  if (Shape.ABI != coro::ABI::Async)
-    NewF->addParamAttr(0, Attribute::NoAlias);
 
   M->getFunctionList().insert(InsertBefore, NewF);
 
   return NewF;
 }
 
 /// Replace uses of the active llvm.coro.suspend.retcon/async call with the
 /// arguments to the continuation function.
auto FramePtrPtr =
       Builder.CreateBitCast(NewStorage, FramePtrTy->getPointerTo());
     return Builder.CreateLoad(FramePtrTy, FramePtrPtr);
   }
   }
   llvm_unreachable("bad ABI");
 }
 
 static void addFramePointerAttrs(AttributeList &Attrs, LLVMContext &Context,
-                                 unsigned ParamIndex,
-                                 uint64_t Size, Align Alignment) {
+                                 unsigned ParamIndex, uint64_t Size,
+                                 Align Alignment, bool NoAlias) {
   AttrBuilder ParamAttrs(Context);
   ParamAttrs.addAttribute(Attribute::NonNull);
+  ParamAttrs.addAttribute(Attribute::NoUndef);
+
+  if (NoAlias)
     ParamAttrs.addAttribute(Attribute::NoAlias);
+
   ParamAttrs.addAlignmentAttr(Alignment);
   ParamAttrs.addDereferenceableAttr(Size);
   Attrs = Attrs.addParamAttributes(Context, ParamIndex, ParamAttrs);
 }
 
 static void addAsyncContextAttrs(AttributeList &Attrs, LLVMContext &Context,
                                  unsigned ParamIndex) {
   AttrBuilder ParamAttrs(Context);
void CoroCloner::create() {
 
   switch (Shape.ABI) {
   case coro::ABI::Switch:
     // Bootstrap attributes by copying function attributes from the
     // original function.  This should include optimization settings and so on.
     NewAttrs = NewAttrs.addFnAttributes(
         Context, AttrBuilder(Context, OrigAttrs.getFnAttrs()));
 
-    addFramePointerAttrs(NewAttrs, Context, 0,
-                         Shape.FrameSize, Shape.FrameAlign);
+    addFramePointerAttrs(NewAttrs, Context, 0, Shape.FrameSize,
+                         Shape.FrameAlign, /*NoAlias=*/false);
     break;
   case coro::ABI::Async: {
     auto *ActiveAsyncSuspend = cast<CoroSuspendAsyncInst>(ActiveSuspend);
     if (OrigF.hasParamAttribute(Shape.AsyncLowering.ContextArgNo,
                                 Attribute::SwiftAsync)) {
       uint32_t ArgAttributeIndices =
           ActiveAsyncSuspend->getStorageArgumentIndex();
       auto ContextArgIndex = ArgAttributeIndices & 0xff;
case coro::ABI::Async: {
     break;
   }
   case coro::ABI::Retcon:
   case coro::ABI::RetconOnce:
     // If we have a continuation prototype, just use its attributes,
     // full-stop.
     NewAttrs = Shape.RetconLowering.ResumePrototype->getAttributes();
 
+    /// FIXME: Is it really good to add the NoAlias attribute?
     addFramePointerAttrs(NewAttrs, Context, 0,
                          Shape.getRetconCoroId()->getStorageSize(),
-                         Shape.getRetconCoroId()->getStorageAlignment());
+                         Shape.getRetconCoroId()->getStorageAlignment(),
+                         /*NoAlias=*/true);
+
     break;
   }
 
   switch (Shape.ABI) {
   // In these ABIs, the cloned functions always return 'void', and the
   // existing return sites are meaningless.  Note that for unique
   // continuations, this includes the returns associated with suspends;
   // this is fine because we can't suspend twice.

llvm/test/Transforms/Coroutines/coro-debug-dbg.addr.ll

 ; Tests whether we properly setup llvm.dbg.addr.
 ;
 ; Since we do not have any guarantees around the usage of llvm.dbg.addr, we can
 ; not propagate them like we do llvm.dbg.declare into funclets. But if users
 ; create the debug_value for us, make sure that we propagate llvm.dbg.addr into
 ; the beginning coroutine and all other funclets.
 
 ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 
 ; This file is based on coro-debug-frame-variable.ll.
-; CHECK:  define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
+; CHECK:  define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
 ; CHECK-NEXT:       entry.resume:
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[YVAR_RESUME:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[ZVAR_RESUME:[0-9]+]],
 
-; CHECK:  define internal fastcc void @f.destroy(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[DESTROY_FN_DBG_NUM:[0-9]+]] {
+; CHECK:  define internal fastcc void @f.destroy(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[DESTROY_FN_DBG_NUM:[0-9]+]] {
 ; CHECK-NEXT:       entry.destroy:
 ; CHECK-NEXT:         %FramePtr.debug = alloca
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_DESTROY:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[YVAR_DESTROY:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[ZVAR_DESTROY:[0-9]+]],
 
-; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[CLEANUP_FN_DBG_NUM:[0-9]+]] {
+; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[CLEANUP_FN_DBG_NUM:[0-9]+]] {
 ; CHECK:       entry.cleanup:
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_CLEANUP:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[YVAR_CLEANUP:[0-9]+]],
 ; CHECK:         call void @llvm.dbg.addr(metadata %f.Frame** %FramePtr.debug, metadata ![[ZVAR_CLEANUP:[0-9]+]],
 
 ; CHECK-DAG: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
 ; CHECK-DAG: ![[DESTROY_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
 ; CHECK-DAG: ![[CLEANUP_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"

llvm/test/Transforms/Coroutines/coro-debug-dbg.values-not_used_in_frame.ll

 ; Tests whether resume function would remain dbg.value infomation if corresponding values are not used in the frame.
 ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 ;
 ; This file is based on coro-debug-frame-variable.ll.
-; CHECK:  define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
+; CHECK:  define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
 ; CHECK:       await.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata i32 undef, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ; CHECK:         call void @llvm.dbg.value(metadata i32 undef, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ;
 ; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"
 ; CHECK: ![[IVAR_RESUME]] = !DILocalVariable(name: "i"
 ; CHECK: ![[JVAR_RESUME]] = !DILocalVariable(name: "j"
 

llvm/test/Transforms/Coroutines/coro-debug-dbg.values.ll

 ; Tests whether resume function would remain dbg.value infomation.
 ; RUN: opt < %s -passes='module(coro-early),cgscc(coro-split,coro-split)' -S | FileCheck %s
 ;
 ; This file is based on coro-debug-frame-variable.ll.
-; CHECK:  define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
+; CHECK:  define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 16 dereferenceable(80) %FramePtr) !dbg ![[RESUME_FN_DBG_NUM:[0-9]+]]
 ; CHECK:       init.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[XVAR_RESUME:[0-9]+]],
 ; CHECK:       await.ready:
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[SPILL_RESUME:[0-9]+]]
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[IVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ; CHECK:         call void @llvm.dbg.value(metadata %f.Frame** %FramePtr.debug, metadata ![[JVAR_RESUME:[0-9]+]], metadata !DIExpression(
 ;
 ; CHECK: ![[RESUME_FN_DBG_NUM]] = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov"

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

 !27 = !DILocalVariable(name: "undefined", scope: !6, file: !7, line: 55, type: !11)
 !28 = !DILocalVariable(name: "null", scope: !6, file: !7, line: 55, type: !11)
 !29 = !DILocalVariable(name: "partial_dead", scope: !6, file: !7, line: 55, type: !11)
 !30 = !DILocalVariable(name: "direct_value", scope: !6, file: !7, line: 55, type: !11)
 !31 = !DILocalVariable(name: "allocated", scope: !6, file: !7, line: 55, type: !11)
 !32 = !DILocalVariable(name: "inline_asm", scope: !6, file: !7, line: 55, type: !11)
 
 ; CHECK: define i8* @f(i32 %x) #0 personality i32 0 !dbg ![[ORIG:[0-9]+]]
-; CHECK: define internal fastcc void @f.resume(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[RESUME:[0-9]+]]
+; CHECK: define internal fastcc void @f.resume(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[RESUME:[0-9]+]]
 ; CHECK: entry.resume:
 ; CHECK: %[[DBG_PTR:.*]] = alloca %f.Frame*
 ; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_COROHDL:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst,
 ; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_X:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL:.*]])
 ; CHECK: call void @llvm.dbg.declare(metadata %f.Frame** %[[DBG_PTR]], metadata ![[RESUME_DIRECT:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, [[EXPR_TAIL]])
 ; CHECK: store %f.Frame* {{.*}}, %f.Frame** %[[DBG_PTR]]
 ; CHECK-NOT: alloca %struct.test*
 ; CHECK: call void @llvm.dbg.declare(metadata i8 0, metadata ![[RESUME_CONST:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed))
 ; Note that keeping the undef value here could be acceptable, too.
 ; CHECK-NOT: call void @llvm.dbg.declare(metadata i32* undef, metadata !{{[0-9]+}}, metadata !DIExpression())
 ; CHECK: call void @coro.devirt.trigger(i8* null)
 ; CHECK: call void @llvm.dbg.value(metadata %f.Frame** {{.*}}, metadata ![[RESUME_DIRECT_VALUE:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
 ; Check that the dbg.declare intrinsic of invoke instruction is hanled correctly.
 ; CHECK: %[[ALLOCATED_STORAGE:.+]] = invoke i8* @allocate()
 ; CHECK-NEXT: to label %[[NORMAL_DEST:.+]] unwind
 ; CHECK: [[NORMAL_DEST]]
 ; CHECK-NEXT: call void @llvm.dbg.declare(metadata i8* %[[ALLOCATED_STORAGE]]
 ; CHECK: %[[CALLBR_RES:.+]] = callbr i32 asm
 ; CHECK-NEXT: to label %[[DEFAULT_DEST:.+]] [label
 ; CHECK: [[DEFAULT_DEST]]:
 ; CHECK-NEXT: call void @llvm.dbg.declare(metadata i32 %[[CALLBR_RES]]
-; CHECK: define internal fastcc void @f.destroy(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[DESTROY:[0-9]+]]
-; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[CLEANUP:[0-9]+]]
+; CHECK: define internal fastcc void @f.destroy(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[DESTROY:[0-9]+]]
+; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noundef nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[CLEANUP:[0-9]+]]
 
 ; CHECK: ![[ORIG]] = distinct !DISubprogram(name: "f", linkageName: "flink"
 
 ; CHECK: ![[RESUME]] = distinct !DISubprogram(name: "f", linkageName: "flink"
 ; CHECK: ![[RESUME_COROHDL]] = !DILocalVariable(name: "coro_hdl", scope: ![[RESUME]]
 ; CHECK: ![[RESUME_X]] = !DILocalVariable(name: "x", arg: 1, scope: ![[RESUME]]
 ; CHECK: ![[RESUME_DIRECT]] = !DILocalVariable(name: "direct_mem", scope: ![[RESUME]]
 ; CHECK: ![[RESUME_CONST]] = !DILocalVariable(name: "direct_const", scope: ![[RESUME]]
 ; CHECK: ![[RESUME_DIRECT_VALUE]] = !DILocalVariable(name: "direct_value", scope: ![[RESUME]]
 
 ; CHECK: ![[DESTROY]] = distinct !DISubprogram(name: "f", linkageName: "flink"
 
 ; CHECK: ![[CLEANUP]] = distinct !DISubprogram(name: "f", linkageName: "flink"

llvm/test/Transforms/Coroutines/coro-frame.ll

 ; See if the float was spilled into the frame
 ; CHECK-LABEL: @f(
 ; CHECK: %r = call double @print(
 ; CHECK: %r.spill.addr = getelementptr inbounds %f.Frame, %f.Frame* %FramePtr, i32 0, i32 2
 ; CHECK: store double %r, double* %r.spill.addr
 ; CHECK: ret i8* %hdl
 
 ; See if the float was loaded from the frame
-; CHECK-LABEL: @f.resume(%f.Frame* noalias nonnull align 8
+; CHECK-LABEL: @f.resume(%f.Frame* noundef nonnull align 8
 ; CHECK: %r.reload = load double, double* %r.reload.addr
 ; CHECK: call double @print(double %r.reload)
 ; CHECK: ret void
 
 declare i8* @llvm.coro.free(token, i8*)
 declare i32 @llvm.coro.size.i32()
 declare i8  @llvm.coro.suspend(token, i1)
 declare void @llvm.coro.resume(i8*)