Improve data formatter for libstdcpp unique_ptr

[tberghammer]

Summary

Improve data formatter for libstdcpp unique_ptr

• Fix infinite loop when there is a reference loop created from smart pointers
• Respect pointer depth argument in frame variable command
• Support dereferencing unique_ptr in the frame variable command
• Support operator-> for unique_ptr in the frame variable command

Note: After submitting this change I plan to add the same functionality for the other smart pointers as well (shared_ptr/weak_ptr, libcpp/libstdcpp)

[jingham]

It seems a little wrong to me to hook "IsPointerLikeObject" up to the ValueObject, and not to the Synthetic Child Provider for the type. After all, you are using the Synthetic Child Provider to provide the pointee object, so it should be the synthetic child provider that says it is presenting the bare type as a pointer-like thing. That's also more in line with the way the formatters work. They add structure to an underlying object independent of it's own structure. And the "can be treated like a pointer" bit is just another instance of this.

Also, if you did it that way, you could then add an "is_pointer_like" method to the Scripted Synthetic Child Provider, and this could be adopted by formatters for types lldb knows nothing about.

[labath]

Jim's comment definitely makes sense. If we happen to not use pretty-printer for the unique_ptr, it will not behave as a pointer-like object, and it should be formatted as a normal struct (I have no idea how much of a challenge it would be to implement it that way).

source/DataFormatters/ValueObjectPrinter.cpp

515

Is there are reason you are bundling the is-pointer-like with the is-ref flag instead of the is-ptr one (which would be more logical)? If there is one it certainly isn't obvious.

source/Target/StackFrame.cpp

637

SetErrorStringWithFormatv (and then you can drop the .AsCString from the deref_error).

[tberghammer]

My original plan was to add it to the synthetic child provider but after some thoughts and experimenting I concluded it doesn't really belongs to there because it should be responsible for generating new children while here we are modifying the way the parent object is printed. Also for this reason the implementation of it would be fairly complex because we would have to execute the synthetic child providers when the parent is referenced instead of when a child of it is queried. Also I think it won't be a good idea to add a new method to the synthetic child provider called "IsPointerLike" as it seems like introducing a very specific method to an interface what is currently quite generic. On the other hand I see the need for making the list of pointer like objects easily extensible from python.

