[Clang][Coroutine][DebugInfo] remove useless debug info for coroutine parameters

[dongAxis1944]

Summary

In c++ coroutine, clang will emit different debug info variables for parameters and move-parameters.
The first one is the real parameters of the coroutine function, the other one just for copying parameters to the coroutine frame.

Considering the following c++ code:

struct coro {
  ...
};

coro foo(struct test & t) {
  ...
  co_await suspend_always();
  ...
  co_await suspend_always();
  ...
  co_await suspend_always();
}

int main(int argc, char *argv[]) {
  auto c = foo(...);
  c.handle.resume();
  ...
}

Function foo is the standard coroutine function, and it has only one parameter named t (ignoring this at first),
when we use the llvm code to compile this function, we can get the following ir:

!2921 = distinct !DISubprogram(name: "foo", linkageName: "_ZN6Object3fooE4test", scope: !2211, file: !45, li\
ne: 48, type: !2329, scopeLine: 48, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefi\
nition | DISPFlagOptimized, unit: !44, declaration: !2328, retainedNodes: !2922)
!2924 = !DILocalVariable(name: "t", arg: 2, scope: !2921, file: !45, line: 48, type: !838) 
...
!2926 = !DILocalVariable(name: "t", scope: !2921, type: !838, flags: DIFlagArtificial)

We can find there are two the same DIVariable named t in the same dwarf scope for foo.resume.
And when we try to use llvm-dwarfdump to dump the dwarf info of this elf, we get the following output:

0x00006684:   DW_TAG_subprogram
                DW_AT_low_pc    (0x00000000004013a0)
                DW_AT_high_pc   (0x00000000004013a8)
                DW_AT_frame_base        (DW_OP_reg7 RSP)
                DW_AT_object_pointer    (0x0000669c)
                DW_AT_GNU_all_call_sites        (true)
                DW_AT_specification     (0x00005b5c "_ZN6Object3fooE4test")

0x000066a5:     DW_TAG_formal_parameter
                  DW_AT_name    ("t")
                  DW_AT_decl_file       ("/disk1/yifeng.dongyifeng/my_code/llvm/build/bin/coro-debug-1.cpp")
                  DW_AT_decl_line       (48)
                  DW_AT_type    (0x00004146 "test")

0x000066ba:     DW_TAG_variable
                  DW_AT_name    ("t")
                  DW_AT_type    (0x00004146 "test")
                  DW_AT_artificial      (true)

The elf also has two 't' in the same scope.
But unluckily, it might let the debugger confused. And failed to print parameters for O0 or above.
This patch will make coroutine parameters and move parameters use the same DIVar and try to fix the problems that I mentioned before.

Test Plan:
check-clang

[dongAxis1944]

update path for code formtting

[dongAxis1944]

@aprantl @JDevlieghere @akhuang @MaskRay ping...

[MaskRay]

In D97533#2593226, @dongAxis1944 wrote:

@aprantl @JDevlieghere @akhuang @MaskRay ping...

Most folks have other duties beside the contribution here and they may have a large queue of reviews. The community convention is one ping per week.

clang/lib/CodeGen/CGCoroutine.cpp

614

https://llvm.org/docs/CodingStandards.html#don-t-evaluate-end-every-time-through-a-loop

631

Cpitalize. Add period.

clang/lib/CodeGen/CGDebugInfo.cpp

4360

Capitalize

clang/lib/CodeGen/CGDebugInfo.h

168

Don’t duplicate function or class name at the beginning of the comment.

clang/lib/CodeGen/CodeGenFunction.cpp

1332

Capitalize. Add period.

clang/lib/CodeGen/CodeGenFunction.h

313

https://llvm.org/docs/CodingStandards.html
"Don’t duplicate function or class name at the beginning of the comment."

clang/test/CodeGenCoroutines/coro-dwarf.cpp

2

I'll create a patch making CC1 -fno-split-dwarf-inlining default align with the driver default.

Then you can delete the option.

-triple=x86_64-unknown-linux-gnu can usually be -triple=x86_64 (generic ELF behavior) because it is not GNU specific.

54

format this line.

68

Relative line numbers may be better. Otherwise, adding or deleting source lines will lead to a pain updating tests.

https://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-pseudo-numeric-variables

[dongAxis1944]

In D97533#2593386, @MaskRay wrote:

In D97533#2593226, @dongAxis1944 wrote:

