[formatters] Add a formatter for libstdc++ optional

[wallace]

Summary

Besides adding the formatter and the summary, this makes the libcxx
tests also work for this case.

This is the polished version of https://reviews.llvm.org/D114266,
authored by Danil Stefaniuc.

[wallace]

nit

[labath]

I'm seeing some very funky behavior after this patch. My machine has both libc++ and libstdc++, so both versions of this test run normally, and then libstdc++ fails. If I run just the libstdc++ version then it passes just fine. If I change the test order so that the libstdc++ version is run first, then the *libc++* version fails instead...

lldb/examples/synthetic/gnu_libstdcpp.py

25

I assume this is relying on the fact that _M_engaged can only contain values 1 and 0. While this may be true for normal situations, people tend to use debuggers precisely in the situations where things are not "normal". And it'd be good if e.g. a user's memory corruption bug (which for example overwrites this field) does not make the debugger go haywire. You most likely cannot format the value correctly if that happens, but you can at least avoid printing 3195786238 children in those cases.
One way to do that would be to rename this field to engaged and implement the num_children method as return self.engaged ? 1 : 0

lldb/source/API/SBValue.cpp

1442

https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

lldb/bindings/interface/SBValue.i

@return
         An SBData with the contents of this SBValue, on success.
         An empty SBData otherwise.") GetData;
     lldb::SBData
     GetData ();
 
     bool
     SetData (lldb::SBData &data, lldb::SBError& error);
 
+    lldb::SBValue
+    Clone(const char *new_name);
+
   lldb::addr_t
   GetLoadAddress();
 
   lldb::SBAddress
   GetAddress();
 
     lldb::SBValue
     Persist ();

lldb/examples/synthetic/gnu_libstdcpp.py

 from __future__ import division
 import re
 import lldb.formatters.Logger
 
 # C++ STL formatters for LLDB
 # These formatters are based upon the version of the GNU libstdc++
 # as it ships with Mac OS X 10.6.8 thru 10.8.0
 # You are encouraged to look at the STL implementation for your platform
 # before relying on these formatters to do the right thing for your setup
 
+def StdOptionalSummaryProvider(valobj, dict):
+    has_value = valobj.GetNumChildren() > 0
+    # We add wrapping spaces for consistency with the libcxx formatter
+    return " Has Value=" + ("true" if has_value else "false") + " "
+
+
+class StdOptionalSynthProvider:
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+
+    def update(self):
+        try:
+            self.payload = self.valobj.GetChildMemberWithName('_M_payload')
+            self.value = self.payload.GetChildMemberWithName('_M_payload')
+            self.count = self.payload.GetChildMemberWithName('_M_engaged').GetValueAsUnsigned(0)
+        except:
+            self.count = 0
+        return False
+
+
+    def num_children(self):
+        return self.count
+
+    def get_child_index(self, name):
+        return 0
+
+    def get_child_at_index(self, index):
+        return self.value.Clone('Value')
 
 """
  This formatter can be applied to all
  unordered map-like structures (unordered_map, unordered_multimap, unordered_set, unordered_multiset)
 """
 class StdUnorderedMapSynthProvider:
     def __init__(self, valobj, dict):
         self.valobj = valobj
         self.count = None
         self.kind = self.get_object_kind(valobj)
 
     def get_object_kind(self, valobj):
         type_name = valobj.GetTypeName()
         return "set" if "set" in type_name else "map"
 
     def extract_type(self):
         type = self.valobj.GetType()
         # type of std::pair<key, value> is the first template
-        # argument type of the 4th template argument to std::map and 
-        # 3rd template argument for std::set. That's why 
+        # argument type of the 4th template argument to std::map and
+        # 3rd template argument for std::set. That's why
         # we need to know kind of the object
         template_arg_num = 4 if self.kind == "map" else 3
         allocator_type = type.GetTemplateArgumentType(template_arg_num)
         data_type = allocator_type.GetTemplateArgumentType(0)
         return data_type
 
-    def update(self): 
+    def update(self):
         # preemptively setting this to None - we might end up changing our mind
         # later
         self.count = None
         try:
             self.head = self.valobj.GetChildMemberWithName('_M_h')
             self.before_begin = self.head.GetChildMemberWithName('_M_before_begin')
             self.next = self.before_begin.GetChildMemberWithName('_M_nxt')
             self.data_type = self.extract_type()