One solution I can possibly see (haven't tried it out) is to add the following 2 new method to the value object:

• IsDeceremntPointerDepth: By default returns true for pointers and references and will return true for children generated for smart pointers
• IsDereferenceOfParent: By default returns false and will return true for the first child of the smart pointers

If we add these methods then the synthetic child provider can create a child where they will be returning true and then rely on them to implement this functionality. I think this solution would be a fairly clean design but would introduce a lot of new API for a small amount of extra functionality.

The third possible option is to somehow put the IsPointerLikeObject method into the summary provider as I think that would be the best place for it but I am not sure how to do it as it currently takes a ValueObject and then returns a string without too much flexibility. Saying that it should just flip some bit on the ValueObject itself seems like a quite big hack and would make the API hard to maintain so I don't really like this implementation.

What do you think?

source/DataFormatters/ValueObjectPrinter.cpp

515

Because I want to treat a unique_ptr the same way as a reference so if you just write so it is automatically dereferenced at the root level while not at other levels (we don't dereference pointers by default at any level). I can split it out to a separate bool if you think that helps

[labath]

In D30272#684610, @tberghammer wrote:

My original plan was to add it to the synthetic child provider but after some thoughts and experimenting I concluded it doesn't really belongs to there because it should be responsible for generating new children while here we are modifying the way the parent object is printed.

That is true, however. It still seems that this property should be somehow tied to the child provider, because it is only in the presence of the provider that the unique_ptr obtains its magic dereferencing properties. For example, if I do a frame variable -R X Y, where X is a std::unique_ptr and Y is a variable that happens to have the same layout (but a different name) as X, I would expect them to be printed identically, but it seems this will break that.

Also for this reason the implementation of it would be fairly complex because we would have to execute the synthetic child providers when the parent is referenced instead of when a child of it is queried. Also I think it won't be a good idea to add a new method to the synthetic child provider called "IsPointerLike" as it seems like introducing a very specific method to an interface what is currently quite generic. On the other hand I see the need for making the list of pointer like objects easily extensible from python.

One solution I can possibly see (haven't tried it out) is to add the following 2 new method to the value object:

• IsDeceremntPointerDepth: By default returns true for pointers and references and will return true for children generated for smart pointers
• IsDereferenceOfParent: By default returns false and will return true for the first child of the smart pointers

If we add these methods then the synthetic child provider can create a child where they will be returning true and then rely on them to implement this functionality. I think this solution would be a fairly clean design but would introduce a lot of new API for a small amount of extra functionality.

I like where this is going. I can see one possible problem here: the "IsDecrementPointerDepth"(*) property would now be a property of the child, whereas it really seems to be a property of the parent-child relationship. So we could have paths arriving at the same object and one will have this bit set and the other one will not. However this may not be a major problem as the ValueObjects seem to already know their parent anyway. I don't think the API blowup would be big. It seems you have had to add the IsPointerLikeObject method to quite a lot of classes for this implementation, and presumably these would not be needed if we go that way.

• I would try to keep "pointer depth" out of the name as this isn't something the values should need to worry about. Maybe something like IsObtainedByDereferencingAPointer, only shorter :)

source/DataFormatters/ValueObjectPrinter.cpp

515

Splitting out would definitely help as that gives you space to explain why you chose to treat this differently. That said, I am not entirely sure this needs special treatment. If the smart pointer should behave like a pointer then maybe we short format it as such too (i.e., display the pointed-to value only if it was explicitly asked for).

[jingham]

It definitely does not belong in the summary provider. So far as I can tell the main benefit of the IsPointerLike part of this thing is that you can do:

(lldb) frame var isPointerLikeThing->field_of_pointee->field_of_field_of_pointee

which the summary wouldn't help with.

I don't understand your argument about it not belonging in the summary provider. Maybe you can clarify?

It seems to me clear this is something that people who write synthetic child providers would want to be able to specify. So hard-coding it in the ValueObject with some special logic to turn it on in the CPP language runtime seems the wrong way to go.

You can also imagine wanting to write a synthetic provider that supports a more complex object - with several interesting synthetic-fields that also has a -> operator. For such an object, you would want:

(lldb) frame var such_an_object

to print all the synthetic fields, but then:

(lldb) frame var such_an_object->field_of_pointee->field_of_field_pointee

would also work. In that case you need to ask somebody which one of the synthetic fields is the "pointer like" one. That clearly has to be the parent's synthetic child provider, nobody else can know. Seems to me, the fact that you had to hard-code this to the 0'th synthetic child demonstrates that this was the wrong approach.

[tberghammer]

Thank you the comments. Based on them I have the following proposal:

• Add a new property to value object with name "m_is_dereference_of_parent"
• Add a new static method named "CreateCopy(name, valobj, is_dereference_of_parent)" to ValueObject and to SBValue what will create a new value object with the same type and data as the original value object with m_is_dereference_of_parent is set (I am open to suggestions for a better name). The reason I need to create a copy of the value object instead of modifying it in place is that if the dereferenced object is referenced without using a synthetic child provider then this flag shouldn't be set and the cleanest way to achieve this is to have 2 separate value object instances.
• From the synthetic child providers when we want to create a child what is the dereference of the parent (e.g. object for unique_ptr) then we will use the above CreateCopy method
• We will decrement the pointer depth during display every time we go through an object marked as m_is_dereference_of_parent
• In "frame variable" when the user uses "operator*" or "operator->" we return the first child with m_is_dereference_of_parent (possibly return an error if multiple child has it set)

I think this approach satisfies all the requirements we had (extensibility, dereference support, loop detection) and makes the API fairly clean. What do you think?

[jingham]

I also thought about having the synthetic child provider mark up the special child value objects when it made them. It bugs me a little but that you couldn't, for instance, have a synthetic child provider that doesn't display a child that is the result of the dereference in its view, but provides one when you do the dereference. And it looks like we're creating a system where we have somebody - the SCP - that knows what the dereference means to it, but then we lose the connection to that knowledge when we hand it out.

Explain a bit more why you need to create a copy? Anything that makes two versions of the same value that we have to keep in sync makes me nervous. For instance, one of the things we want to do in the future is make write-back possible for synthetic children. That would allow you to change values of std::vector elements in the Locals view of a GUI debugger (which would naturally be based on SBValues) just like you can with the non-synthetic SBValues. Also, how would the SCP know to update this copy when you've stepped in the debugger and the dereference now points to another pointee?

[tberghammer]

In D30272#686061, @jingham wrote:

I also thought about having the synthetic child provider mark up the special child value objects when it made them. It bugs me a little but that you couldn't, for instance, have a synthetic child provider that doesn't display a child that is the result of the dereference in its view, but provides one when you do the dereference. And it looks like we're creating a system where we have somebody - the SCP - that knows what the dereference means to it, but then we lose the connection to that knowledge when we hand it out.

The current system already supports it to have a synthetic child what doesn't displayed by default (can be referenced by name) so we can rely on that functionality to have a child what is the result of the dereference while not in view. We might have to gave it a special name (e.g. "$dereference") to make it easy to access it from the value object but I am not sure if it will be necessary (would certainly make the code simpler and more efficient).

I thought quite a bit about adding a Dereference method the the synthetic child provider but I am not convinced it is a good idea as it would complicate the API for it and I don't see how can we solve the problem I hit with the infinite smart pointer loop when I added a synthetic child displayed by default what contained the dereference of the pointed object without annotating the children itself.

Explain a bit more why you need to create a copy? Anything that makes two versions of the same value that we have to keep in sync makes me nervous. For instance, one of the things we want to do in the future is make write-back possible for synthetic children. That would allow you to change values of std::vector elements in the Locals view of a GUI debugger (which would naturally be based on SBValues) just like you can with the non-synthetic SBValues. Also, how would the SCP know to update this copy when you've stepped in the debugger and the dereference now points to another pointee?

Take the following (bit strange) example:

struct Foo {
  int x;
  int& operator*() { return x; }
}

If I implement a synthetic child provider for it then it will return the same value object as we would return when accessing the "x" member variable. If we annotate that value object as dereference of parent then it will effect the way we are displaying the "x" member variable even when it is not used through the "operator*". Creating a second separate ValueObject solves this problem by separating the 2 solving this issue. For updating it we will rely on the same logic what is currently used to update other synthetic children after a step what is not backed by an actual variable. My current idea is to create a new ValueObject with the memory address and compiler type copied from the original value object and it will be updated using the Update method of the synthetic child provider.

[tberghammer]

I wasn't able to get this approach working so I propose an alternative solution at https://reviews.llvm.org/D31366 for the infinite loop issue and I will create a separate CL for dereferencing smart pointers in "frame variable".

include/lldb/Core/ValueObject.h

public:
   virtual bool IsPointerType();
 
   virtual bool IsArrayType();
 
   virtual bool IsScalarType();
 
   virtual bool IsPointerOrReferenceType();
 
+  virtual bool IsPointerLikeObject();
+
   virtual bool IsPossibleDynamicType();
 
   bool IsNilReference();
 
   bool IsUninitializedReference();
 
   virtual bool IsBaseClass() { return false; }
 

include/lldb/DataFormatters/ValueObjectPrinter.h

protected:
   bool IsUninitialized();
 
   bool IsPtr();
 
   bool IsRef();
 
   bool IsInstancePointer();
 
+  bool IsPointerLikeObject();
+
   bool IsAggregate();
 
   bool PrintValidationMarkerIfNeeded();
 
   bool PrintValidationErrorIfNeeded();
 
   bool PrintLocationIfNeeded();
 
private:
   DumpValueObjectOptions::PointerDepth m_ptr_depth;
   uint32_t m_curr_depth;
   LazyBool m_should_print;
   LazyBool m_is_nil;
   LazyBool m_is_uninit;
   LazyBool m_is_ptr;
   LazyBool m_is_ref;
   LazyBool m_is_aggregate;
+  LazyBool m_is_pointer_like;
   LazyBool m_is_instance_ptr;
   std::pair<TypeSummaryImpl *, bool> m_summary_formatter;
   std::string m_value;
   std::string m_summary;
   std::string m_error;
   bool m_val_summary_ok;
   std::pair<TypeValidatorResult, std::string> m_validation;
 
   friend struct StringSummaryFormat;
 
   DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
 };
 
 } // namespace lldb_private
 
 #endif // lldb_ValueObjectPrinter_h_

include/lldb/Target/Language.h

-//===-- Language.h ---------------------------------------------------*- C++
-//-*-===//
+//===-- Language.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
   virtual bool GetFunctionDisplayName(const SymbolContext *sc,
                                       const ExecutionContext *exe_ctx,
                                       FunctionNameRepresentation representation,
                                       Stream &s);
 
   virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on,
                                                Stream &s);
 