@aprantl @JDevlieghere @akhuang @MaskRay ping...

Most folks have other duties beside the contribution here and they may have a large queue of reviews. The community convention is one ping per week.

ok, I get it. Thanks for remaining...

[aprantl]

clang/lib/CodeGen/CGCoroutine.cpp

608

Nit: Per LLVM Coding style this should be formatted as:

// Create mapping between parameters and copy-params for coroutine function.

613

Why this->Args and not Args? Are there other Args in scope?

614

FYI: you could use one of the zip functions in llvm::Support to write this as a range-based loop.

clang/lib/CodeGen/CGDebugInfo.cpp

4382

In LLVM we prefer early exits over nested ifs.

if (!PD)
 continue;

4394

This seems redundant?

clang/lib/CodeGen/CGDebugInfo.h

171

No need to repeat the name at the beginning of the comment.

549

What does this comment mean?

552

why this->?

554

LLVM coding style elides {} when there is single statement in the loop.

561

ParamDbgMappings.insert({Var, DILocalVar});

clang/test/CodeGenCoroutines/coro-dwarf.cpp

66

Try to not hardcode the metadata numbering (!7) in the CHECK lines. It will randomly change with other LLVM changes and then the test needs to be updated.
If you need to refer to it again, write

// CHECK: ![[SP:[0-9]+]] = distinct ...
// CHECK: ..., ![[SP]], ...

[aprantl]

Most folks have other duties beside the contribution here and they may have a large queue of reviews. The community convention is one ping per week.

On the flip side, please *do* make use of that weekly ping, because everybody is very busy and it's quite easy to loose track of open reviews.

[dongAxis1944]

In D97533#2601356, @aprantl wrote:

Most folks have other duties beside the contribution here and they may have a large queue of reviews. The community convention is one ping per week.

On the flip side, please *do* make use of that weekly ping, because everybody is very busy and it's quite easy to loose track of open reviews.

Thank you for your reminding.

[dongAxis1944]

fix code format

[dongAxis1944]

clang/lib/CodeGen/CGDebugInfo.cpp

4382

Because the if-statement is not in a single loop, so the current code style might be fine I think. Any ideas?

[dongAxis1944]

update patch for fixing duplicate variables

[dongAxis1944]

@aprantl gentle ping~

[ChuanqiXu]

clang/lib/CodeGen/CGDebugInfo.cpp

4361

We can rewrite these codes into one lambda to make it more clear.

[jmorse]

Drive-by review: some minor nits commented on, looks very reasonable overall.

IMO, the regression test shouldn't use CHECK-NEXT everywhere: it's encoding an ordering on what metadata is emitted, which can be fragile similar to the way that hardcoded metadata numbers are fragile. Would it be sufficient to:

• Match the DISubprogram,
• Match with CHECK-SAME the retained-nodes field on the same line,
• Match against each expected DILocalVariable from the retain-nodes field

That should (AFAIUI) match without relying too much on ordering, and fail to match when there's an unexpected additional DILocalVariable in the retained-nodes field. As it stands, there could be any number of additional DILocalVariables after the CHECK-NEXT lines.

clang/lib/CodeGen/CGDebugInfo.cpp

4380

4388

Full sentences with full stops in other comments too please.

4391

I assume the do-while-0 loop is used to break out of; wouldn't a simpler if condition be sufficient?:

if (!isa<llvm::DISubprogram(Scope) || !Scope->isDistinct() || D->getScope() != Scope) {
  D = nullptr;
}

4396

Opinion: a little more context in this comment would help new readers, i.e. "If we couldn't find a move param DIVariable, create a new one."

[aprantl]

clang/lib/CodeGen/CGCoroutine.cpp

608

I know I'm being pendantic, but the sentence should end with a . :-)

[dongAxis1944]

reflect the code, and fix some code style and comment style

[dongAxis1944]

fix some comment styles

[dongAxis1944]

clang/lib/CodeGen/CGCoroutine.cpp

608

Thanks for reviewing. Please feel free, I think it is useful to fix code styles. :-)

clang/lib/CodeGen/CGDebugInfo.cpp

4380

thanks for reviewing. I just rewrite the code.

4388

Thanks, I already fix syntax errors. :-)

[jmorse]

The test now passes without the rest of the patch applied; as mentioned above, it needs to affirmatively identify the contents of retainedNodes to guarantee detection of extra entries. Alternately, use CHECK-NOT or --implicit-check-not to confirm the absence of the extra DILocalVariables.

