[LLDB] Fix for synthetic children memory leak

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 the managed objects in the cluster is destroyed. This means that no object in the cluster can store a shared pointer to another object in the cluster without creating a memory leak of the entire cluster. However, some of the synthetic children front-end implementations do exactly this; this patch fixes that.

Differential Revision: https://reviews.llvm.org/D68641

llvm-svn: 374195

1 files changed, 23 insertions, 14 deletions

diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp
index 8da7460f227..c86ab6be644 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp
@@ -30,47 +30,56 @@ public:
   ValueObjectSP GetChildAtIndex(size_t idx) override;
 
 private:
-  std::vector<ValueObjectSP> m_elements;
-  ValueObjectSP m_base_sp;
+  // 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).
+  std::vector<ValueObject*> m_elements;
+  ValueObject* m_base = nullptr;
 };
 }
 
 bool TupleFrontEnd::Update() {
   m_elements.clear();
-  m_base_sp = m_backend.GetChildMemberWithName(ConstString("__base_"), true);
-  if (! m_base_sp) {
+  m_base = nullptr;
+
+  ValueObjectSP base_sp;
+  base_sp = m_backend.GetChildMemberWithName(ConstString("__base_"), true);
+  if (!base_sp) {
     // Pre r304382 name of the base element.
-    m_base_sp = m_backend.GetChildMemberWithName(ConstString("base_"), true);
+    base_sp = m_backend.GetChildMemberWithName(ConstString("base_"), true);
   }
-  if (! m_base_sp)
+  if (!base_sp)
     return false;
-  m_elements.assign(m_base_sp->GetCompilerType().GetNumDirectBaseClasses(),
-                    ValueObjectSP());
+  m_base = base_sp.get();
+  m_elements.assign(base_sp->GetCompilerType().GetNumDirectBaseClasses(),
+                    nullptr);
   return false;
 }
 
 ValueObjectSP TupleFrontEnd::GetChildAtIndex(size_t idx) {
   if (idx >= m_elements.size())
     return ValueObjectSP();
-  if (!m_base_sp)
+  if (!m_base)
     return ValueObjectSP();
   if (m_elements[idx])
-    return m_elements[idx];
+    return m_elements[idx]->GetSP();
 
   CompilerType holder_type =
-      m_base_sp->GetCompilerType().GetDirectBaseClassAtIndex(idx, nullptr);
+      m_base->GetCompilerType().GetDirectBaseClassAtIndex(idx, nullptr);
   if (!holder_type)
     return ValueObjectSP();
-  ValueObjectSP holder_sp = m_base_sp->GetChildAtIndex(idx, true);
+  ValueObjectSP holder_sp = m_base->GetChildAtIndex(idx, true);
   if (!holder_sp)
     return ValueObjectSP();
 
   ValueObjectSP elem_sp = holder_sp->GetChildAtIndex(0, true);
   if (elem_sp)
     m_elements[idx] =
-        elem_sp->Clone(ConstString(llvm::formatv("[{0}]", idx).str()));
+        elem_sp->Clone(ConstString(llvm::formatv("[{0}]", idx).str())).get();
 
-  return m_elements[idx];
+  return m_elements[idx]->GetSP();
 }
 
 SyntheticChildrenFrontEnd *