+  // Returns true if the specified value object is a class type what behaves
+  // like a pointer in the language (e.g. std::shared_ptr in c++).
+  virtual bool IsPointerLikeObject(ValueObject &valobj);
+
   static void GetDefaultExceptionResolverDescription(bool catch_on,
                                                      bool throw_on, Stream &s);
 
   // These are accessors for general information about the Languages lldb knows
   // about:
 
   static lldb::LanguageType
   GetLanguageTypeFromString(const char *string) = delete;

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/TestDataFormatterStdUniquePtr.py

def test_with_run_command(self):
 
         self.expect("frame variable nup", substrs=['nup = nullptr'])
         self.expect("frame variable iup", substrs=['iup = 0x', 'object = 123'])
         self.expect("frame variable sup", substrs=['sup = 0x', 'object = "foobar"'])
 
         self.expect("frame variable ndp", substrs=['ndp = nullptr'])
         self.expect("frame variable idp", substrs=['idp = 0x', 'object = 456', 'deleter = ', 'a = 1', 'b = 2'])
         self.expect("frame variable sdp", substrs=['sdp = 0x', 'object = "baz"', 'deleter = ', 'a = 3', 'b = 4'])
-        
         self.assertEqual(123, frame.GetValueForVariablePath("iup.object").GetValueAsUnsigned())
         self.assertFalse(frame.GetValueForVariablePath("iup.deleter").IsValid())
 
         self.assertEqual('"foobar"', frame.GetValueForVariablePath("sup.object").GetSummary())
         self.assertFalse(frame.GetValueForVariablePath("sup.deleter").IsValid())
 
         self.assertEqual(456, frame.GetValueForVariablePath("idp.object").GetValueAsUnsigned())
         self.assertEqual('"baz"', frame.GetValueForVariablePath("sdp.object").GetSummary())
 
         idp_deleter = frame.GetValueForVariablePath("idp.deleter")
         self.assertTrue(idp_deleter.IsValid())
         self.assertEqual(1, idp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned())
         self.assertEqual(2, idp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned())
 
         sdp_deleter = frame.GetValueForVariablePath("sdp.deleter")
         self.assertTrue(sdp_deleter.IsValid())
         self.assertEqual(3, sdp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned())
         self.assertEqual(4, sdp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned())