def get_child_at_index(self, index):
         logger = lldb.formatters.Logger.Logger()
         logger >> "Being asked to fetch child[" + str(index) + "]"
         if index < 0:
             return None
         if index >= self.num_children():
             return None
         try:
             offset = index
-            current = self.next     
+            current = self.next
             while offset > 0:
                 current = current.GetChildMemberWithName('_M_nxt')
                 offset = offset - 1
             return current.CreateChildAtOffset( '[' + str(index) + ']', self.skip_size, self.data_type)
-        
         except:
             logger >> "Cannot get child"
             return None
 
     def num_children(self):
         if self.count is None:
             self.count = self.num_children_impl()
         return self.count
class AbstractListSynthProvider:
     def is_valid(self, node):
         logger = lldb.formatters.Logger.Logger()
         valid = self.value(self.next_node(node)) != self.get_end_of_list_address()
         if valid:
             logger >> "%s is valid" % str(self.valobj.GetName())
         else:
             logger >> "synthetic value is not valid"
         return valid
-    
     def value(self, node):
         logger = lldb.formatters.Logger.Logger()
         value = node.GetValueAsUnsigned()
         logger >> "synthetic value for {}: {}".format(
             str(self.valobj.GetName()), value)
         return value
 
     # Floyd's cycle-finding algorithm
def num_children(self):
         return self.count
 
     def num_children_impl(self):
         logger = lldb.formatters.Logger.Logger()
         try:
             # After a std::list has been initialized, both next and prev will
             # be non-NULL
             next_val = self.next.GetValueAsUnsigned(0)
-            if next_val == 0: 
+            if next_val == 0:
                 return 0
             if self.has_loop():
                 return 0
             if self.has_prev:
                 prev_val = self.prev.GetValueAsUnsigned(0)
                 if prev_val == 0:
                     return 0
                 if next_val == self.node_address:
                     return 0
                 if next_val == prev_val:
-                    return 1   
+                    return 1
             size = 1
             current = self.next
             while current.GetChildMemberWithName(
                     '_M_next').GetValueAsUnsigned(0) != self.get_end_of_list_address():
                 size = size + 1
                 current = current.GetChildMemberWithName('_M_next')
-            return size 
+            return size
         except:
             logger >> "Error determining the size"
             return 0
 
     def get_child_index(self, name):
         logger = lldb.formatters.Logger.Logger()
         try:
             return int(name.lstrip('[').rstrip(']'))
         except:
             return -1
-      
     def get_child_at_index(self, index):
         logger = lldb.formatters.Logger.Logger()
         logger >> "Fetching child " + str(index)
         if index < 0:
             return None
         if index >= self.num_children():
             return None
         try:
