maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[DEBUG-INFO] Change how we handle auto return types for lambda operator() to be consistent with gcc 

D70524 added support for auto return types for C++ member functions. I was
implementing support on the LLDB side for looking up the deduced type.

I ran into trouble with some cases with respect to lambdas. I looked into
how gcc was handling these cases and it appears gcc emits the deduced return type for lambdas.

So I am changing out behavior to match that.

Differential Revision: https://reviews.llvm.org/D123319
This commit is contained in:
Shafik Yaghmour 2022-04-21 14:56:22 -07:00
parent 414f84ba29
commit 5ff992bca2
2 changed files with 36 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
clang/lib/CodeGen/CGDebugInfo.cpp
View File

@ -1679,9 +1679,17 @@ CGDebugInfo::getOrCreateInstanceMethodType(QualType ThisPtr,
SmallVector<llvm::Metadata *, 16> Elts;
// First element is always return type. For 'void' functions it is NULL.
QualType temp = Func->getReturnType();
if (temp->getTypeClass() == Type::Auto && decl)
Elts.push_back(CreateType(cast<AutoType>(temp)));
else
if (temp->getTypeClass() == Type::Auto && decl) {
const AutoType *AT = cast<AutoType>(temp);
// It may be tricky in some cases to link the specification back the lambda
// call operator and so we skip emitting "auto" for lambdas. This is
// consistent with gcc as well.
if (AT->isDeduced() && ThisPtr->getPointeeCXXRecordDecl()->isLambda())
Elts.push_back(getOrCreateType(AT->getDeducedType(), Unit));
else
Elts.push_back(CreateType(AT));
} else
Elts.push_back(Args[0]);
// "this" pointer is always first argument.

25
clang/test/CodeGenCXX/no_auto_return_lambda.cpp Normal file
View File

@ -0,0 +1,25 @@
// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s
// We emit "auto" for deduced return types for member functions but we should
// not emitting "auto" for deduced return types for lambdas call function which
// will be implmented as operator() in a class type. This test will verify that
// behavior.
__attribute__((used)) int g() {
auto f = []() { return 10; };
return f();
}
// g() is not a member function so we should not emit "auto" for the deduced
// return type.
//
// CHECK: !DISubprogram(name: "g",{{.*}}, type: ![[FUN_TYPE:[0-9]+]],{{.*}}
// CHECK: ![[FUN_TYPE]] = !DISubroutineType(types: ![[TYPE_NODE:[0-9]+]])
// CHECK: ![[TYPE_NODE]] = !{![[INT_TYPE:[0-9]+]]}
// CHECK: ![[INT_TYPE]] = !DIBasicType(name: "int", {{.*}})
// operator() of the local lambda should have the same return type as g()
//
// CHECK: distinct !DISubprogram(name: "operator()",{{.*}}, type: ![[FUN_TYPE_LAMBDA:[0-9]+]],{{.*}}
// CHECK: ![[FUN_TYPE_LAMBDA]] = !DISubroutineType(types: ![[TYPE_NODE_LAMBDA:[0-9]+]])
// CHECK: ![[TYPE_NODE_LAMBDA]] = !{![[INT_TYPE:[0-9]+]], {{.*}}