[Corosplit] Prepend entry_value in swift async dbg values

[fdeazeve]

Summary

When the coroutine splitter splits swift coroutines, variables in the new
funclets are now described in terms of the frame pointer, which is always placed
at a ABI-specified register whose contents are valid upon function entry. As
such, debug intrinsics must be prepended by the entry_value operation.

Depends on D149778

[fdeazeve]

Update lang ref

[fdeazeve]

Reorganize test slightly to emphasize each coroutine split

[fdeazeve]

rebased

llvm/docs/LangRef.rst

:ref:`_swiftasync` argument. The operation is introduced by:
     - ``LiveDebugValues`` pass, which applies it to function parameters that
       are unmodified throughout the function. Support is limited to simple
       register location descriptions, or as indirect locations (e.g.,
       parameters passed-by-value to a callee via a pointer to a temporary copy
       made in the caller).
     - ``AsmPrinter`` pass when a call site parameter value
       (``DW_AT_call_site_parameter_value``) is represented as entry value of
       the parameter.
+    - ``CoroSplit`` pass, which may move variables from allocas into a
+      coroutine frame. If the coroutine frame is a :ref:`_swiftasync` argument,
+      the variable is described with an ``DW_OP_LLVM_entry_value`` operation.
 
 - ``DW_OP_LLVM_arg, N`` is used in debug intrinsics that refer to more than one
   value, such as one that calculates the sum of two registers. This is always
   used in combination with an ordered list of values, such that
   ``DW_OP_LLVM_arg, N`` refers to the ``N``\ :sup:`th` element in that list. For
   example, ``!DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_minus,
   DW_OP_stack_value)`` used with the list ``(%reg1, %reg2)`` would evaluate to
   ``%reg1 - reg2``. This list of values should be provided by the containing

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

if (auto *LdInst = dyn_cast<LoadInst>(Inst)) {
       Storage = Op;
       Expr = DIExpression::appendOpsToArg(Expr, Ops, 0, /*StackValue*/ false);
     }
     SkipOutermostLoad = false;
   }
   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.
