[lldb][TypeSystemClang] Use the CXXFunctionPointerSummaryProvider for member-function pointers

[Michael137]

Summary

With this patch member-function pointers are formatted using
CXXFunctionPointerSummaryProvider.

This turns,

(lldb) v pointer_to_member_func
(void (Foo::*)()) ::pointer_to_member_func = 0x00000000000000000000000100003f94

into

(lldb) v pointer_to_member_func
(void (Foo::*)()) ::pointer_to_member_func = 0x00000000000000000000000100003f94 (a.out`Foo::member_func() at main.cpp:3)

[aprantl]

Nice.

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

1394

The more often you are using this construct the more comfortable I'm getting with it :-)

[stella.stamenova]

Looks like either this change or D125241 broke the Windows lldb bot: https://lab.llvm.org/buildbot/#/builders/83/builds/29800. Since it's been broken for a few days, if you can't address the failure soon, I'll go ahead and revert the changes to bring it back to green.

[Michael137]

In D145242#4173577, @stella.stamenova wrote:

Looks like either this change or D125241 broke the Windows lldb bot: https://lab.llvm.org/buildbot/#/builders/83/builds/29800. Since it's been broken for a few days, if you can't address the failure soon, I'll go ahead and revert the changes to bring it back to green.

Ah thanks for pointing it out. Thought I had fixed it with https://reviews.llvm.org/rG96e39fdbb90b26191fc79b6226f299e3c10e559b

Will check on my Windows machine. But feel free to revert, since I'm only going to be able to look at it tomorrow

[stella.stamenova]

In D145242#4173592, @Michael137 wrote:

In D145242#4173577, @stella.stamenova wrote:

Looks like either this change or D125241 broke the Windows lldb bot: https://lab.llvm.org/buildbot/#/builders/83/builds/29800. Since it's been broken for a few days, if you can't address the failure soon, I'll go ahead and revert the changes to bring it back to green.

Ah thanks for pointing it out. Thought I had fixed it with https://reviews.llvm.org/rG96e39fdbb90b26191fc79b6226f299e3c10e559b

Will check on my Windows machine. But feel free to revert, since I'm only going to be able to look at it tomorrow

The lldb bot I pointed you is not an arm buildbot, it's x64. Also the test you fixed is ast-types, but there were actually two failing tests - TestDataFormatterCpp.py is still failing.

[Michael137]

This comment was removed by Michael137.

[labath]

You may want to check that pointers to virtual functions get printed here. In particular, that 0x00000000000000010000000000000000 (pointer to the first virtual function) does not get printed as nullptr or something like that (due to the truncation of the 128-bit value to zero).

[Michael137]

• Rebase on latest test changes

lldb/include/lldb/Symbol/CompilerType.h

public:
   size_t GetNumberOfFunctionArguments() const;
 
   CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
 
   bool IsVariadicFunctionType() const;
 
   bool IsFunctionPointerType() const;
 
+  bool IsMemberFunctionPointerType() const;
+
   bool
   IsBlockPointerType(CompilerType *function_pointer_type_ptr = nullptr) const;
 
   bool IsIntegerType(bool &is_signed) const;
 
   bool IsEnumerationType(bool &is_signed) const;
 
   bool IsIntegerOrEnumerationType(bool &is_signed) const;

lldb/include/lldb/Symbol/TypeSystem.h

#endif
   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType
   GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
                              const size_t index) = 0;
 
   virtual bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) = 0;
 
+  virtual bool
+  IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) = 0;
+
   virtual bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
                                   CompilerType *function_pointer_type_ptr) = 0;
 
   virtual bool IsIntegerType(lldb::opaque_compiler_type_t type,
                              bool &is_signed) = 0;
 
   virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                                  bool &is_signed) {

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

llvm::call_once(g_initialize, []() -> void {
     g_formatters.push_back(
         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
            FormatManager &) -> TypeSummaryImpl::SharedPointer {
           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
               new CXXFunctionSummaryFormat(
                   TypeSummaryImpl::Flags(),
                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
                   "Function pointer summary provider"));
-          if (valobj.GetCompilerType().IsFunctionPointerType()) {
+          if (CompilerType CT = valobj.GetCompilerType();
+              CT.IsFunctionPointerType() || CT.IsMemberFunctionPointerType()) {
             return formatter_sp;
           }
           return nullptr;
         });
     g_formatters.push_back(
         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

#endif
   size_t
   GetNumberOfFunctionArguments(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type,
                                           const size_t index) override;
 
   bool IsFunctionPointerType(lldb::opaque_compiler_type_t type) override;
 
+  bool IsMemberFunctionPointerType(lldb::opaque_compiler_type_t type) override;
+
   bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
                           CompilerType *function_pointer_type_ptr) override;
 
   bool IsIntegerType(lldb::opaque_compiler_type_t type,
                      bool &is_signed) override;
 
   bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                          bool &is_signed) override;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

case clang::Type::RValueReference: {
       if (reference_type)
         return IsTypeImpl(reference_type->getPointeeType().getAsOpaquePtr(), predicate);
     } break;
     }
   }
   return false;
 }
 
+bool TypeSystemClang::IsMemberFunctionPointerType(
+    lldb::opaque_compiler_type_t type) {
+  auto isMemberFunctionPointerType = [](clang::QualType qual_type) {
+    return qual_type->isMemberFunctionPointerType();
+  };
+
+  return IsTypeImpl(type, isMemberFunctionPointerType);
+}
+
 bool TypeSystemClang::IsFunctionPointerType(lldb::opaque_compiler_type_t type) {
   auto isFunctionPointerType = [](clang::QualType qual_type) {
     return qual_type->isFunctionPointerType();
   };
 
   return IsTypeImpl(type, isFunctionPointerType);
 }
 

lldb/source/Symbol/CompilerType.cpp

 
 bool CompilerType::IsFunctionPointerType() const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->IsFunctionPointerType(m_type);
   return false;
 }
 
+bool CompilerType::IsMemberFunctionPointerType() const {
+  if (IsValid())
+    if (auto type_system_sp = GetTypeSystem())
+      return type_system_sp->IsMemberFunctionPointerType(m_type);
+  return false;
+}
+
 bool CompilerType::IsBlockPointerType(
     CompilerType *function_pointer_type_ptr) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->IsBlockPointerType(m_type, function_pointer_type_ptr);
   return false;
 }
 

lldb/test/API/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

def test_mem_func_ptr_formats(self):
         lldbutil.run_to_source_breakpoint(self, "Break in has_local_mem_func_pointers", lldb.SBFileSpec("main.cpp"))
 
         # FIXME: don't format pointer to members as bytes, but rather as regular pointers
         self.expect(
             "frame variable member_ptr",
             patterns=['member_ptr = 0x[0-9a-z]+'])
         self.expect(
             "frame variable member_func_ptr",
-            patterns=['member_func_ptr = 0x[0-9a-z]+'])
+            patterns=['member_func_ptr = 0x[0-9a-z]+'],
+            substrs=['(a.out`IUseCharStar::member_func(int) at main.cpp:61)'])
         self.expect(
             "frame variable ref_to_member_func_ptr",
-            patterns=['ref_to_member_func_ptr = 0x[0-9a-z]+'])
+            patterns=['ref_to_member_func_ptr = 0x[0-9a-z]+'],
+            substrs=['(a.out`IUseCharStar::member_func(int) at main.cpp:61)'])
         self.expect(
             "frame variable virt_member_func_ptr",
-            patterns=['virt_member_func_ptr = 0x[0-9a-z]+'])
+            patterns=['virt_member_func_ptr = 0x[0-9a-z]+$'])