That being said, looking at the output of clang @ 880822255e21 on this test, it looks like the retainedNodes field isn't populated for coroutines -- all the DISubprograms have "!{}" for the field. That feels like a bug to me, as any variables completely optimised out will not have their type / declaration information represented in the DWARF output. (I assume there isn't a design change with the representation of coroutine DISubprograms that explains this).

Specifically, in DISubprograms like:

!2 = !{}
!140 = distinct !DISubprogram(name: "f_coro", linkageName: "_Z6f_coroi8MoveOnly11MoveAndCopy", scope: !8, file: !8, line: 60, type: !9, scopeLine: 60, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
!143 = !DILocalVariable(name: "mcParam", scope: !140, type: !28, flags: DIFlagArtificial)
!144 = !DILocalVariable(name: "moParam", scope: !140, type: !12, flags: DIFlagArtificial)
!145 = !DILocalVariable(name: "val", scope: !140, type: !11, flags: DIFlagArtificial)

retainedNodes should be metadata with contents !{!143, !144, !145}

[dongAxis1944]

In D97533#2650910, @jmorse wrote:

The test now passes without the rest of the patch applied; as mentioned above, it needs to affirmatively identify the contents of retainedNodes to guarantee detection of extra entries. Alternately, use CHECK-NOT or --implicit-check-not to confirm the absence of the extra DILocalVariables.

That being said, looking at the output of clang @ 880822255e21 on this test, it looks like the retainedNodes field isn't populated for coroutines -- all the DISubprograms have "!{}" for the field. That feels like a bug to me, as any variables completely optimised out will not have their type / declaration information represented in the DWARF output. (I assume there isn't a design change with the representation of coroutine DISubprograms that explains this).

Specifically, in DISubprograms like:

!2 = !{}
!140 = distinct !DISubprogram(name: "f_coro", linkageName: "_Z6f_coroi8MoveOnly11MoveAndCopy", scope: !8, file: !8, line: 60, type: !9, scopeLine: 60, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
!143 = !DILocalVariable(name: "mcParam", scope: !140, type: !28, flags: DIFlagArtificial)
!144 = !DILocalVariable(name: "moParam", scope: !140, type: !12, flags: DIFlagArtificial)
!145 = !DILocalVariable(name: "val", scope: !140, type: !11, flags: DIFlagArtificial)

retainedNodes should be metadata with contents !{!143, !144, !145}

Thanks, I will update the patch later.

[dongAxis1944]

Use CHECK-NOT to confirm the absence of the extra DILocalVariables.

[dongAxis1944]

In D97533#2650910, @jmorse wrote:

The test now passes without the rest of the patch applied; as mentioned above, it needs to affirmatively identify the contents of retainedNodes to guarantee detection of extra entries. Alternately, use CHECK-NOT or --implicit-check-not to confirm the absence of the extra DILocalVariables.

That being said, looking at the output of clang @ 880822255e21 on this test, it looks like the retainedNodes field isn't populated for coroutines -- all the DISubprograms have "!{}" for the field. That feels like a bug to me, as any variables completely optimised out will not have their type / declaration information represented in the DWARF output. (I assume there isn't a design change with the representation of coroutine DISubprograms that explains this).

Specifically, in DISubprograms like:

!2 = !{}
!140 = distinct !DISubprogram(name: "f_coro", linkageName: "_Z6f_coroi8MoveOnly11MoveAndCopy", scope: !8, file: !8, line: 60, type: !9, scopeLine: 60, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
!143 = !DILocalVariable(name: "mcParam", scope: !140, type: !28, flags: DIFlagArtificial)
!144 = !DILocalVariable(name: "moParam", scope: !140, type: !12, flags: DIFlagArtificial)
!145 = !DILocalVariable(name: "val", scope: !140, type: !11, flags: DIFlagArtificial)

retainedNodes should be metadata with contents !{!143, !144, !145}

As you said, I rerun the test of this patch, it seems the retainedNodes are always empty.
Is this unit test wrong?

Thanks in advance.

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

4362

"we would love to" makes it sound like a FIXME, but I think you mean that we are actually going to do this in the following block?

4367

Should we call this RemapCoroArgToLocalVar or something more descriptive?

[dongAxis1944]

update common and fix code style as suggested

[dongAxis1944]

clang/lib/CodeGen/CGDebugInfo.cpp

4362

Thanks, I will use the "we are going to" instead of "we would love to"

4367

RemapCoroArgToLocalVar sounds great, thanks

4396

Thanks, I already add comments for this code as you suggested.

[dongAxis1944]

fix compile error

[dongAxis1944]

use isa_and_nonnull instead of isa....

[jmorse]

NB, while I flagged that CHECK-NEXT added too much ordering, I forgot that CHECK still requires some ordering. It causes us some difficulties downstream; there's a follow-up patch here D100298 for consideration.

clang/lib/CodeGen/CGCoroutine.cpp

auto *CoroBegin = Builder.CreateCall(
       CGM.getIntrinsic(llvm::Intrinsic::coro_begin), {CoroId, Phi});
   CurCoro.Data->CoroBegin = CoroBegin;
 
   GetReturnObjectManager GroManager(*this, S);
   GroManager.EmitGroAlloca();
 
   CurCoro.Data->CleanupJD = getJumpDestInCurrentScope(RetBB);
   {
+    CGDebugInfo *DI = getDebugInfo();
     ParamReferenceReplacerRAII ParamReplacer(LocalDeclMap);
     CodeGenFunction::RunCleanupsScope ResumeScope(*this);
     EHStack.pushCleanup<CallCoroDelete>(NormalAndEHCleanup, S.getDeallocate());
 
+    // create mapping between parameters and copy-params for coroutine function
+    auto ParamMoves = S.getParamMoves();
+    assert(
+        (ParamMoves.size() == 0 || (ParamMoves.size() == this->Args.size())) &&
+        "should be same");
+    if (ParamMoves.size() == this->Args.size() && DI)
+      for (uint64_t i = 0; i < ParamMoves.size(); i++) {
+        assert(isa<ParmVarDecl>(this->Args[i]) && "should be parameter");
+        if (const auto *ParmDecl = dyn_cast_or_null<ParmVarDecl>(this->Args[i]))
+          DI->appendParamDecl2Stmt(ParmDecl, ParamMoves[i]);
+      }
+
     // Create parameter copies. We do it before creating a promise, since an
     // evolution of coroutine TS may allow promise constructor to observe
     // parameter copies.
     for (auto *PM : S.getParamMoves()) {
       EmitStmt(PM);
       ParamReplacer.addCopy(cast<DeclStmt>(PM));
       // TODO: if(CoroParam(...)) need to surround ctor and dtor
       // for the copy, so that llvm can elide it if the copy is
       // not needed.
     }
 
+    // clear mapping, it is useless later
+    if (DI)
+      DI->clearParamDecl2Stmt();
+
     EmitStmt(S.getPromiseDeclStmt());
 
     Address PromiseAddr = GetAddrOfLocalVar(S.getPromiseDecl());
     auto *PromiseAddrVoidPtr =
         new llvm::BitCastInst(PromiseAddr.getPointer(), VoidPtrTy, "", CoroId);
     // Update CoroId to refer to the promise. We could not do it earlier because
     // promise local variable was not emitted yet.
     CoroId->setArgOperand(1, PromiseAddrVoidPtr);

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLExtensionTypes.def"
   /// using declarations) that aren't covered by other more specific caches.
   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> DeclCache;
   llvm::DenseMap<const NamespaceDecl *, llvm::TrackingMDRef> NamespaceCache;
   llvm::DenseMap<const NamespaceAliasDecl *, llvm::TrackingMDRef>
       NamespaceAliasCache;
   llvm::DenseMap<const Decl *, llvm::TypedTrackingMDRef<llvm::DIDerivedType>>
       StaticDataMemberCache;
 
+  using ParamDecl2StmtTy = llvm::DenseMap<const ParmVarDecl *, const Stmt *>;
+  using Param2DILocTy =
+      llvm::DenseMap<const ParmVarDecl *, llvm::DILocalVariable *>;
+
+  /// CoroutineParameterMappings -
+  /// the key is coroutine real parameters, value is coroutine move parameters
+  ParamDecl2StmtTy CoroutineParameterMappings;
+  /// ParamDbgMappings
+  /// key is coroutine real parameters, value is DIVariable in LLVM IR
+  Param2DILocTy ParamDbgMappings;
+
   /// Helper functions for getOrCreateType.
   /// @{
   /// Currently the checksum of an interface includes the number of
   /// ivars and property accessors.
   llvm::DIType *CreateType(const BuiltinType *Ty);
   llvm::DIType *CreateType(const ComplexType *Ty);
   llvm::DIType *CreateType(const AutoType *Ty);
   llvm::DIType *CreateType(const ExtIntType *Ty);
public:
   /// Emit call to \c llvm.dbg.declare for an imported variable
   /// declaration in a block.
   void EmitDeclareOfBlockDeclRefVariable(
       const VarDecl *variable, llvm::Value *storage, CGBuilderTy &Builder,
       const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint = nullptr);
 
   /// Emit call to \c llvm.dbg.declare for an argument variable
   /// declaration.
-  void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI,
-                                unsigned ArgNo, CGBuilderTy &Builder);
+  llvm::DILocalVariable *EmitDeclareOfArgVariable(const VarDecl *Decl,
+                                                  llvm::Value *AI,
+                                                  unsigned ArgNo,
+                                                  CGBuilderTy &Builder);
 
   /// Emit call to \c llvm.dbg.declare for the block-literal argument
   /// to a block invocation function.
   void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
                                             StringRef Name, unsigned ArgNo,
                                             llvm::AllocaInst *LocalAddr,
                                             CGBuilderTy &Builder);
 
