Add a data formatter for libc++ std::bitset

[jingham]

Looks fine. Seems like Update doesn't need to grab the bool type on every pass, but I don't think that matters IRL. Thanks for adding this.

source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

62 ↗

(On Diff #122685)

Does this need to be done every time you Update? Couldn't you do this in the constructor instead? This is probably pretty cheap call, so it doesn't matter much, but it seems odd.

[labath]

source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

62 ↗

(On Diff #122685)

The other pretty printers were doing all of their initialization in the Update function, but I don't see a reason why this couldn't be done in the constructor. In that case, I can probably do the byte order and pointer size computation there as well.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/Makefile

+LEVEL = ../../../../../make
+
+CXX_SOURCES := main.cpp
+
+USE_LIBCPP := 1
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/TestDataFormatterLibcxxBitset.py

+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestDataFormatterLibcxxBitset(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+        primes = [1]*300
+        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 check(self, name, size):
+        var = self.frame().FindVariable(name)
+        self.assertTrue(var.IsValid())
+        self.assertEqual(var.GetNumChildren(), size)
+        for i in range(size):
+            child = var.GetChildAtIndex(i)
+            self.assertEqual(child.GetValueAsUnsigned(), self.primes[i],
+                    "variable: %s, index: %d"%(name, size))
+
+    @add_test_categories(["libc++"])
+    def test(self):
+        """Test that std::bitset is displayed correctly"""
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, '// break here',
+                lldb.SBFileSpec("main.cpp", False))
+
+        self.check("empty", 0)
+        self.check("small", 13)
+        self.check("large", 200)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/main.cpp

+#include <bitset>
+
+template<std::size_t N>
+void fill(std::bitset<N> &b) {
+  b.set();
+  b[0] = b[1] = false;
+  for (std::size_t i = 2; i < N; ++i) {
+    for (std::size_t j = 2*i; j < N; j+=i)
+      b[j] = false;
+  }
+}
+
+int main() {
+  std::bitset<0> empty;
+  std::bitset<13> small;
+  fill(small);
+  std::bitset<200> large;
+  fill(large);
+  return 0; // break here
+}

lldb/trunk/source/Plugins/Language/CPlusPlus/CMakeLists.txt

 add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   BlockPointer.cpp
   CPlusPlusLanguage.cpp
   CPlusPlusNameParser.cpp
   CxxStringTypes.cpp
   LibCxx.cpp
   LibCxxAtomic.cpp
+  LibCxxBitset.cpp
   LibCxxInitializerList.cpp
   LibCxxList.cpp
   LibCxxMap.cpp
   LibCxxQueue.cpp
   LibCxxTuple.cpp
   LibCxxUnorderedMap.cpp
   LibCxxVector.cpp
   LibStdcpp.cpp

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

cpp_category_sp->GetTypeSummariesContainer()->Add(
       std_wstring_summary_sp);
 
   SyntheticChildren::Flags stl_synth_flags;
   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
       false);
 
   AddCXXSynthetic(
       cpp_category_sp,
+      lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
+      "libc++ std::bitset synthetic children",
+      ConstString("^std::__(ndk)?1::bitset<.+>(( )?&)?$"), stl_synth_flags,
+      true);
+  AddCXXSynthetic(
+      cpp_category_sp,
       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
       "libc++ std::vector synthetic children",
       ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"), stl_synth_flags,
       true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
       "libc++ std::forward_list synthetic children",
AddCXXSynthetic(
       "weak_ptr synthetic children",
       ConstString("^(std::__(ndk)?1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags,
       true);
 
   stl_summary_flags.SetDontShowChildren(false);
   stl_summary_flags.SetSkipPointers(false);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxContainerSummaryProvider,
+                "libc++ std::bitset summary provider",
+                ConstString("^std::__(ndk)?1::bitset<.+>(( )?&)?$"),
+                stl_summary_flags, true);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::LibcxxContainerSummaryProvider,
                 "libc++ std::vector summary provider",
                 ConstString("^std::__(ndk)?1::vector<.+>(( )?&)?$"),
                 stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxContainerSummaryProvider,
                 "libc++ std::list summary provider",
                 ConstString("^std::__(ndk)?1::forward_list<.+>(( )?&)?$"),
                 stl_summary_flags, true);

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.h

private:
   ValueObject *m_cntrl;
   lldb::ValueObjectSP m_count_sp;
   lldb::ValueObjectSP m_weak_count_sp;
   uint8_t m_ptr_size;
   lldb::ByteOrder m_byte_order;
 };
 
 SyntheticChildrenFrontEnd *
+LibcxxBitsetSyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                     lldb::ValueObjectSP);
+
+SyntheticChildrenFrontEnd *
 LibcxxSharedPtrSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                         lldb::ValueObjectSP);
 
 SyntheticChildrenFrontEnd *
 LibcxxStdVectorSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                         lldb::ValueObjectSP);
 
 SyntheticChildrenFrontEnd *

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

+//===-- LibCxxBitset.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LibCxx.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+class BitsetFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  BitsetFrontEnd(ValueObject &valobj);
+
+  size_t GetIndexOfChildWithName(const ConstString &name) override {
+    return formatters::ExtractIndexFromString(name.GetCString());
+  }
+
+  bool MightHaveChildren() override { return true; }
+  bool Update() override;
+  size_t CalculateNumChildren() override { return m_elements.size(); }
+  ValueObjectSP GetChildAtIndex(size_t idx) override;
+
+private:
+  std::vector<ValueObjectSP> m_elements;
+  ValueObjectSP m_first;
+  CompilerType m_bool_type;
+  ByteOrder m_byte_order = eByteOrderInvalid;
+  uint8_t m_byte_size = 0;
+};
+} // namespace
+
+BitsetFrontEnd::BitsetFrontEnd(ValueObject &valobj)
+    : SyntheticChildrenFrontEnd(valobj) {
+  m_bool_type = valobj.GetCompilerType().GetBasicTypeFromAST(eBasicTypeBool);
+  if (auto target_sp = m_backend.GetTargetSP()) {
+    m_byte_order = target_sp->GetArchitecture().GetByteOrder();
+    m_byte_size = target_sp->GetArchitecture().GetAddressByteSize();
+    Update();
+  }
+}
+
+bool BitsetFrontEnd::Update() {
+  m_elements.clear();
+  m_first.reset();
+
+  TargetSP target_sp = m_backend.GetTargetSP();
+  if (!target_sp)
+    return false;
+  size_t capping_size = target_sp->GetMaximumNumberOfChildrenToDisplay();
+
+  size_t size = 0;
+  auto value_and_type =
+      m_backend.GetCompilerType().GetIntegralTemplateArgument(0);
+  if (value_and_type.second)
+    size = value_and_type.first.getLimitedValue(capping_size);
+
+  m_elements.assign(size, ValueObjectSP());
+
+  m_first = m_backend.GetChildMemberWithName(ConstString("__first_"), true);
+  return false;
+}
+
+ValueObjectSP BitsetFrontEnd::GetChildAtIndex(size_t idx) {
+  if (idx >= m_elements.size() || !m_first)
+    return ValueObjectSP();
+
+  if (m_elements[idx])
+    return m_elements[idx];
+
+  ExecutionContext ctx = m_backend.GetExecutionContextRef().Lock(false);
+  CompilerType type;
+  ValueObjectSP chunk;
+  // For small bitsets __first_ is not an array, but a plain size_t.
+  if (m_first->GetCompilerType().IsArrayType(&type, nullptr, nullptr))
+    chunk = m_first->GetChildAtIndex(
+        idx / type.GetBitSize(ctx.GetBestExecutionContextScope()), true);
+  else {
+    type = m_first->GetCompilerType();
+    chunk = m_first;
+  }
+  if (!type || !chunk)
+    return ValueObjectSP();
+
+  size_t chunk_idx = idx % type.GetBitSize(ctx.GetBestExecutionContextScope());
+  uint8_t value = !!(chunk->GetValueAsUnsigned(0) & (uint64_t(1) << chunk_idx));
+  DataExtractor data(&value, sizeof(value), m_byte_order, m_byte_size);
+
+  m_elements[idx] = CreateValueObjectFromData(llvm::formatv("[{0}]", idx).str(),
+                                              data, ctx, m_bool_type);
+
+  return m_elements[idx];
+}
+
+SyntheticChildrenFrontEnd *formatters::LibcxxBitsetSyntheticFrontEndCreator(
+    CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+  if (valobj_sp)
+    return new BitsetFrontEnd(*valobj_sp);
+  return nullptr;
+}