[formatters] List and forward_list capping_size determination and application

[danilashtefan]

Summary

This diff is adding the capping_size determination for the list and forward list, to limit the number of children to be displayed. Also it modifies and unifies tests for libcxx and libstdcpp list data formatter.

[danilashtefan]

lldb/examples/synthetic/gnu_libstdcpp.py

66–69

I will change this to the following:

`if not _list_uses_loop_detector of self.has_prev:

logger >> "Asked not to use loop detection
 return False"`

[wallace]

lldb/examples/synthetic/gnu_libstdcpp.py

14–16

you have to use > instead of >=

31–35

this shouldn't fail, so remove the try/except

61–68

these changes shouldn't be here, as has_loop should only be called if the size is not present as a member of the variable. num_children is the method that is called by lldb to determine the size of the structure, which invokes num_children_impl only if the count is not a member variable. So I have the impression that this code is redundant

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/forward_list/TestDataFormatterGenericForwardList.py

66

create another test in which you set the setting to 3, for example, and then check the output

[danilashtefan]

Done!

[wallace]

add generic tests for list

[danilashtefan]

List tests unification for libcxx and libstdcpp

[danilashtefan]

Deleted duplicated tests from both platforms

lldb/bindings/interface/SBTarget.i

public:
     Architecture code byte width accessor.
 
     :return: The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus.
 
     ") GetCodeByteSize;
     uint32_t
     GetCodeByteSize ();
 
+    uint32_t
+    GetMaximumNumberOfChildrenToDisplay() const;
+
     lldb::SBError
     SetSectionLoadAddress (lldb::SBSection section,
                            lldb::addr_t section_base_addr);
 
     lldb::SBError
     ClearSectionLoadAddress (lldb::SBSection section);
 
     lldb::SBError

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 ForwardListSummaryProvider(valobj, dict):
+    list_capping_size = valobj.GetTarget().GetMaximumNumberOfChildrenToDisplay()
+    if valobj.GetNumChildren() >= list_capping_size:
+        return "(capped) size=" + str(valobj.GetNumChildren())
+    return "size=" + str(valobj.GetNumChildren())
+
 class AbstractListSynthProvider:
     def __init__(self, valobj, dict, has_prev):
         '''
         :param valobj: The value object of the list
         :param dict: A dict with metadata provided by LLDB
         :param has_prev: Whether the list supports a 'prev' pointer besides a 'next' one
         '''
         logger = lldb.formatters.Logger.Logger()
         self.valobj = valobj
         self.count = None
         self.has_prev = has_prev
         logger >> "Providing synthetic children for a list named " + \
             str(valobj.GetName())
+        try:
+            self.list_capping_size = self.valobj.GetTarget().GetMaximumNumberOfChildrenToDisplay()
+        except:
+            logger >> "Error determining the capping size. The default value 256 is applied"
+            self.list_capping_size = 256
 
     def next_node(self, node):
         logger = lldb.formatters.Logger.Logger()
         return node.GetChildMemberWithName('_M_next')
 
     def is_valid(self, node):
         logger = lldb.formatters.Logger.Logger()
         valid = self.value(self.next_node(node)) != self.get_end_of_list_address()
def value(self, node):
         logger >> "synthetic value for {}: {}".format(
             str(self.valobj.GetName()), value)
         return value
 
     # Floyd's cycle-finding algorithm
     # try to detect if this list has a loop
     def has_loop(self):
         global _list_uses_loop_detector
+        # In case of list we know the exact number of children in advance so we do not need to run
+        # cycle detection algorithm
+        if self.has_prev:
+            _list_uses_loop_detector = False
         logger = lldb.formatters.Logger.Logger()
         if not _list_uses_loop_detector:
             logger >> "Asked not to use loop detection"
+            _list_uses_loop_detector = True
             return False
         slow = self.next
         fast1 = self.next
         fast2 = self.next
         while self.is_valid(slow):
             slow_value = self.value(slow)
             fast1 = self.next_node(fast2)
             fast2 = self.next_node(fast1)
             if self.value(fast1) == slow_value or self.value(
def num_children_impl(self):
                 if next_val == prev_val:
                     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')
+                # In case of forward_list capping size is the limit of the children to be displayed
+                if not self.has_prev and size >= self.list_capping_size:
+                    break
             return size 
         except:
             logger >> "Error determining the size"
             return 0
 
     def get_child_index(self, name):
         logger = lldb.formatters.Logger.Logger()
         try:

lldb/include/lldb/API/SBTarget.h

public:
 
   /// Architecture code byte width accessor
   ///
   /// \return
   /// The size in 8-bit (host) bytes of a minimum addressable
   /// unit from the Architecture's code bus
   uint32_t GetCodeByteSize();
 
+  /// Gets the target.max-children-count value
+  /// It should be used to limit the number of
+  /// children of large data structures to be displayed.
+  uint32_t GetMaximumNumberOfChildrenToDisplay() const;
+
   /// Set the base load address for a module section.
   ///
   /// \param[in] section
   ///     The section whose base load address will be set within this
   ///     target.
   ///
   /// \param[in] section_base_addr
   ///     The base address for the section.

lldb/source/API/SBTarget.cpp

uint32_t SBTarget::GetCodeByteSize() {
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     return target_sp->GetArchitecture().GetCodeByteSize();
   }
   return 0;
 }
 
+uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay);
+
+  TargetSP target_sp(GetSP());
+  if(target_sp){
+     return target_sp->GetMaximumNumberOfChildrenToDisplay();
+  }
+  return 0;
+}
+
 uint32_t SBTarget::GetAddressByteSize() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
     return target_sp->GetArchitecture().GetAddressByteSize();
   return sizeof(void *);
 }
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule,
                        (const lldb::SBFileSpec &));
   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits,
                        (const lldb::SBFileSpec &));
   LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
   LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay,());
   LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
   LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
                        (uint32_t));
   LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
   LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster,
                              ());
   LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
                        (lldb::SBStream &, lldb::DescriptionLevel));

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

cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
       TypeSummaryImplSP(
           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
       RegularExpression("^std::(__cxx11::)?forward_list<.+>(( )?&)?$"),
       TypeSummaryImplSP(
-          new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+          new ScriptSummaryFormat(stl_summary_flags, "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
       "std::vector iterator synthetic children",
       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
 
   AddCXXSynthetic(

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/forward_list/TestDataFormatterGenericForwardList.py

def do_test(self, stdlib_type):
                              '{',
                              '[0] = 1',
                              '[1] = 22',
                              '[2] = 333',
                              '[3] = 4444',
                              '[4] = 55555',
                              '}'])
 
+        self.expect("settings show target.max-children-count", matching=True,
+                    substrs=['target.max-children-count (int) = 256'])
+
+        self.expect("frame variable thousand_elts",matching=False,
+                    substrs=[ 
+                             '[256] = 256',
+                             '[333] = 333',
+                             '[444] = 444',
+                             '[555] = 555',
+                             '[666] = 666',
+                             '...'
+                             ])
+
     @add_test_categories(["libstdcxx"])
     def test_libstdcpp(self):
         self.do_test(USE_LIBSTDCPP)
 
     @add_test_categories(["libc++"])
     def test_libcpp(self):
          self.do_test(USE_LIBCPP)
     

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

 #include <forward_list>
 
 int main() {
   std::forward_list<int> empty{}, one_elt{47},
-      five_elts{1, 22, 333, 4444, 55555};
+      five_elts{1, 22, 333, 4444, 55555}, thousand_elts{};
+  for(int i = 0; i<1000;i++){
+    thousand_elts.push_front(i);
+  }
   return 0; // break here
 }