llvm::DIMacro *CreateMacro(llvm::DIMacroFile *Parent, unsigned MType,
                              SourceLocation LineLoc, StringRef Name,
                              StringRef Value);
 
   /// Create debug info for a file referenced by an #include directive.
   llvm::DIMacroFile *CreateTempMacroFile(llvm::DIMacroFile *Parent,
                                          SourceLocation LineLoc,
                                          SourceLocation FileLoc);
 
+  // get & set
+  void
+  copyCoroParamMappingsIfEmpty(ParamDecl2StmtTy &CoroutineParameterMappings) {
+    if (!this->CoroutineParameterMappings.empty())
+      return;
+    for (auto KeyVal : CoroutineParameterMappings) {
+      this->CoroutineParameterMappings.insert(KeyVal);
+    }
+  }
+
+  void appendParam2DILoc(const ParmVarDecl *Var,
+                         llvm::DILocalVariable *DILocalVar) {
+    ParamDbgMappings.insert(std::make_pair(Var, DILocalVar));
+  }
+
+  void appendParamDecl2Stmt(const ParmVarDecl *Param, const Stmt *MovParam) {
+    CoroutineParameterMappings.insert(std::make_pair(Param, MovParam));
+  }
+
+  void clearParamDecl2Stmt() { ParamDbgMappings.clear(); }
+
 private:
   /// Emit call to llvm.dbg.declare for a variable declaration.
   /// Returns a pointer to the DILocalVariable associated with the
   /// llvm.dbg.declare, or nullptr otherwise.
   llvm::DILocalVariable *EmitDeclare(const VarDecl *decl, llvm::Value *AI,
                                      llvm::Optional<unsigned> ArgNo,
                                      CGBuilderTy &Builder,
                                      const bool UsePointerValue = false);

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
   if (Loc.isInvalid()) {
     // The DIFile used by the CU is distinct from the main source file. Call
     // createFile() below for canonicalization if the source file was specified
     // with an absolute path.
     FileName = TheCU->getFile()->getFilename();
   } else {
     PresumedLoc PLoc = SM.getPresumedLoc(Loc);
     FileName = PLoc.getFilename();
-    
     if (FileName.empty()) {
       FileName = TheCU->getFile()->getFilename();
     } else {
       FileName = PLoc.getFilename();
     }
     FID = PLoc.getFileID();
   }
 
llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
   if (UsePointerValue) {
     assert(std::find(Expr.begin(), Expr.end(), llvm::dwarf::DW_OP_deref) ==
                Expr.end() &&
            "Debug info already contains DW_OP_deref.");
     Expr.push_back(llvm::dwarf::DW_OP_deref);
   }
 
   // Create the descriptor for the variable.