-  //
-  // Avoid to create the alloca would be eliminated by optimization
-  // passes and the corresponding dbg.declares would be invalid.
-  if (!OptimizeFrame)
-    if (auto *Arg = dyn_cast<Argument>(Storage)) {
-      auto &Cached = ArgToAllocaMap[Arg];
-      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.
-      Expr = DIExpression::prepend(Expr, DIExpression::DerefBefore);
-    }
+  auto *StorageAsArg = dyn_cast<Argument>(Storage);
+  const bool IsSwiftAsyncArg =
+      StorageAsArg && StorageAsArg->hasAttribute(Attribute::SwiftAsync);
+
+  // Swift async arguments are described by an entry value of the ABI-defined
+  // register containing the coroutine context.
+  if (IsSwiftAsyncArg && !Expr->isEntryValue())
+    Expr = DIExpression::prepend(Expr, DIExpression::EntryValue);
+
+  // If the coroutine frame is an Argument, store it in an alloca to improve
+  // its availability (e.g. registers may be clobbered).
+  // Avoid this if optimizations are enabled (they would remove the alloca) or
+  // if the value is guaranteed to be available through other means (e.g. swift
+  // ABI guarantees).
+  if (StorageAsArg && !OptimizeFrame && !IsSwiftAsyncArg) {
+    auto &Cached = ArgToAllocaMap[StorageAsArg];
+                                    Storage->getName() + ".debug");
 
   DVI->replaceVariableLocationOp(OriginalStorage, Storage);
   DVI->setExpression(Expr);
   // We only hoist dbg.declare today since it doesn't make sense to hoist
   // dbg.value since it does not have the same function wide guarantees that
   // dbg.declare does.
   if (isa<DbgDeclareInst>(DVI)) {
     Instruction *InsertPt = nullptr;

llvm/test/Transforms/Coroutines/swift-async-dbg.ll

+; RUN: opt %s -S -passes='module(coro-early),cgscc(coro-split,simplifycfg)' -o - | FileCheck %s
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-macosx13.0.0"
+
+; This coroutine has one split point and two variables defined by:
+;   %var_with_dbg_value,   which has multiple dbg.value intrinsics associated with
+;                          it, one per split point.
+;   %var_with_dbg_declare, which has a single dbg.declare intrinsic associated
+;                          with it at the coroutine entry.
+; We check that, for each funclet, the debug intrinsics are propagated properly AND that
+; an `entry_value` operation is created.
+define swifttailcc void @coroutineA(ptr swiftasync %arg) !dbg !48 {
+  %var_with_dbg_value = alloca ptr, align 8
+  %var_with_dbg_declare = alloca ptr, align 8
+  call void @llvm.dbg.declare(metadata ptr %var_with_dbg_declare, metadata !500, metadata !DIExpression()), !dbg !54
+  call void @llvm.dbg.value(metadata ptr %var_with_dbg_value, metadata !50, metadata !DIExpression(DW_OP_deref)), !dbg !54
+  %i2 = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, ptr nonnull @coroutineATu)
+  %i3 = call ptr @llvm.coro.begin(token %i2, ptr null)
+; CHECK-LABEL: define {{.*}} @coroutineA(
+; CHECK-SAME:    ptr swiftasync %[[frame_ptr:.*]])
+; CHECK:      @llvm.dbg.declare(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                   DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)
+; CHECK:      @llvm.dbg.value(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                 DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_deref)
+; CHECK:      call {{.*}} @swift_task_switch
+
+  %i7 = call ptr @llvm.coro.async.resume(), !dbg !54
+  %i10 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0s(i32 0, ptr %i7, ptr nonnull @__swift_async_resume_get_context, ptr nonnull @coroutineA.1, ptr %i7, i64 0, i64 0, ptr %arg), !dbg !54
+  %i11 = extractvalue { ptr } %i10, 0, !dbg !54
+  %i12 = call ptr @__swift_async_resume_get_context(ptr %i11), !dbg !54
+  call void @dont_optimize(ptr %var_with_dbg_value, ptr %var_with_dbg_declare)
+  call void @llvm.dbg.value(metadata ptr %var_with_dbg_value, metadata !50, metadata !DIExpression(DW_OP_deref)), !dbg !54
+  %i17 = load i32, ptr getelementptr inbounds (<{i32, i32}>, ptr @coroutineBTu, i64 0, i32 1), align 8, !dbg !54
+  %i18 = zext i32 %i17 to i64, !dbg !54
+  %i19 = call swiftcc ptr @swift_task_alloc(i64 %i18), !dbg !54
+; CHECK-NOT: define
+; CHECK-LABEL: define {{.*}} @coroutineATY0_(
+; CHECK-SAME:    ptr swiftasync %[[frame_ptr:.*]])
+; CHECK:      @llvm.dbg.declare(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                   DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)
+; CHECK:      @llvm.dbg.value(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                 DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_deref)
+; CHECK:      call {{.*}} @coroutineB
+
+  %i23 = call ptr @llvm.coro.async.resume(), !dbg !54
+  %i25 = getelementptr inbounds <{ ptr, ptr }>, ptr %i19, i64 0, i32 1, !dbg !54
+  store ptr %i23, ptr %i25, align 8, !dbg !54
+  %i27 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0s(i32 0, ptr %i23, ptr nonnull @__swift_async_resume_project_context, ptr nonnull @coroutineA.0, ptr nonnull @coroutineB, ptr nonnull %i19), !dbg !54
+  %i28 = extractvalue { ptr } %i27, 0, !dbg !54
+  %i29 = call ptr @__swift_async_resume_project_context(ptr %i28), !dbg !54
+  call swiftcc void @swift_task_dealloc(ptr nonnull %i19), !dbg !54
+  call void @dont_optimize(ptr %var_with_dbg_value, ptr %var_with_dbg_declare)
+  call void @llvm.dbg.value(metadata ptr %var_with_dbg_value, metadata !50, metadata !DIExpression(DW_OP_deref)), !dbg !54
+; CHECK-NOT: define
+; CHECK-LABEL: define {{.*}} @coroutineATQ1_(
+; CHECK-SAME:    ptr swiftasync %[[frame_ptr:.*]])
+; Note the extra level of indirection that shows up here!
+; CHECK:      @llvm.dbg.declare(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                   DW_OP_LLVM_entry_value, 1, DW_OP_deref, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)
+; CHECK:      @llvm.dbg.value(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                 DW_OP_LLVM_entry_value, 1, DW_OP_deref, DW_OP_plus_uconst, 16, DW_OP_deref)
+; CHECK:      call {{.*}} @swift_task_switch
+
+  %i31 = call ptr @llvm.coro.async.resume(), !dbg !54
+  %i33 = call { ptr } (i32, ptr, ptr, ...) @llvm.coro.suspend.async.sl_p0s(i32 0, ptr %i31, ptr nonnull @__swift_async_resume_get_context, ptr nonnull @coroutineA.1, ptr %i31, i64 0, i64 0, ptr %i29), !dbg !54
+  %i34 = extractvalue { ptr } %i33, 0, !dbg !54
+  %i35 = call ptr @__swift_async_resume_get_context(ptr %i34), !dbg !54
+  %i45 = call i1 (ptr, i1, ...) @llvm.coro.end.async(ptr %i3, i1 false, ptr nonnull @coroutineA.0.1, ptr undef, ptr undef), !dbg !54
+  unreachable, !dbg !54
+; CHECK-NOT: define
+; CHECK-LABEL: define {{.*}} @coroutineATY2_(
+; CHECK-SAME:    ptr swiftasync %[[frame_ptr:.*]])
+; CHECK:      @llvm.dbg.declare(metadata ptr %[[frame_ptr]], {{.*}} !DIExpression(
+; CHECK-SAME:                   DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 16, DW_OP_plus_uconst, 8)
+}
+
+; Everything from here on is just support code for the coroutines.
+
+@coroutineBTu = global <{i32, i32}> <{ i32 trunc (i64 sub (i64 ptrtoint (ptr @"coroutineB" to i64), i64 ptrtoint (ptr @"coroutineBTu" to i64)) to i32), i32 16 }>, align 8
+@coroutineATu = global <{i32, i32}> <{ i32 trunc (i64 sub (i64 ptrtoint (ptr @"coroutineA" to i64), i64 ptrtoint (ptr @"coroutineATu" to i64)) to i32), i32 16 }>, align 8
+
+define weak_odr hidden ptr @__swift_async_resume_get_context(ptr %arg) !dbg !64 {
+  ret ptr %arg, !dbg !65
+}
+define hidden swifttailcc void @coroutineA.1(ptr %arg, i64 %arg1, i64 %arg2, ptr %arg3) !dbg !66 {
+  musttail call swifttailcc void @swift_task_switch(ptr swiftasync %arg3, ptr %arg, i64 %arg1, i64 %arg2), !dbg !67
+  ret void, !dbg !67
+}
+
+define weak_odr hidden ptr @__swift_async_resume_project_context(ptr %arg) !dbg !68 {
+  %i1 = load ptr, ptr %arg, align 8, !dbg !69
+  %i2 = call ptr @llvm.swift.async.context.addr(), !dbg !69
+  store ptr %i1, ptr %i2, align 8, !dbg !69
+  ret ptr %i1, !dbg !69
+}
+define hidden swifttailcc void @coroutineA.0(ptr %arg, ptr %arg1) !dbg !70 {
+  musttail call swifttailcc void %arg(ptr swiftasync %arg1), !dbg !71
+  ret void, !dbg !71
+}
+define hidden swifttailcc void @coroutineA.0.1(ptr %arg, ptr %arg1) !dbg !72 {
+  musttail call swifttailcc void %arg(ptr swiftasync %arg1), !dbg !73
+  ret void, !dbg !73
+}
+define swifttailcc void @coroutineB(ptr swiftasync %arg) !dbg !37 {
+  %i2 = call token @llvm.coro.id.async(i32 16, i32 16, i32 0, ptr nonnull @coroutineBTu)
+  %i3 = call ptr @llvm.coro.begin(token %i2, ptr null)
+  %i6 = getelementptr inbounds <{ ptr, ptr }>, ptr %arg, i64 0, i32 1, !dbg !42
+  %i712 = load ptr, ptr %i6, align 8, !dbg !42
+  %i10 = call i1 (ptr, i1, ...) @llvm.coro.end.async(ptr %i3, i1 false, ptr nonnull @coroutineB.0, ptr %i712, ptr %arg), !dbg !42
+  unreachable, !dbg !42
+}
+define hidden swifttailcc void @coroutineB.0(ptr %arg, ptr %arg1) !dbg !44 {
+  musttail call swifttailcc void %arg(ptr swiftasync %arg1), !dbg !47
+  ret void, !dbg !47
+}
+
+declare i1 @llvm.coro.end.async(ptr, i1, ...)
+declare ptr @llvm.coro.async.resume()
+declare ptr @llvm.coro.begin(token, ptr writeonly)
+declare ptr @llvm.swift.async.context.addr()
+declare swiftcc ptr @swift_task_alloc(i64)
+declare swiftcc void @swift_task_dealloc(ptr)
+declare swifttailcc void @swift_task_switch(ptr, ptr, i64, i64)
+declare token @llvm.coro.id.async(i32, i32, i32, ptr)
+declare void @dont_optimize(ptr, ptr)
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+declare { ptr } @llvm.coro.suspend.async.sl_p0s(i32, ptr, ptr, ...)
+
+!llvm.module.flags = !{!6, !7}
+!llvm.dbg.cu = !{!16}
+
+!6 = !{i32 7, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+
+!50 = !DILocalVariable(name: "k1", scope: !48, file: !17, line: 7, type: !53)
+!500 = !DILocalVariable(name: "k2", scope: !48, file: !17, line: 7, type: !53)
+!49 = !{!50, !500}
+
+!16 = distinct !DICompileUnit(language: DW_LANG_Swift, file: !17, producer: "", emissionKind: FullDebug)
+!17 = !DIFile(filename: "blah", directory: "")
+
+!53 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Klass")
+!46 = !DISubroutineType(types: null)
+
+!64 = distinct !DISubprogram(linkageName: "blah", file: !17, type: !46, unit: !16)
+!68 = distinct !DISubprogram(linkageName: "blah", file: !17, type: !46, unit: !16)
+!66 = distinct !DISubprogram(linkageName: "coroutineA", file: !17, type: !46, unit: !16)
+!70 = distinct !DISubprogram(linkageName: "coroutineA", file: !17, type: !46, unit: !16)
+!72 = distinct !DISubprogram(linkageName: "coroutineA", file: !17, type: !46, unit: !16)
+!48 = distinct !DISubprogram(linkageName: "coroutineA", file: !17, type: !46, unit: !16, retainedNodes: !49)
+!37 = distinct !DISubprogram(linkageName: "coroutineB", file: !17, type: !46, unit: !16)
+!44 = distinct !DISubprogram(linkageName: "coroutineB", file: !17, type: !46, unit: !16)
+!65 = !DILocation(line: 0, scope: !64)
+!67 = !DILocation(line: 0, scope: !66)
+!69 = !DILocation(line: 0, scope: !68)
+!71 = !DILocation(line: 0, scope: !70)
+!73 = !DILocation(line: 0, scope: !72)
+!54 = !DILocation(line: 6, scope: !48)
+!42 = !DILocation(line: 3, scope: !37)
+!47 = !DILocation(line: 0, scope: !44)