class AbstractListSynthProvider:
     Method is used to extract the list pointers into the variables (e.g self.node, self.next, and optionally to self.prev)
     and is mandatory to be overriden in each AbstractListSynthProvider subclass
     '''
     def updateNodes(self):
         raise NotImplementedError
 
     def has_children(self):
         return True
-        
     '''
      Method is used to identify if a node traversal has reached its end
      and is mandatory to be overriden in each AbstractListSynthProvider subclass
     '''
     def get_end_of_list_address(self):
         raise NotImplementedError
 
 
class StdVectorImplementation(object):
                 # point in trying to fetch anything
                 if self.start.IsValid() and self.finish.IsValid(
                 ) and self.end.IsValid() and self.data_type.IsValid():
                     self.count = None
                 else:
                     self.count = 0
             except:
                 pass
-            return False 
+            return False
 
     class StdVBoolImplementation(object):
 
         def __init__(self, valobj, bool_type):
             self.valobj = valobj
             self.bool_type = bool_type
             self.valid = False
 

lldb/include/lldb/API/SBValue.h

public:
   ///
   /// \return
   ///     An SBData with the contents of this SBValue, on success.
   ///     An empty SBData otherwise.
   lldb::SBData GetData();
 
   bool SetData(lldb::SBData &data, lldb::SBError &error);
 
+  /// Creates a copy of the SBValue with a new name and setting the current
+  /// SBValue as its parent. It should be used when we want to change the
+  /// name of a SBValue without modifying the actual SBValue itself
+  /// (e.g. sythetic child provider).
+  lldb::SBValue Clone(const char *new_name);
+
   lldb::SBDeclaration GetDeclaration();
 
   /// Find out if a SBValue might have children.
   ///
   /// This call is much more efficient than GetNumChildren() as it
   /// doesn't need to complete the underlying type. This is designed
   /// to be used in a UI environment in order to detect if the
   /// disclosure triangle should be displayed or not.

lldb/source/API/SBValue.cpp

error.SetErrorStringWithFormat(
         "Couldn't set data: could not get SBValue: %s",
         locker.GetError().AsCString());
     ret = false;
   }
 
   return ret;
 }
 
+lldb::SBValue SBValue::Clone(const char *new_name) {
+  LLDB_RECORD_METHOD(lldb::SBValue, SBValue, Clone, (const char *), new_name);
+
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+
+  if (value_sp)
+    return lldb::SBValue(value_sp->Clone(ConstString(new_name)));
+  else
+    return lldb::SBValue();
+}
+
 lldb::SBDeclaration SBValue::GetDeclaration() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBDeclaration, SBValue, GetDeclaration);
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   SBDeclaration decl_sb;
   if (value_sp) {
     Declaration decl;
void RegisterMethods<SBValue>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, AddressOf, ());
   LLDB_REGISTER_METHOD(lldb::addr_t, SBValue, GetLoadAddress, ());
   LLDB_REGISTER_METHOD(lldb::SBAddress, SBValue, GetAddress, ());
   LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetPointeeData,
                        (uint32_t, uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBData, SBValue, GetData, ());
   LLDB_REGISTER_METHOD(bool, SBValue, SetData,
                        (lldb::SBData &, lldb::SBError &));
+  LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Clone, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBDeclaration, SBValue, GetDeclaration, ());
   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
                        (bool, bool, bool, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, Watch,
                        (bool, bool, bool));
   LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
                        (bool, bool, bool, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
 }
 
 }
 }

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

cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::multimap<.+> >(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
+      RegularExpression("^std::optional<.+>(( )?&)?$"),
+      SyntheticChildrenSP(new ScriptedSyntheticChildren(
+          stl_synth_flags,
+          "lldb.formatters.cpp.gnu_libstdcpp.StdOptionalSynthProvider")));
+  cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::multiset<.+> >(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::unordered_(multi)?(map|set)<.+> >$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_deref_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpression("^std::(__cxx11::)?forward_list<.+>(( )?&)?$"),
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider")));
+
   stl_summary_flags.SetDontShowChildren(false);
   stl_summary_flags.SetSkipPointers(false);
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
+      RegularExpression("^std::optional<.+>(( )?&)?$"),
+      TypeSummaryImplSP(new ScriptSummaryFormat(
+          stl_summary_flags,
+          "lldb.formatters.cpp.gnu_libstdcpp.StdOptionalSummaryProvider")));
+  cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::bitset<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::vector<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/optional/Makefile

 CXX_SOURCES := main.cpp
 
-USE_LIBCPP := 1
-
 CXXFLAGS_EXTRAS := -std=c++17 -fno-exceptions
 include Makefile.rules

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/optional/TestDataFormatterGenericOptional.py

-"""
-Test lldb data formatter subsystem.
-"""
-
-
-
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+USE_LIBSTDCPP = "USE_LIBSTDCPP"
+USE_LIBCPP = "USE_LIBCPP"
 
-class LibcxxOptionalDataFormatterTestCase(TestBase):
+class GenericOptionalDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @add_test_categories(["libc++"])
-    ## Clang 7.0 is the oldest Clang that can reliably parse newer libc++ versions
-    ## with -std=c++17.
-    @skipIf(oslist=no_match(["macosx"]), compiler="clang", compiler_version=['<', '7.0'])
-    ## We are skipping gcc version less that 5.1 since this test requires -std=c++17
-    @skipIf(compiler="gcc", compiler_version=['<', '5.1'])
-
-    def test_with_run_command(self):
+    def do_test_with_run_command(self, stdlib_type):
         """Test that that file and class static variables display correctly."""
-        self.build()
+        self.build(dictionary={stdlib_type: "1"})
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         bkpt = self.target().FindBreakpointByID(
             lldbutil.run_break_set_by_source_regexp(
                 self, "break here"))
 
         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.runCmd( "frame variable has_optional" )
 
         output = self.res.GetOutput()
 
         ## The variable has_optional tells us if the test program
         ## detected we have a sufficient libc++ version to support optional
         ## false means we do not and therefore should skip the test
         if output.find("(bool) has_optional = false") != -1 :
-           self.skipTest( "Optional not supported" ) 
+           self.skipTest( "Optional not supported" )
 
         lldbutil.continue_to_breakpoint(self.process(), bkpt)
 
         self.expect("frame variable number_not_engaged",
                     substrs=['Has Value=false'])
 
         self.expect("frame variable number_engaged",
                     substrs=['Has Value=true',
def do_test_with_run_command(self, stdlib_type):
                                '[3] = 4',
                                '}',
                              '}'])
 
         self.expect("frame var ostring",
                     substrs=['(optional_string) ostring =  Has Value=true  {',
                         'Value = "hello"',
                         '}'])
+
+    @add_test_categories(["libc++"])
+    ## Clang 7.0 is the oldest Clang that can reliably parse newer libc++ versions
+    ## with -std=c++17.
+    @skipIf(oslist=no_match(["macosx"]), compiler="clang", compiler_version=['<', '7.0'])
+    ## We are skipping gcc version less that 5.1 since this test requires -std=c++17
+    @skipIf(compiler="gcc", compiler_version=['<', '5.1'])
+    def test_with_run_command_libcpp(self):
+        self.do_test_with_run_command(USE_LIBCPP)
+
+    @add_test_categories(["libstdcxx"])
+    ## Clang 7.0 is the oldest Clang that can reliably parse newer libc++ versions
+    ## with -std=c++17.
+    @skipIf(compiler="clang", compiler_version=['<', '7.0'])
+    ## We are skipping gcc version less that 5.1 since this test requires -std=c++17
+    @skipIf(compiler="gcc", compiler_version=['<', '5.1'])
+    def test_with_run_command_libstdcpp(self):
+        self.do_test_with_run_command(USE_LIBSTDCPP)

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/optional/main.cpp

+#include <cstdio>
+#include <string>
+#include <vector>
+
+// If we have libc++ 4.0 or greater we should have <optional>
+// According to libc++ C++1z status page
+// https://libcxx.llvm.org/cxx1z_status.html
+#if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 4000
+#include <optional>
+#define HAVE_OPTIONAL 1
+#else
+#define HAVE_OPTIONAL 0
+#endif
+
+int main() {
+  bool has_optional = HAVE_OPTIONAL;
+
+  printf("%d\n", has_optional); // break here
+
+#if HAVE_OPTIONAL == 1
+  using int_vect = std::vector<int>;
+  using optional_int = std::optional<int>;
+  using optional_int_vect = std::optional<int_vect>;
+  using optional_string = std::optional<std::string>;
+
+  optional_int number_not_engaged;
+  optional_int number_engaged = 42;
+
+  printf("%d\n", *number_engaged);
+
+  optional_int_vect numbers{{1, 2, 3, 4}};
+
+  printf("%d %d\n", numbers.value()[0], numbers.value()[1]);
+
+  optional_string ostring = "hello";
+
+  printf("%s\n", ostring->c_str());
+#endif
+
+  return 0; // break here
+}

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/optional/main.cpp

-#include <cstdio>
-#include <string>
-#include <vector>
-
-// If we have libc++ 4.0 or greater we should have <optional>
-// According to libc++ C++1z status page https://libcxx.llvm.org/cxx1z_status.html
-#if _LIBCPP_VERSION >= 4000
-#include <optional>
-#define HAVE_OPTIONAL 1
-#else
-#define HAVE_OPTIONAL 0
-#endif
-
-
-int main()
-{
-    bool has_optional = HAVE_OPTIONAL ;
-
-    printf( "%d\n", has_optional ) ; // break here
-
-#if HAVE_OPTIONAL == 1
-    using int_vect = std::vector<int> ;
-    using optional_int = std::optional<int> ;
-    using optional_int_vect = std::optional<int_vect> ;
-    using optional_string = std::optional<std::string> ;
-
-    optional_int number_not_engaged ;
-    optional_int number_engaged = 42 ;
-
-    printf( "%d\n", *number_engaged) ;
-
-    optional_int_vect numbers{{1,2,3,4}} ;
-
-    printf( "%d %d\n", numbers.value()[0], numbers.value()[1] ) ;
-
-    optional_string ostring = "hello" ;
-
-    printf( "%s\n", ostring->c_str() ) ;
-#endif
-
-    return 0; // break here
-}