-  auto *D = ArgNo ? DBuilder.createParameterVariable(
-                        Scope, Name, *ArgNo, Unit, Line, Ty,
-                        CGM.getLangOpts().Optimize, Flags)
-                  : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
-                                                CGM.getLangOpts().Optimize,
-                                                Flags, Align);
+  llvm::DILocalVariable *D = nullptr;
+  if (ArgNo) {
+    D = DBuilder.createParameterVariable(Scope, Name, *ArgNo, Unit, Line, Ty,
+                                         CGM.getLangOpts().Optimize, Flags);
+  } else {
+    // for normal local variable, we will try to find out whether 'VD' is the
+    // copy parameter of coroutine.
+    // if yes, we would love to use DIVariable of the origin parameter instead
+    // of creating the new one.
+    // if no, it might a normal alloc, we just create a new one for it.
+
+    // 1. check whether the VD is move parameters
+    ParmVarDecl *PD = nullptr;
+    for (auto &Pair : CoroutineParameterMappings) {
+      if (const DeclStmt *DeclStmtPtr = dyn_cast_or_null<DeclStmt>(Pair.second)) {
+        const DeclGroupRef DeclGroup = DeclStmtPtr->getDeclGroup();
+        const Decl *Decl = DeclGroup.getSingleDecl();
+        if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(Decl))
+          if (Var == VD) {
+            PD = const_cast<ParmVarDecl *>(Pair.first);
+            break;
+          }
+      }
+    }
+
+    // 2. if yes, use the the same DIVariable of coroutine paarameters
+    if (PD != nullptr) {
+      for (auto &DbgPair : ParamDbgMappings)
+        if (DbgPair.first == PD) {
+          D = const_cast<llvm::DILocalVariable *>(DbgPair.second);
+          break;
+        }
+
+      // scope must be same
+      assert(D && "D should not be nullptr");
+
+      do {
+        // 2.1 if D is null, just bail out
+        if (!D)
+          break;
+
+        // 2.2 the scope of parameter and move-parameter should be distinct
+        // DISubprogram.
+        if (!isa<llvm::DISubprogram>(Scope) || !Scope->isDistinct()) {
+          D = nullptr;
+          break;
+        }
 
+        // 2.3 scope should be same
+        if (D->getScope() != Scope) {
+          D = nullptr;
+          break;
+        }
+      } while (0);
+    }
+
+    // 3. or we will create a new DIVariable for this Decl
+    if (!D)
+      D = DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
+                                      CGM.getLangOpts().Optimize, Flags, Align);
+  }
   // Insert an llvm.dbg.declare into the current block.
   DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
                          llvm::DILocation::get(CGM.getLLVMContext(), Line,
                                                Column, Scope, CurInlinedAt),
                          Builder.GetInsertBlock());
 
   return D;
 }
auto DL = llvm::DILocation::get(CGM.getLLVMContext(), Line, Column,
                                   LexicalBlockStack.back(), CurInlinedAt);
   auto *Expr = DBuilder.createExpression(addr);
   if (InsertPoint)
     DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
   else
     DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
 }
 
-void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
-                                           unsigned ArgNo,
-                                           CGBuilderTy &Builder) {
+llvm::DILocalVariable *
+CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
+                                      unsigned ArgNo, CGBuilderTy &Builder) {
   assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
-  EmitDeclare(VD, AI, ArgNo, Builder);
+  return EmitDeclare(VD, AI, ArgNo, Builder);
 }
 
 namespace {
 struct BlockLayoutChunk {
   uint64_t OffsetInBits;
   const BlockDecl::Capture *Capture;
 };
 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
   if (DoStore)
     EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
 
   setAddrOfLocalVar(&D, DeclPtr);
 
   // Emit debug info for param declarations in non-thunk functions.
   if (CGDebugInfo *DI = getDebugInfo()) {
     if (CGM.getCodeGenOpts().hasReducedDebugInfo() && !CurFuncIsThunk) {
-      DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
+      llvm::DILocalVariable *DILocalVar = DI->EmitDeclareOfArgVariable(
+          &D, DeclPtr.getPointer(), ArgNo, Builder);
+      if (auto *Var = dyn_cast_or_null<ParmVarDecl>(&D))
+        DI->appendParam2DILoc(Var, DILocalVar);
     }
   }
 
   if (D.hasAttr<AnnotateAttr>())
     EmitVarAnnotations(&D, DeclPtr.getPointer());
 
   // We can only check return value nullability if all arguments to the
   // function satisfy their nullability preconditions. This makes it necessary

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// non-closure context.
   const Decl *CurFuncDecl;
   /// CurCodeDecl - This is the inner-most code context, which includes blocks.
   const Decl *CurCodeDecl;
   const CGFunctionInfo *CurFnInfo;
   QualType FnRetTy;
   llvm::Function *CurFn = nullptr;
 
+  /// Args - Save Parameter Decl for coroutine
+  llvm::SmallVector<const ParmVarDecl *, 4> Args;
+
   // Holds coroutine data if the current function is a coroutine. We use a
   // wrapper to manage its lifetime, so that we don't have to define CGCoroData
   // in this header.
   struct CGCoroInfo {
     std::unique_ptr<CGCoroData> Data;
     CGCoroInfo();
     ~CGCoroInfo();
   };

clang/lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
   // Initialize helper which will detect jumps which can cause invalid lifetime
   // markers.
   if (Body && ShouldEmitLifetimeMarkers)
     Bypasses.Init(Body);
 
   // Emit the standard function prologue.
   StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin());
 