+
+    @skipIfFreeBSD
+    @skipIfWindows  # libstdcpp not ported to Windows
+    @skipIfDarwin  # doesn't compile on Darwin
+    def test_recursive_unique_ptr(self):
+        # Tests that LLDB can handle when we have a loop in the unique_ptr
+        # reference chain and that it correctly handles the different options
+        # for the frame variable command in this case.
+        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 f1->fp",
+                    substrs=['data = 2', 'fp = 0x'])
+        self.expect("frame variable --ptr-depth=2 f1->fp",
+                    substrs=['data = 2', 'fp = 0x', 'object = {', 'data = 1'])
+        self.expect("frame variable f1->fp->data",
+                    substrs=['f1->fp->data = 2'])
+        self.expect("frame variable *f1->fp",
+                    substrs=['(Foo) *f1->fp', 'data = 2', 'fp = 0x'])
+

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/main.cpp

 #include <memory>
 #include <string>
 
 struct Deleter {
   void operator()(void *) {}
 
   int a;
   int b;
 };
 
+struct Foo {
+  int data;
+  std::unique_ptr<Foo> fp;
+};
+
 int main() {
   std::unique_ptr<char> nup;
   std::unique_ptr<int> iup(new int{123});
   std::unique_ptr<std::string> sup(new std::string("foobar"));
 
   std::unique_ptr<char, Deleter> ndp;
   std::unique_ptr<int, Deleter> idp(new int{456}, Deleter{1, 2});
   std::unique_ptr<std::string, Deleter> sdp(new std::string("baz"),
                                             Deleter{3, 4});
 
+  // Set up a structure where we have a loop in the unique_ptr chain.
+  Foo* f1 = new Foo{1};
+  Foo* f2 = new Foo{2};
+  f1->fp.reset(f2);
+  f2->fp.reset(f1);
+
   return 0; // Set break point at this line.
 }

source/Core/ValueObject.cpp

 bool ValueObject::IsIntegerType(bool &is_signed) {
   return GetCompilerType().IsIntegerType(is_signed);
 }
 
 bool ValueObject::IsPointerOrReferenceType() {
   return GetCompilerType().IsPointerOrReferenceType();
 }
 
