[Lldb-commits] [lldb] [lldb] Infer MSInheritanceAttr for CXXRecordDecl with DWARF on Windows (PR #115177)
Stefan Gränitz via lldb-commits
lldb-commits at lists.llvm.org
Mon Nov 18 01:50:20 PST 2024
https://github.com/weliveindetail updated https://github.com/llvm/llvm-project/pull/115177
>From 2c8f5571a4fbe87b50d395fe93f7c4657685e683 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Stefan=20Gr=C3=A4nitz?= <stefan.graenitz at gmail.com>
Date: Fri, 8 Nov 2024 17:16:20 +0100
Subject: [PATCH] [lldb] Infer MSInheritanceAttr for CXXRecordDecl from DWARF
on Windows
---
.../SymbolFile/DWARF/DWARFASTParserClang.cpp | 11 ++++
.../TypeSystem/Clang/TypeSystemClang.cpp | 12 +++-
.../SymbolFile/DWARF/x86/member-pointers.cpp | 65 +++++++++++++++----
3 files changed, 74 insertions(+), 14 deletions(-)
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
index b69b433fdeb67a..d9bdeb560e1220 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
@@ -43,6 +43,7 @@
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Type.h"
+#include "clang/Basic/Specifiers.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Demangle/Demangle.h"
@@ -2138,6 +2139,16 @@ bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
if (record_decl)
GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
+ // DWARF doesn't have the attribute, but we can infer the value the same way
+ // as Clang Sema does. It's required to calculate the size of pointers to
+ // member functions of this type.
+ if (m_ast.getASTContext().getTargetInfo().getCXXABI().isMicrosoft()) {
+ auto IM = record_decl->calculateInheritanceModel();
+ record_decl->addAttr(clang::MSInheritanceAttr::CreateImplicit(
+ m_ast.getASTContext(), true, {},
+ clang::MSInheritanceAttr::Spelling(IM)));
+ }
+
// Now parse all contained types inside of the class. We make forward
// declarations to all classes, but we need the CXXRecordDecl to have decls
// for all contained types because we don't get asked for them via the
diff --git a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
index c5249088a291b8..1a77c7cf9161a0 100644
--- a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
+++ b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
@@ -2772,7 +2772,17 @@ static bool GetCompleteQualType(clang::ASTContext *ast,
allow_completion);
case clang::Type::MemberPointer:
- return !qual_type.getTypePtr()->isIncompleteType();
+ // MS C++ ABI requires type of the class to be complete of which the pointee
+ // is a member.
+ if (ast->getTargetInfo().getCXXABI().isMicrosoft()) {
+ auto *MPT = qual_type.getTypePtr()->castAs<clang::MemberPointerType>();
+ if (MPT->getClass()->isRecordType())
+ GetCompleteRecordType(ast, clang::QualType(MPT->getClass(), 0),
+ allow_completion);
+
+ return !qual_type.getTypePtr()->isIncompleteType();
+ }
+ break;
default:
break;
diff --git a/lldb/test/Shell/SymbolFile/DWARF/x86/member-pointers.cpp b/lldb/test/Shell/SymbolFile/DWARF/x86/member-pointers.cpp
index c7bd95774d33f7..a12892305798a8 100644
--- a/lldb/test/Shell/SymbolFile/DWARF/x86/member-pointers.cpp
+++ b/lldb/test/Shell/SymbolFile/DWARF/x86/member-pointers.cpp
@@ -2,23 +2,62 @@
// Itanium ABI:
// RUN: %clang --target=x86_64-pc-linux -gdwarf -c -o %t_linux.o %s
-// RUN: %lldb -f %t_linux.o -b -o "target variable mp" | FileCheck %s
+// RUN: %lldb -f %t_linux.o -b -o "target variable s1 s2 m1 m2 v1 v2 v3 v4" | FileCheck --check-prefix=CHECK-GNU %s
//
-// CHECK: (char SI::*) mp = 0x0000000000000000
+// CHECK-GNU: (void (Single1::*)()) s1 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Single2::*)()) s2 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Multiple1::*)()) m1 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Multiple2::*)()) m2 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Virtual1::*)()) v1 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Virtual2::*)()) v2 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Virtual3::*)()) v3 = 0x00000000000000000000000000000000
+// CHECK-GNU: (void (Virtual4::*)()) v4 = 0x00000000000000000000000000000000
// Microsoft ABI:
-// RUN: %clang_cl --target=x86_64-windows-msvc -c -gdwarf -o %t_win.obj -- %s
-// RUN: lld-link /out:%t_win.exe %t_win.obj /nodefaultlib /entry:main /debug
-// RUN: %lldb -f %t_win.exe -b -o "target variable mp" | FileCheck --check-prefix=CHECK-MSVC %s
+// RUN: %clang_cl --target=x86_64-windows-msvc -c -gdwarf -o %t_win.obj /GS- -- %s
+// RUN: lld-link /out:%t_win.exe %t_win.obj /entry:main /debug /nodefaultlib
+// RUN: %lldb -f %t_win.exe -b -o "target variable s1 s2 m1 m2 v1 v2 v3 v4" | FileCheck --check-prefix=CHECK-MSVC %s
//
-// DWARF has no representation of MSInheritanceAttr, so we cannot determine the size
-// of member-pointers yet. For the moment, make sure we don't crash on such variables.
-// CHECK-MSVC: error: Unable to determine byte size.
+// CHECK-MSVC: (void (Single1::*)()) s1 = 0x0000000000000000
+// CHECK-MSVC: (void (Single2::*)()) s2 = 0x0000000000000000
+// CHECK-MSVC: (void (Multiple1::*)()) m1 = 0x00000000000000000000000000000000
+// CHECK-MSVC: (void (Multiple2::*)()) m2 = 0x00000000000000000000000000000000
+// CHECK-MSVC: (void (Virtual1::*)()) v1 = 0xffffffff000000000000000000000000
+// CHECK-MSVC: (void (Virtual2::*)()) v2 = 0xffffffff000000000000000000000000
+// CHECK-MSVC: (void (Virtual3::*)()) v3 = 0xffffffff000000000000000000000000
+// CHECK-MSVC: (void (Virtual4::*)()) v4 = 0xffffffff000000000000000000000000
-struct SI {
- char si;
-};
+// clang-format off
+struct Single1 { void s1() {} };
+struct Single2 : Single1 { void s2() {} };
-char SI::*mp = &SI::si;
+struct Helper {};
+struct Multiple1 : Single1, Helper { void m1() {} };
+struct Multiple2 : Multiple1 { void m2() {} };
-int main() { return 0; }
+struct Virtual1 : virtual Single1 { void v1() {} };
+struct Virtual2 : Virtual1 { void v2() {} };
+struct Virtual3 : virtual Multiple1 { void v3() {} };
+struct Virtual4 : Virtual1, Helper { void v4() {} };
+
+void (Single1::*s1)() = nullptr;
+void (Single2::*s2)() = nullptr;
+void (Multiple1::*m1)() = nullptr;
+void (Multiple2::*m2)() = nullptr;
+void (Virtual1::*v1)() = nullptr;
+void (Virtual2::*v2)() = nullptr;
+void (Virtual3::*v3)() = nullptr;
+void (Virtual4::*v4)() = nullptr;
+
+int main(int argc, char *argv[]) {
+ // We need to force emission of type info to DWARF. That's reasonable, because
+ // Clang doesn't know that we need it to infer member-pointer sizes. We could
+ // probably teach Clang to do so, but in most real-world scenarios this might
+ // be a non-issue.
+ Virtual1 vi1;
+ Virtual2 vi2;
+ Virtual3 vi3;
+ Virtual4 vi4;
+ int sum = sizeof(Single2) + sizeof(Multiple2);
+ return argc < sum ? 0 : 1;
+}
More information about the lldb-commits
mailing list