Add data formatter for libstdc++ shared_ptr and weak_ptr

[tberghammer]

Summary

Add data formatter for libstdc++ shared_ptr and weak_ptr

[tberghammer]

Apply clang-format

[granata.enrico]

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

665 ↗

(On Diff #62730)

Is there any reason to hide the children for a type that you provide synthetic children for?

[tberghammer]

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

665 ↗

(On Diff #62730)

Without hiding the children the content of the shard_ptr will be displayed 2 times. Once in the first line as part of the summary and then 2nd time as a children. I think it is cleaner if we display the value only once but it can make it more difficult to access to the content of the shared pointer.

If you think displaying the children is better then I am happy with that option too.

The 2 possible output for a type Foo:

(std::shared_ptr<Foo>) f = Foo @ 0x0000000000606118 {
  _M_ptr = 0x0000000000606118
}

(std::shared_ptr<Foo>) f = Foo @ 0x0000000000606118

The 2 possible output for an std::string:

(std::shared_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) s = "123456" {
  _M_ptr = "123456"
}

(std::shared_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >) s = "123456"

[granata.enrico]

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

665 ↗

(On Diff #62730)

Oh, I see. Yeah, I had to solve a similar problem for Swift Optionals.

Essentially, you're discovering that for shared_ptr<T>, T can have combinations of values, summaries, synthetic values, ...

Unfortunately right now there is no automated formatter for the concept of a box<T> that handles all those intricacies automatically for you. It would be a nice thing to add, but it's probably beyond the scope of your change

Feel free to pick your favorite solution for now, and I'll try to get to a universal box formatter at some point.

[tberghammer]

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

665 ↗

(On Diff #62730)

I decided to remove it to be in sync with the libc++ shared_ptr/weak_ptr summary provider but having a formatter for box<T> would be nice but I am not sure what should be the exact semantic of it. If you won't beat me with it I might take a look in the future but don't know when I will have time for it.

lldb/trunk/include/lldb/DataFormatters/VectorIterator.h

namespace formatters
             bool
             Update() override;
             
             bool
             MightHaveChildren() override;
             
             size_t
             GetIndexOfChildWithName(const ConstString &name) override;
-            
-            ~VectorIteratorSyntheticFrontEnd() override;
-            
         private:
             ExecutionContextRef m_exe_ctx_ref;
             ConstString m_item_name;
             lldb::ValueObjectSP m_item_sp;
         };
         
     } // namespace formatters
 } // namespace lldb_private
 
 #endif // liblldb_CF_h_

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/Makefile

+LEVEL = ../../../../../make
+
+CXX_SOURCES := main.cpp
+
+CXXFLAGS := -O0
+USE_LIBSTDCPP := 1
+
+# clang-3.5+ outputs FullDebugInfo by default for Darwin/FreeBSD
+# targets.  Other targets do not, which causes this test to fail.
+# This flag enables FullDebugInfo for all targets.
+ifneq (,$(findstring clang,$(CC)))
+  CFLAGS_EXTRAS += -fno-limit-debug-info
+endif
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py

+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class StdSmartPtrDataFormatterTestCase(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfFreeBSD
+    @skipIfWindows # libstdcpp not ported to Windows
+    def test_with_run_command(self):
+        self.build()
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+
+        self.expect("frame variable nsp", substrs = ['nsp = nullptr'])
+        self.expect("frame variable isp", substrs = ['isp = 123'])
+        self.expect("frame variable ssp", substrs = ['ssp = "foobar"'])
+
+        self.expect("frame variable nwp", substrs = ['nwp = nullptr'])
+        self.expect("frame variable iwp", substrs = ['iwp = 123'])
+        self.expect("frame variable swp", substrs = ['swp = "foobar"'])
+        
+        self.runCmd("continue")
+
+        self.expect("frame variable nsp", substrs = ['nsp = nullptr'])
+        self.expect("frame variable isp", substrs = ['isp = nullptr'])
+        self.expect("frame variable ssp", substrs = ['ssp = nullptr'])
+
+        self.expect("frame variable nwp", substrs = ['nwp = nullptr'])
+        self.expect("frame variable iwp", substrs = ['iwp = nullptr'])
+        self.expect("frame variable swp", substrs = ['swp = nullptr'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/main.cpp

+#include <memory>
+#include <string>
+
+int
+main()
+{
+    std::shared_ptr<char> nsp;
+    std::shared_ptr<int> isp(new int{123});
+    std::shared_ptr<std::string> ssp = std::make_shared<std::string>("foobar");
+
+    std::weak_ptr<char> nwp;
+    std::weak_ptr<int> iwp = isp;
+    std::weak_ptr<std::string> swp = ssp;
+
+    nsp.reset(); // Set break point at this line.
+    isp.reset();
+    ssp.reset();
+
+    return 0; // Set break point at this line.
+}

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

#ifndef LLDB_DISABLE_PYTHON
     cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
                                                            TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
                                                                                                      "size=${svar%#}")));
     cpp_category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$")),
                                                            TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
                                                                                                      "size=${svar%#}")));
 
     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
