[lldb][DataFormatter] Add dereference support to libstdcpp std::shared_ptr formatter

[Michael137]

Summary

This mimicks the implementation of the libstd++ and libc++ std::unique_ptr
formatters.

This has been attempted several years ago in
0789722d85cf1f1fdbe2ffb2245ea0ba034a9f94 but was reverted in
e7dd3972094c2f2fb42dc9d4d5344e54a431e2ce.

The difference to the original patch is that we now maintain
a $$dereference$$ member and we only store weak pointers
to the other children inside the synthetic frontend. This is
what the libc++ formatters do to prevent the recursion mentioned
in the revert commit.

This patch addresses https://github.com/llvm/llvm-project/issues/62825

[Michael137]

Fix expected string in test

[Michael137]

Committed in https://reviews.llvm.org/rG44bb442fd5be

[antmo]

Hi Michael,
lldb-aarch64-windows bot is broken since yesterday: https://lab.llvm.org/buildbot/#/builders/219/builds/3012
I suspect this is due to this commit. Could you please take a look at this ?

[Michael137]

Any chance someone with a working aarch64 windows 10 setup could take a look? (@compnerd ?) Or let me know how I might be able to set this up.

The place where we seem to crash in TestVarPath.py is:

# Make sure we don't crash when looking for non existant child     
# in type with synthetic children. This used to cause a crash.     
v = frame.GetValueForVariablePath('pt_sp->not_valid_child')        
self.assertTrue(v.GetError().Fail(),                               
                "Make sure we don't find 'pt_sp->not_valid_child'")

A crash that was previously addressed in 0d6f681292d5a. Interestingly, the code path that was added in that patch is the one that we used to take before adding support for $$dereference$$ in this patch.

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

   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
+private:
+
+  // The lifetime of a ValueObject and all its derivative ValueObjects
+  // (children, clones, etc.) is managed by a ClusterManager. These
+  // objects are only destroyed when every shared pointer to any of them
+  // is destroyed, so we must not store a shared pointer to any ValueObject
+  // derived from our backend ValueObject (since we're in the same cluster).
+  ValueObject* m_ptr_obj = nullptr; // Underlying pointer (held, not owned)
+  ValueObject* m_obj_obj = nullptr; // Underlying object (held, not owned)
 };
 
 } // end of anonymous namespace

 
 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();
+    return m_ptr_obj->GetSP();
+  if (idx == 1)
+    return m_obj_obj->GetSP();
+
+  return lldb::ValueObjectSP();
 }
 
-bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; }
+bool LibStdcppSharedPtrSyntheticFrontEnd::Update() {
+  auto backend = m_backend.GetSP();
+  if (!backend)
+    return false;
+
+  auto valobj_sp = backend->GetNonSyntheticValue();
+  if (!valobj_sp)
+    return false;
+
+  auto ptr_obj_sp = valobj_sp->GetChildMemberWithName(ConstString("_M_ptr"), true);
+  if (!ptr_obj_sp)
+    return false;
+
+  m_ptr_obj = ptr_obj_sp->Clone(ConstString("pointer")).get();
+
+  if (m_ptr_obj) {
+    Status error;
+    ValueObjectSP obj_obj = m_ptr_obj->Dereference(error);
+    if (error.Success()) {
+      m_obj_obj = obj_obj->Clone(ConstString("object")).get();
+    }
+  }
+
+  return false;
+}
 
 bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; }
 
 size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {
-  if (name == "_M_ptr")
+  if (name == "pointer")
     return 0;
+  if (name == "object" || name == "$$dereference$$")
+    return 1;
   return UINT32_MAX;
 }
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py

         self.expect("frame variable iwp", substrs=['iwp = 123'])
         self.expect("frame variable swp", substrs=['swp = "foobar"'])
 
+        self.expect("frame variable *nsp", substrs=['*nsp = <parent is NULL>'])
+        self.expect("frame variable *isp", substrs=['*isp = 123'])
+        self.expect("frame variable *ssp", substrs=['*ssp = "foobar"'])
+        self.expect("frame variable *fsp", substrs=['*fsp = (mem = 5)'])
+
+        self.expect("frame variable fsp->mem", substrs=['(int) fsp->mem = 5'])
+
         self.runCmd("continue")
 
         self.expect("frame variable nsp", substrs=['nsp = nullptr'])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/main.cpp

 #include <memory>
 #include <string>
 
+struct Foo {
+  int mem = 5;
+};
+
 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::shared_ptr<Foo> fsp = std::make_shared<Foo>();
 
     std::weak_ptr<char> nwp;
     std::weak_ptr<int> iwp = isp;

     nsp.reset(); // Set break point at this line.
     isp.reset();
     ssp.reset();
+    fsp.reset();
 
     return 0; // Set break point at this line.
 }