+bool ValueObject::IsPointerLikeObject() {
+  Language *language = Language::FindPlugin(GetObjectRuntimeLanguage());
+  if (!language)
+    return false;
+  return language->IsPointerLikeObject(*this);
+}
+
 bool ValueObject::IsPossibleDynamicType() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
   if (process)
     return process->IsPossibleDynamicValue(*this);
   else
     return GetCompilerType().IsPossibleDynamicType(NULL, true, true);
 }
if (child_compiler_type && child_byte_size) {
         child_name.SetCString(child_name_str.c_str());
 
       m_deref_valobj = new ValueObjectChild(
           *this, child_compiler_type, child_name, child_byte_size,
           child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
           child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
           language_flags);
     }
+  } else if (IsPointerLikeObject() && HasSyntheticValue()) {
+    m_deref_valobj = GetSyntheticValue()->GetChildAtIndex(0, true).get();
   }
 
   if (m_deref_valobj) {
     error.Clear();
     return m_deref_valobj->GetSP();
   } else {
     StreamString strm;
     GetExpressionPath(strm, true);

source/DataFormatters/ValueObjectPrinter.cpp

void ValueObjectPrinter::Init(
   assert(m_orig_valobj && "cannot print a NULL ValueObject");
   assert(m_stream && "cannot print to a NULL Stream");
   m_should_print = eLazyBoolCalculate;
   m_is_nil = eLazyBoolCalculate;
   m_is_uninit = eLazyBoolCalculate;
   m_is_ptr = eLazyBoolCalculate;
   m_is_ref = eLazyBoolCalculate;
   m_is_aggregate = eLazyBoolCalculate;
+  m_is_pointer_like = eLazyBoolCalculate;
   m_is_instance_ptr = eLazyBoolCalculate;
   m_summary_formatter = {nullptr, false};
   m_value.assign("");
   m_summary.assign("");
   m_error.assign("");
   m_val_summary_ok = false;
   m_printed_instance_pointers =
       printed_instance_pointers

 
 bool ValueObjectPrinter::IsAggregate() {
   if (m_is_aggregate == eLazyBoolCalculate)
     m_is_aggregate =
         m_type_flags.Test(eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
   return m_is_aggregate == eLazyBoolYes;
 }
 
+bool ValueObjectPrinter::IsPointerLikeObject() {
+  if (m_is_pointer_like == eLazyBoolCalculate)
+    m_is_pointer_like =
+        m_valobj->IsPointerLikeObject() ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_pointer_like == eLazyBoolYes;
+}
+
 bool ValueObjectPrinter::IsInstancePointer() {
   // you need to do this check on the value's clang type
   if (m_is_instance_ptr == eLazyBoolCalculate)
     m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
                          eTypeInstanceIsPointer) != 0
                             ? eLazyBoolYes
                             : eLazyBoolNo;
   if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
case Mode::Never:
     return false;
   }
   return false;
 }
 
 bool ValueObjectPrinter::ShouldPrintChildren(
     bool is_failed_description,
     DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
-  const bool is_ref = IsRef();
   const bool is_ptr = IsPtr();
+  const bool is_ref_or_ptr_like = IsRef() || IsPointerLikeObject();
   const bool is_uninit = IsUninitialized();
 
   if (is_uninit)
     return false;
 
   // if the user has specified an element count, always print children
   // as it is explicit user demand being honored
   if (m_options.m_pointer_as_array)
     return true;
 
   TypeSummaryImpl *entry = GetSummaryFormatter();
 
   if (m_options.m_use_objc)
     return false;
 
   if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
     // We will show children for all concrete types. We won't show
     // pointer contents unless a pointer depth has been specified.
     // We won't reference contents unless the reference is the
     // root object (depth of zero).
 
     // Use a new temporary pointer depth in case we override the
     // current pointer depth below...
 
-    if (is_ptr || is_ref) {
+    if (is_ptr || is_ref_or_ptr_like) {
       // We have a pointer or reference whose value is an address.
       // Make sure that address is not NULL
       AddressType ptr_address_type;
       if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
         return false;
 
       const bool is_root_level = m_curr_depth == 0;
 
-      if (is_ref && is_root_level) {
+      if (is_ref_or_ptr_like && is_root_level) {
         // If this is the root object (depth is zero) that we are showing
         // and it is a reference, and no pointer depth has been supplied
         // print out what it references. Don't do this at deeper depths
         // otherwise we can end up with infinite recursion...
         return true;
       }
 
       return curr_ptr_depth.CanAllowExpansion(false, entry, m_valobj,
void ValueObjectPrinter::PrintChildrenPreamble() {
   }
 }
 
 void ValueObjectPrinter::PrintChild(
     ValueObjectSP child_sp,
     const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
   const uint32_t consumed_depth = (!m_options.m_pointer_as_array) ? 1 : 0;
   const bool does_consume_ptr_depth =
-      ((IsPtr() && !m_options.m_pointer_as_array) || IsRef());
+      ((IsPtr() && !m_options.m_pointer_as_array) || IsRef() ||
+       IsPointerLikeObject());
 
   DumpValueObjectOptions child_options(m_options);
   child_options.SetFormat(m_options.m_format)
       .SetSummary()
       .SetRootValueObjectName();
   child_options.SetScopeChecked(true)
       .SetHideName(m_options.m_hide_name)
       .SetHideValue(m_options.m_hide_value)

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
   std::unique_ptr<TypeScavenger> GetTypeScavenger() override;
   lldb::TypeCategoryImplSP GetFormatters() override;
 
   HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries() override;
 
   HardcodedFormatters::HardcodedSyntheticFinder
   GetHardcodedSynthetics() override;
 
+  bool IsPointerLikeObject(ValueObject &valobj) override;
+
   //------------------------------------------------------------------
   // Static Functions
   //------------------------------------------------------------------
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

g_formatters.push_back([](lldb_private::ValueObject &valobj,
       }
       return nullptr;
     });
 
   });
 
   return g_formatters;
 }
+
+bool CPlusPlusLanguage::IsPointerLikeObject(ValueObject &valobj) {
+  static RegularExpression unique_ptr_regex("^std::unique_ptr<.+>(( )?&)?$");
+
+  llvm::StringRef name(valobj.GetCompilerType().GetTypeName().GetStringRef());
+  if (unique_ptr_regex.Execute(name))
+    return true;
+  return false;
+}

source/Target/Language.cpp

 }
 
 void Language::GetDefaultExceptionResolverDescription(bool catch_on,
                                                       bool throw_on,
                                                       Stream &s) {
   s.Printf("Exception breakpoint (catch: %s throw: %s)",
            catch_on ? "on" : "off", throw_on ? "on" : "off");
 }
+
+bool Language::IsPointerLikeObject(ValueObject &valobj) { return false; }
+
 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
 Language::Language() {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 Language::~Language() {}

source/Target/StackFrame.cpp

if (!valobj_sp) {
     return ValueObjectSP();
   }
 
   // We are dumping at least one child
   while (separator_idx != std::string::npos) {
     // Calculate the next separator index ahead of time
     ValueObjectSP child_valobj_sp;
     const char separator_type = var_expr[0];
+    bool expr_is_ptr = false;
     switch (separator_type) {
     case '-':
+      expr_is_ptr = true;
       if (var_expr.size() >= 2 && var_expr[1] != '>')
         return ValueObjectSP();
 
       if (no_fragile_ivar) {
         // Make sure we aren't trying to deref an objective
         // C ivar if this is not allowed
         const uint32_t pointer_type_flags =
             valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
         if ((pointer_type_flags & eTypeIsObjC) &&
             (pointer_type_flags & eTypeIsPointer)) {
           // This was an objective C object pointer and
           // it was requested we skip any fragile ivars
           // so return nothing here
           return ValueObjectSP();
         }
       }
+
+      // If we have operator-> and it is a pointer like value object then we
+      // dereference it and then handle it as operator.
+      if (valobj_sp->IsPointerLikeObject()) {
+        Error deref_error;
+        ValueObjectSP deref_sp = valobj_sp->Dereference(deref_error);
+        if (deref_sp && error.Success()) {
+          valobj_sp = deref_sp;
+          expr_is_ptr = false;
+        } else {
+          error.SetErrorStringWithFormat(
+              "Failed to dereference a pointer like object: %s",
+              deref_error.AsCString());
+          return ValueObjectSP();
+        }
+      }
+
       var_expr = var_expr.drop_front(); // Remove the '-'
       LLVM_FALLTHROUGH;
     case '.': {
-      const bool expr_is_ptr = var_expr[0] == '>';
-
       var_expr = var_expr.drop_front(); // Remove the '.' or '>'
       separator_idx = var_expr.find_first_of(".-[");
       ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
 
       if (check_ptr_vs_member) {
         // We either have a pointer type and need to verify
         // valobj_sp is a pointer, or we have a member of a
         // class/union/struct being accessed with the . syntax