Author: Amy Huang Date: 2021-01-28T16:30:38-08:00 New Revision: d73564c510036b2d4f5858effdcd23fe54fc1063
URL: https://github.com/llvm/llvm-project/commit/d73564c510036b2d4f5858effdcd23fe54fc1063 DIFF: https://github.com/llvm/llvm-project/commit/d73564c510036b2d4f5858effdcd23fe54fc1063.diff LOG: [DebugInfo][CodeView] Use <lambda_n> as the display name for lambdas. Currently (for codeview) lambdas have a string like `<lambda_0>` in their mangled name, and don't have any display name. This change uses the `<lambda_0>` as the display name, which helps distinguish between lambdas in -gline-tables-only, since there are no linkage names there. It also changes how we display lambda names; previously we used `<unnamed-tag>`; now it will show `<lambda_0>`. I added a function to the mangling context code to create this string; for Itanium it just returns an empty string. Bug: https://bugs.llvm.org/show_bug.cgi?id=48432 Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D95187 Added: Modified: clang/include/clang/AST/Mangle.h clang/lib/AST/ItaniumMangle.cpp clang/lib/AST/MicrosoftMangle.cpp clang/lib/CodeGen/CGDebugInfo.cpp clang/test/CodeGenCXX/debug-info-codeview-unnamed.cpp clang/test/CodeGenCXX/debug-info-gline-tables-only-codeview.cpp Removed: ################################################################################ diff --git a/clang/include/clang/AST/Mangle.h b/clang/include/clang/AST/Mangle.h index 0e8d6dd53d8a6..f8f44853567fd 100644 --- a/clang/include/clang/AST/Mangle.h +++ b/clang/include/clang/AST/Mangle.h @@ -89,6 +89,17 @@ class MangleContext { return Result.first->second; } + uint64_t getAnonymousStructIdForDebugInfo(const NamedDecl *D) { + llvm::DenseMap<const NamedDecl *, uint64_t>::iterator Result = + AnonStructIds.find(D); + // The decl should already be inserted, but return 0 in case it is not. + if (Result == AnonStructIds.end()) + return 0; + return Result->second; + } + + virtual StringRef getLambdaString(const CXXRecordDecl *Lambda) = 0; + /// @name Mangler Entry Points /// @{ diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index 4420f6a2c1c38..265c2172801c4 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -203,6 +203,36 @@ class ItaniumMangleContextImpl : public ItaniumMangleContext { disc = discriminator-2; return true; } + + StringRef getLambdaString(const CXXRecordDecl *Lambda) override { + // This function matches the one in MicrosoftMangle, which returns + // the string that is used in lambda mangled names. + assert(Lambda->isLambda() && "RD must be a lambda!"); + llvm::SmallString<10> Name("<lambda"); + Decl *LambdaContextDecl = Lambda->getLambdaContextDecl(); + unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber(); + unsigned LambdaId; + const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl); + const FunctionDecl *Func = + Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr; + + if (Func) { + unsigned DefaultArgNo = + Func->getNumParams() - Parm->getFunctionScopeIndex(); + Name += llvm::utostr(DefaultArgNo); + Name += "_"; + } + + if (LambdaManglingNumber) + LambdaId = LambdaManglingNumber; + else + LambdaId = getAnonymousStructIdForDebugInfo(Lambda); + + Name += llvm::utostr(LambdaId); + Name += '>'; + return StringRef(Name); + } + /// @} }; diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp index 9eac3586c8715..aaaba62a0fd4e 100644 --- a/clang/lib/AST/MicrosoftMangle.cpp +++ b/clang/lib/AST/MicrosoftMangle.cpp @@ -228,6 +228,34 @@ class MicrosoftMangleContextImpl : public MicrosoftMangleContext { return true; } + StringRef getLambdaString(const CXXRecordDecl *Lambda) override { + assert(Lambda->isLambda() && "RD must be a lambda!"); + llvm::SmallString<10> Name("<lambda_"); + + Decl *LambdaContextDecl = Lambda->getLambdaContextDecl(); + unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber(); + unsigned LambdaId; + const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl); + const FunctionDecl *Func = + Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr; + + if (Func) { + unsigned DefaultArgNo = + Func->getNumParams() - Parm->getFunctionScopeIndex(); + Name += llvm::utostr(DefaultArgNo); + Name += "_"; + } + + if (LambdaManglingNumber) + LambdaId = LambdaManglingNumber; + else + LambdaId = getLambdaIdForDebugInfo(Lambda); + + Name += llvm::utostr(LambdaId); + Name += ">"; + return StringRef(Name); + } + unsigned getLambdaId(const CXXRecordDecl *RD) { assert(RD->isLambda() && "RD must be a lambda!"); assert(!RD->isExternallyVisible() && "RD must not be visible!"); @@ -238,6 +266,19 @@ class MicrosoftMangleContextImpl : public MicrosoftMangleContext { return Result.first->second; } + unsigned getLambdaIdForDebugInfo(const CXXRecordDecl *RD) { + assert(RD->isLambda() && "RD must be a lambda!"); + assert(!RD->isExternallyVisible() && "RD must not be visible!"); + assert(RD->getLambdaManglingNumber() == 0 && + "RD must not have a mangling number!"); + llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator Result = + LambdaIds.find(RD); + // The lambda should exist, but return 0 in case it doesn't. + if (Result == LambdaIds.end()) + return 0; + return Result->second; + } + /// Return a character sequence that is (somewhat) unique to the TU suitable /// for mangling anonymous namespaces. StringRef getAnonymousNamespaceHash() const { diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index 99944afaad14b..fb1d465fca4eb 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -317,8 +317,9 @@ StringRef CGDebugInfo::getClassName(const RecordDecl *RD) { if (const IdentifierInfo *II = RD->getIdentifier()) return II->getName(); - // The CodeView printer in LLVM wants to see the names of unnamed types: it is - // used to reconstruct the fully qualified type names. + // The CodeView printer in LLVM wants to see the names of unnamed types + // because they need to have a unique identifier. + // These names are used to reconstruct the fully qualified type names. if (CGM.getCodeGenOpts().EmitCodeView) { if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) { assert(RD->getDeclContext() == D->getDeclContext() && @@ -342,6 +343,14 @@ StringRef CGDebugInfo::getClassName(const RecordDecl *RD) { // associate typedef mangled in if they have one. Name = TND->getName(); + // Give lambdas a display name based on their name mangling. + if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) + if (CXXRD->isLambda()) { + StringRef LambdaName = + CGM.getCXXABI().getMangleContext().getLambdaString(CXXRD); + return internString(LambdaName); + } + if (!Name.empty()) { SmallString<256> UnnamedType("<unnamed-type-"); UnnamedType += Name; diff --git a/clang/test/CodeGenCXX/debug-info-codeview-unnamed.cpp b/clang/test/CodeGenCXX/debug-info-codeview-unnamed.cpp index dd4cc9cb47873..b4c79936ab33e 100644 --- a/clang/test/CodeGenCXX/debug-info-codeview-unnamed.cpp +++ b/clang/test/CodeGenCXX/debug-info-codeview-unnamed.cpp @@ -100,7 +100,7 @@ int main(int argc, char* argv[], char* arge[]) { // MSVC-SAME: ) // MSVC: [[TYPE_OF_FOUR]] = distinct !DICompositeType // MSVC-SAME: tag: DW_TAG_class_type - // MSVC-NOT: name: + // MSVC-SAME: name: "<lambda_0>" // MSVC-SAME: identifier: ".?AV<lambda_0>@?0??main@@9@" // MSVC-SAME: ) diff --git a/clang/test/CodeGenCXX/debug-info-gline-tables-only-codeview.cpp b/clang/test/CodeGenCXX/debug-info-gline-tables-only-codeview.cpp index 409b62da62c12..e3ca6bf8a1873 100644 --- a/clang/test/CodeGenCXX/debug-info-gline-tables-only-codeview.cpp +++ b/clang/test/CodeGenCXX/debug-info-gline-tables-only-codeview.cpp @@ -1,17 +1,26 @@ -// RUN: %clang_cc1 %s -gcodeview -debug-info-kind=line-tables-only -S \ -// RUN: -emit-llvm -o - | FileCheck %s +// RUN: %clang_cc1 %s -gcodeview -debug-info-kind=line-tables-only -emit-llvm \ +// RUN: -o - | FileCheck %s // Checks that clang with "-gline-tables-only" with CodeView emits some debug // info for variables and types when they appear in function scopes. namespace NS { struct C { void m() {} + // Test externally visible lambda. + void lambda2() { []() {}(); } + + // Test naming for function parameters. + void lambda_params(int x = [](){ return 0; }(), int y = [](){ return 1; }()) {} }; void f() {} } +// Test non- externally visible lambda. +auto lambda1 = []() { return 1; }; + NS::C c; + void test() { // CHECK: !DISubprogram(name: "f", scope: ![[NS:[0-9]+]], // CHECK-SAME: type: ![[F:[0-9]+]] @@ -21,10 +30,30 @@ void test() { NS::f(); // CHECK: ![[M:[0-9]+]] = distinct !DISubprogram(name: "m", scope: ![[C:[0-9]+]], - // CHECK-SAME: type: ![[MTYPE:[0-9]+]] + // CHECK-SAME: type: ![[MTYPE:[0-9]+]], // CHECK: ![[C]] = !DICompositeType(tag: DW_TAG_structure_type, name: "C", // CHECK-SAME: flags: DIFlagFwdDecl // CHECK-NOT: identifier // CHECK: ![[MTYPE]] = !DISubroutineType({{.*}}types: !{{.*}}) c.m(); + + // CHECK: !DISubprogram(name: "operator()", scope: ![[LAMBDA0:[0-9]+]], + // CHECK: ![[LAMBDA0]] = !DICompositeType(tag: DW_TAG_class_type, + // CHECK-SAME: name: "<lambda_0>", + // CHECK-SAME: flags: DIFlagFwdDecl + lambda1(); + + // CHECK: !DISubprogram(name: "operator()", scope: ![[LAMBDA1_1:[0-9]+]], + // CHECK: ![[LAMBDA1_1]] = !DICompositeType(tag: DW_TAG_class_type, + // CHECK-SAME: name: "<lambda_1_1>", + // CHECK: !DISubprogram(name: "operator()", scope: ![[LAMBDA2_1:[0-9]+]], + // CHECK: ![[LAMBDA2_1]] = !DICompositeType(tag: DW_TAG_class_type, + // CHECK-SAME: name: "<lambda_2_1>", + c.lambda_params(); + + // CHECK: !DISubprogram(name: "operator()", scope: ![[LAMBDA1:[0-9]+]], + // CHECK: ![[LAMBDA1]] = !DICompositeType(tag: DW_TAG_class_type, + // CHECK-SAME: name: "<lambda_1>", + // CHECK-SAME: flags: DIFlagFwdDecl + c.lambda2(); } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
