[formatters] Capping size limitation avoidance for the libcxx and libcpp bitset data formatters.

[danilashtefan]

Summary

This diff is avoiding the size limitation introduced by the capping size for the libcxx and libcpp bitset data formatters.

[wallace]

great!!!

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

 
 bool GenericBitsetFrontEnd::Update() {
   m_elements.clear();
   m_first = nullptr;
 
   TargetSP target_sp = m_backend.GetTargetSP();
   if (!target_sp)
     return false;
-  size_t capping_size = target_sp->GetMaximumNumberOfChildrenToDisplay();
 
   size_t size = 0;
 
   if (auto arg = m_backend.GetCompilerType().GetIntegralTemplateArgument(0))
-    size = arg->value.getLimitedValue(capping_size);
+    size = arg->value.getLimitedValue();
 
   m_elements.assign(size, ValueObjectSP());
   m_first = m_backend.GetChildMemberWithName(GetDataContainerMemberName(), true)
                 .get();
   return false;
 }
 
 ValueObjectSP GenericBitsetFrontEnd::GetChildAtIndex(size_t idx) {

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/bitset/TestDataFormatterGenericBitset.py

 POINTER = "POINTER"
 
 class GenericBitsetDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        primes = [1]*300
+        primes = [1]*1000
         primes[0] = primes[1] = 0
         for i in range(2, len(primes)):
             for j in range(2*i, len(primes), i):
                 primes[j] = 0
         self.primes = primes
 
     def getBitsetVariant(self, size, variant):
         if variant == VALUE:
def do_test_value(self, stdlib_type):
         """Test that std::bitset is displayed correctly"""
         self.build(dictionary={stdlib_type: "1"})
 
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.check("empty", 0, VALUE)
         self.check("small", 13, VALUE)
-        self.check("large", 70, VALUE)
+        self.check("medium", 70, VALUE)
+        self.check("large", 1000, VALUE)
 
     @add_test_categories(["libstdcxx"])
     def test_value_libstdcpp(self):
         self.do_test_value(USE_LIBSTDCPP)
 
     @add_test_categories(["libc++"])
     def test_value_libcpp(self):
         self.do_test_value(USE_LIBCPP)
def do_test_ptr_and_ref(self, stdlib_type):
         self.check("ref", 13, REFERENCE)
         self.check("ptr", 13, POINTER)
 
         lldbutil.continue_to_breakpoint(process, bkpt)
 
         self.check("ref", 70, REFERENCE)
         self.check("ptr", 70, POINTER)
 
+        lldbutil.continue_to_breakpoint(process, bkpt)
+
+        self.check("ref", 1000, REFERENCE)
+        self.check("ptr", 1000, POINTER)
+
     @add_test_categories(["libstdcxx"])
     def test_ptr_and_ref_libstdcpp(self):
         self.do_test_ptr_and_ref(USE_LIBSTDCPP)
 
     @add_test_categories(["libc++"])
     def test_ptr_and_ref_libcpp(self):
         self.do_test_ptr_and_ref(USE_LIBCPP)

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

void by_ref_and_ptr(std::bitset<N> &ref, std::bitset<N> *ptr) {
   // Check ref and ptr
   return;
 }
 
 int main() {
   std::bitset<0> empty;
   std::bitset<13> small;
   fill(small);
-  std::bitset<70> large;
+  std::bitset<70> medium;
+  fill(medium);
+  std::bitset<1000> large;
   fill(large);
   by_ref_and_ptr(small, &small); // break here
+  by_ref_and_ptr(medium, &medium);
   by_ref_and_ptr(large, &large);
   return 0;
 }