-    
     AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
+
+    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
+                    "std::shared_ptr synthetic children", ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags,
+                    true);
+    AddCXXSynthetic(cpp_category_sp, lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
+                    "std::weak_ptr synthetic children", ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags,
+                    true);
+
+    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
+                  "libstdc++ std::shared_ptr summary provider", ConstString("^std::shared_ptr<.+>(( )?&)?$"),
+                  stl_summary_flags, true);
+    AddCXXSummary(cpp_category_sp, lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
+                  "libstdc++ std::weak_ptr summary provider", ConstString("^std::weak_ptr<.+>(( )?&)?$"),
+                  stl_summary_flags, true);
 #endif
 }
 
 static void
 LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)
 {
     if (!cpp_category_sp)
         return;

lldb/trunk/source/Plugins/Language/CPlusPlus/LibStdcpp.h

namespace lldb_private {
     namespace formatters
     {
         bool
         LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libcstdc++ c++11 std::string
 
         bool
         LibStdcppWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libcstdc++ c++11 std::wstring
 
+        bool
+        LibStdcppSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options); // libstdc++ std::shared_ptr<> and std::weak_ptr<>
+
         SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
-        
         SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
+
+        SyntheticChildrenFrontEnd* LibStdcppSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
     } // namespace formatters
 } // namespace lldb_private
 
 #endif // liblldb_LibStdCpp_h_

lldb/trunk/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
+namespace
+{
+
 class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
 {
-public:
-    LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
+    /*
+     (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ibeg = {
+     (_Base_ptr) _M_node = 0x0000000100103910 {
+     (std::_Rb_tree_color) _M_color = _S_black
+     (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0
+     (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000
+     (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000
+     }
+     }
+     */
 
-    ~LibstdcppMapIteratorSyntheticFrontEnd() override = default;
+public:
+    explicit LibstdcppMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
     size_t
     CalculateNumChildren() override;
     
     lldb::ValueObjectSP
     GetChildAtIndex(size_t idx) override;
     
     bool
     Update() override;
     
     bool
     MightHaveChildren() override;
     
     size_t
     GetIndexOfChildWithName (const ConstString &name) override;
     
 private:
     ExecutionContextRef m_exe_ctx_ref;
     lldb::addr_t m_pair_address;
     CompilerType m_pair_type;
     lldb::ValueObjectSP m_pair_sp;
 };
 
-/*
- (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ibeg = {
- (_Base_ptr) _M_node = 0x0000000100103910 {
- (std::_Rb_tree_color) _M_color = _S_black
- (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0
- (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000
- (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000
- }
- }
- */
+class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd
+{
+public:
+    explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+    size_t
+    CalculateNumChildren() override;
+
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx) override;
+
+    bool
+    Update() override;
+
+    bool
+    MightHaveChildren() override;
+
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override;
+};
+
+} // end of anonymous namespace
 
 LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
     SyntheticChildrenFrontEnd(*valobj_sp),
     m_exe_ctx_ref(),
     m_pair_address(0),
     m_pair_type(),
     m_pair_sp()
 {
lldb_private::formatters::VectorIteratorSyntheticFrontEnd::VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
     m_item_name(item_name),
     m_item_sp()
 {
     if (valobj_sp)
         Update();
 }
 
 bool
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update()
+VectorIteratorSyntheticFrontEnd::Update()
 {
     m_item_sp.reset();
     
     ValueObjectSP valobj_sp = m_backend.GetSP();
     if (!valobj_sp)
         return false;
     
     if (!valobj_sp)
         return false;
     
     ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name,true));
     if (!item_ptr)
         return false;
     if (item_ptr->GetValueAsUnsigned(0) == 0)
         return false;
     Error err;
     m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
     m_item_sp = CreateValueObjectFromAddress("item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref, item_ptr->GetCompilerType().GetPointeeType());
     if (err.Fail())
         m_item_sp.reset();
     return false;
 }
 
 size_t
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::CalculateNumChildren ()
+VectorIteratorSyntheticFrontEnd::CalculateNumChildren()
 {
     return 1;
 }
 
 lldb::ValueObjectSP
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+VectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx)
 {
     if (idx == 0)
         return m_item_sp;
     return lldb::ValueObjectSP();
 }
 
 bool
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::MightHaveChildren ()
+VectorIteratorSyntheticFrontEnd::MightHaveChildren()
 {
     return true;
 }
 
 size_t
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name)
 {
     if (name == ConstString("item"))
         return 0;
     return UINT32_MAX;
 }
 
-lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd() = default;
-
 bool
 lldb_private::formatters::LibStdcppStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     const bool scalar_is_load_addr = true;
     AddressType addr_type;
     lldb::addr_t addr_of_string = valobj.GetAddressOf(scalar_is_load_addr, &addr_type);
     if (addr_of_string != LLDB_INVALID_ADDRESS)
     {
if (addr_of_string != LLDB_INVALID_ADDRESS)
                 break;
             case eAddressTypeInvalid:
             case eAddressTypeFile:
                 break;
         }
     }
     return false;
 }
+
+LibStdcppSharedPtrSyntheticFrontEnd::LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp)
+{
+    if (valobj_sp)
+        Update();
+}
+
+size_t
+LibStdcppSharedPtrSyntheticFrontEnd::CalculateNumChildren()
+{
+    return 1;
+}
+
+lldb::ValueObjectSP
+LibStdcppSharedPtrSyntheticFrontEnd::GetChildAtIndex(size_t idx)
+{
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return lldb::ValueObjectSP();
+
+    if (idx == 0)
+        return valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
+    else
+        return lldb::ValueObjectSP();
+}
+
+bool
+LibStdcppSharedPtrSyntheticFrontEnd::Update()
+{
+    return false;
+}
+
+bool
+LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren()
+{
+    return true;
+}
+
+size_t
+LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name)
+{
+    if (name == ConstString("_M_ptr"))
+        return 0;
+    return UINT32_MAX;
+}
+
+SyntheticChildrenFrontEnd *
+lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                                                     lldb::ValueObjectSP valobj_sp)
+{
+    return (valobj_sp ? new LibStdcppSharedPtrSyntheticFrontEnd(valobj_sp) : nullptr);
+}
+
+bool
+lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(ValueObject &valobj, Stream &stream,
+                                                               const TypeSummaryOptions &options)
+{
+    ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
+    if (!valobj_sp)
+        return false;
+
+    ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true));
+    if (!ptr_sp)
+        return false;
+
+    ValueObjectSP usecount_sp(
+        valobj_sp->GetChildAtNamePath({ConstString("_M_refcount"), ConstString("_M_pi"), ConstString("_M_use_count")}));
+    if (!usecount_sp)
+        return false;
+
+    if (ptr_sp->GetValueAsUnsigned(0) == 0 || usecount_sp->GetValueAsUnsigned(0) == 0)
+    {
+        stream.Printf("nullptr");
+        return true;
+    }
+
+    Error error;
+    ValueObjectSP pointee_sp = ptr_sp->Dereference(error);
+    if (pointee_sp && error.Success())
+    {
+        if (pointee_sp->DumpPrintableRepresentation(stream, ValueObject::eValueObjectRepresentationStyleSummary,
+                                                    lldb::eFormatInvalid,
+                                                    ValueObject::ePrintableRepresentationSpecialCasesDisable, false))
+        {
+            return true;
+        }
+    }
+
+    stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0));
+    return true;
+}