+  // temp save parameters
+  if (Body && isa<CoroutineBodyStmt>(Body))
+    for (auto ParamDecl : FD->parameters())
+      this->Args.push_back(ParamDecl);
+
   // Generate the body of the function.
   PGO.assignRegionCounters(GD, CurFn);
   if (isa<CXXDestructorDecl>(FD))
     EmitDestructorBody(Args);
   else if (isa<CXXConstructorDecl>(FD))
     EmitConstructorBody(Args);
   else if (getLangOpts().CUDA &&
            !getLangOpts().CUDAIsDevice &&

clang/test/CodeGenCoroutines/coro-dwarf.cpp

+// RUN: %clang_cc1 -std=c++2a -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -dwarf-version=4 -fno-split-dwarf-inlining -debug-info-kind=limited -emit-llvm -o - %s | FileCheck %s
+
+namespace std::experimental {
+template <typename... T> struct coroutine_traits;
+
+template <class Promise = void> struct coroutine_handle {
+  coroutine_handle() = default;
+  static coroutine_handle from_address(void *) noexcept;
+};
+template <> struct coroutine_handle<void> {
+  static coroutine_handle from_address(void *) noexcept;
+  coroutine_handle() = default;
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
+};
+}
+
+struct suspend_always {
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
+};
+
+template <typename... Args> struct std::experimental::coroutine_traits<void, Args...> {
+  struct promise_type {
+    void get_return_object() noexcept;
+    suspend_always initial_suspend() noexcept;
+    suspend_always final_suspend() noexcept;
+    void return_void() noexcept;
+    promise_type();
+    ~promise_type() noexcept;
+    void unhandled_exception() noexcept;
+  };
+};
+
+// TODO: Not supported yet
+struct CopyOnly {
+  int val;
+  CopyOnly(const CopyOnly&) noexcept;
+  CopyOnly(CopyOnly&&) = delete;
+  ~CopyOnly();
+};
+
+struct MoveOnly {
+  int val;
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly(MoveOnly&&) noexcept;
+  ~MoveOnly();
+};
+
+struct MoveAndCopy {
+  int val;
+  MoveAndCopy(const MoveAndCopy&)noexcept;
+  MoveAndCopy(MoveAndCopy&&) noexcept;
+  ~MoveAndCopy();
+};
+
+void consume(int,int,int) noexcept;
+
+void f_coro(int val, MoveOnly moParam, MoveAndCopy mcParam) {
+  consume(val, moParam.val, mcParam.val);
+  co_return;
+}
+
+// CHECK: !7 = distinct !DISubprogram(name: "f_coro", linkageName: "_Z6f_coroi8MoveOnly11MoveAndCopy"
+// CHECK: !44 = !DILocalVariable(name: "val", arg: 1, scope: !7, file: !8, line: 60, type: !11)
+// CHECK-NEXT: !45 = !DILocation(line: 60, column: 17, scope: !7)
+// CHECK-NEXT: !46 = !DILocalVariable(name: "moParam", arg: 2, scope: !7, file: !8, line: 60, type: !12)
+// CHECK-NEXT: !47 = !DILocation(line: 60, column: 31, scope: !7)
+// CHECK-NEXT: !48 = !DILocalVariable(name: "mcParam", arg: 3, scope: !7, file: !8, line: 60, type: !28)
+// CHECK-NEXT: !49 = !DILocation(line: 60, column: 52, scope: !7)
+// CHECK-NEXT: !50 = !DILocation(line: 60, column: 61, scope: !7)
+// CHECK-NEXT: !51 = !DILocation(line: 60, column: 6, scope: !7)
+// CHECK-NEXT: !52 = !DILocation(line: 0, scope: !7)
+// CHECK-NEXT: !53 = !DILocation(line: 62, column: 3, scope: !7)