Adapt LLDB dataformatters for libcxx change D129386

[aprantl]

Summary

We at first misattributed this to a CMake configuration change that happened on green dragon at the same time, hence the delay.

[ldionne]

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

1004

IIUC you're trying to support both the old and the new naming?

[aprantl]

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

1004

Yes, otherwise the matrix bot, which tests that LLDB can debug code compiled with older releases of clang (and libcxx) would fail. Currently it builds the testsuite with every other release since Clang 5.0

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake-matrix/

[Michael137]

LGTM thanks!

lldb/include/lldb/DataFormatters/VectorIterator.h

 #ifndef LLDB_DATAFORMATTERS_VECTORITERATOR_H
 #define LLDB_DATAFORMATTERS_VECTORITERATOR_H
 
 #include "lldb/lldb-forward.h"
 
 #include "lldb/DataFormatters/TypeSynthetic.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Utility/ConstString.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace lldb_private {
 namespace formatters {
 class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp,
-                                  ConstString item_name);
+                                  llvm::ArrayRef<ConstString> item_names);
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   ExecutionContextRef m_exe_ctx_ref;
-  ConstString m_item_name;
+  llvm::SmallVector<ConstString, 2> m_item_names;
   lldb::ValueObjectSP m_item_sp;
 };
 
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_VECTORITERATOR_H

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

 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
 #include "lldb/Utility/Stream.h"
 
 namespace lldb_private {
 namespace formatters {
 
+/// Find a child member of \c obj_sp, trying all alternative names in order.
+lldb::ValueObjectSP
+GetChildMemberWithName(ValueObject &obj,
+                       llvm::ArrayRef<ConstString> alternative_names);
+
 bool LibcxxStringSummaryProviderASCII(
     ValueObject &valobj, Stream &stream,
     const TypeSummaryOptions &summary_options); // libc++ std::string
 
 bool LibcxxStringSummaryProviderUTF16(
     ValueObject &valobj, Stream &stream,
     const TypeSummaryOptions &summary_options); // libc++ std::u16string
 

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

 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/lldb-enumerations.h"
 #include <tuple>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
+lldb::ValueObjectSP lldb_private::formatters::GetChildMemberWithName(
+    ValueObject &obj, llvm::ArrayRef<ConstString> alternative_names) {
+  for (ConstString name : alternative_names) {
+    lldb::ValueObjectSP child_sp = obj.GetChildMemberWithName(name, true);
+
+    if (child_sp)
+      return child_sp;
+  }
+  return {};
+}
+
 bool lldb_private::formatters::LibcxxOptionalSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
   // An optional either contains a value or not, the member __engaged_ is
   // a bool flag, it is true if the optional has a value and false otherwise.

  (int) *__i = 1
  }
  }
 */
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
-  static ConstString g_item_name;
-  if (!g_item_name)
-    g_item_name.SetCString("__i");
-  return (valobj_sp
-              ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name)
+  return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(
+                          valobj_sp, {ConstString("__i_"), ConstString("__i")})
                     : nullptr);
 }
 
 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
     LibcxxSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_cntrl(nullptr) {
   if (valobj_sp)
     Update();
 }
bool lldb_private::formatters::LibcxxStringSummaryProviderUTF32(
     ValueObject &valobj, Stream &stream,
     const TypeSummaryOptions &summary_options) {
   return formatStringImpl<StringPrinter::StringElementType::UTF32>(
       valobj, stream, summary_options, "U");
 }
 
 static std::tuple<bool, ValueObjectSP, size_t>
 LibcxxExtractStringViewData(ValueObject& valobj) {
-  ConstString g_data_name("__data");
-  ConstString g_size_name("__size");
-  auto dataobj = valobj.GetChildMemberWithName(g_data_name, true);
-  auto sizeobj = valobj.GetChildMemberWithName(g_size_name, true);
-
+  auto dataobj = GetChildMemberWithName(
+      valobj, {ConstString("__data_"), ConstString("__data")});
+  auto sizeobj = GetChildMemberWithName(
+      valobj, {ConstString("__size_"), ConstString("__size")});
   if (!dataobj || !sizeobj)
     return std::make_tuple<bool,ValueObjectSP,size_t>(false, {}, {});
 
   if (!dataobj->GetError().Success() || !sizeobj->GetError().Success())
     return std::make_tuple<bool,ValueObjectSP,size_t>(false, {}, {});
 
   bool success{false};
   uint64_t size = sizeobj->GetValueAsUnsigned(0, &success);

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

if (tree_node_type
             .IsValid())
       m_skip_size = (uint32_t)child_byte_offset;
   }
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
-  static ConstString g_cc("__cc");
+  static ConstString g_cc_("__cc_"), g_cc("__cc");
   static ConstString g_nc("__nc");
   static ConstString g_value_("__value_");
 
   if (idx >= CalculateNumChildren())
     return lldb::ValueObjectSP();
   if (m_tree == nullptr || m_root_node == nullptr)
     return lldb::ValueObjectSP();
 
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   auto potential_child_sp = CreateValueObjectFromData(
       name.GetString(), data, m_backend.GetExecutionContextRef(),
       m_element_type);
   if (potential_child_sp) {
     switch (potential_child_sp->GetNumChildren()) {
     case 1: {
       auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
-      if (child0_sp && child0_sp->GetName() == g_cc)
+      if (child0_sp &&
+          (child0_sp->GetName() == g_cc_ || child0_sp->GetName() == g_cc))
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     case 2: {
       auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
       auto child1_sp = potential_child_sp->GetChildAtIndex(1, true);
-      if (child0_sp && child0_sp->GetName() == g_cc && child1_sp &&
-          child1_sp->GetName() == g_nc)
+      if (child0_sp &&
+          (child0_sp->GetName() == g_cc_ || child0_sp->GetName() == g_cc) &&
+          child1_sp && child1_sp->GetName() == g_nc)
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     }
   }
   m_iterators[idx] = iterator;
   return potential_child_sp;
 }

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

lldb_private::formatters::LibcxxStdSpanSyntheticFrontEnd::GetChildAtIndex(
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   return CreateValueObjectFromAddress(name.GetString(), offset,
                                       m_backend.GetExecutionContextRef(),
                                       m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxStdSpanSyntheticFrontEnd::Update() {
   // Get element type.
-  ValueObjectSP data_type_finder_sp(
-      m_backend.GetChildMemberWithName(ConstString("__data"), true));
+  ValueObjectSP data_type_finder_sp = GetChildMemberWithName(
+      m_backend, {ConstString("__data_"), ConstString("__data")});
   if (!data_type_finder_sp)
     return false;
 
   m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
 
   // Get element size.
   if (llvm::Optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
     m_element_size = *size;
 
     // Get data.
     if (m_element_size > 0) {
       m_start = data_type_finder_sp.get();
     }
 
     // Get number of elements.
-    if (auto size_sp =
-            m_backend.GetChildMemberWithName(ConstString("__size"), true)) {
+    if (auto size_sp = GetChildMemberWithName(
+            m_backend, {ConstString("__size_"), ConstString("__size")})) {
       m_num_elements = size_sp->GetValueAsUnsigned(0);
     } else if (auto arg =
                    m_backend.GetCompilerType().GetIntegralTemplateArgument(1)) {
 
       m_num_elements = arg->value.getLimitedValue();
     }
   }
 

lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.h

-//===-- LibCxxVariant.h -------------------------------------------*- C++
-//-*-===//
+//===-- LibCxxVariant.h ----------------------------------------*- C++ -*--===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_LIBCXXVARIANT_H

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

 //===-- LibCxxVariant.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LibCxxVariant.h"
+#include "LibCxx.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 namespace lldb_private {
 namespace formatters {
 bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
                                   const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP impl_sp(
-      valobj_sp->GetChildMemberWithName(ConstString("__impl"), true));
+  ValueObjectSP impl_sp = GetChildMemberWithName(
+      *valobj_sp, {ConstString("__impl_"), ConstString("__impl")});
 
   if (!impl_sp)
     return false;
 
   LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
 
   if (validity == LibcxxVariantIndexValidity::Invalid)
     return false;

 
 private:
   size_t m_size = 0;
 };
 } // namespace
 
 bool VariantFrontEnd::Update() {
   m_size = 0;
-  ValueObjectSP impl_sp(
-      m_backend.GetChildMemberWithName(ConstString("__impl"), true));
+  ValueObjectSP impl_sp = formatters::GetChildMemberWithName(
+      m_backend, {ConstString("__impl_"), ConstString("__impl")});
   if (!impl_sp)
     return false;
 
   LibcxxVariantIndexValidity validity = LibcxxVariantGetIndexValidity(impl_sp);
 
   if (validity == LibcxxVariantIndexValidity::Invalid)
     return false;
 
   if (validity == LibcxxVariantIndexValidity::NPos)
     return true;
 
   m_size = 1;
 
   return false;
 }
 
 ValueObjectSP VariantFrontEnd::GetChildAtIndex(size_t idx) {
   if (idx >= m_size)
-    return ValueObjectSP();
+    return {};
 
-  ValueObjectSP impl_sp(
-      m_backend.GetChildMemberWithName(ConstString("__impl"), true));
+  ValueObjectSP impl_sp = formatters::GetChildMemberWithName(
+      m_backend, {ConstString("__impl_"), ConstString("__impl")});
+  if (!impl_sp)
+    return {};
 
   auto optional_index_value = LibcxxVariantIndexValue(impl_sp);
 
   if (!optional_index_value)
-    return ValueObjectSP();
+    return {};
 
   uint64_t index_value = *optional_index_value;
 
   ValueObjectSP nth_head = LibcxxVariantGetNthHead(impl_sp, index_value);
 
   if (!nth_head)
-    return ValueObjectSP();
+    return {};
 
   CompilerType head_type = nth_head->GetCompilerType();
 
   if (!head_type)
-    return ValueObjectSP();
+    return {};
 
   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 
   if (!template_type)
-    return ValueObjectSP();
+    return {};
 
   ValueObjectSP head_value(
       nth_head->GetChildMemberWithName(ConstString("__value"), true));
 
   if (!head_value)
-    return ValueObjectSP();
+    return {};
 
   return head_value->Clone(ConstString("Value"));
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
                                          lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new VariantFrontEnd(*valobj_sp);
   return nullptr;
 }

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

 //===-- LibStdcpp.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LibStdcpp.h"
+#include "LibCxx.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/VectorIterator.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"

  *_M_current = 1
  }
  }
  */
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
-  static ConstString g_item_name;
-  if (!g_item_name)
-    g_item_name.SetCString("_M_current");
-  return (valobj_sp
-              ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name)
+  return (valobj_sp ? new VectorIteratorSyntheticFrontEnd(
+                          valobj_sp, {ConstString("_M_current")})
                     : nullptr);
 }
 
 lldb_private::formatters::VectorIteratorSyntheticFrontEnd::
     VectorIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp,
-                                    ConstString item_name)
+                                    llvm::ArrayRef<ConstString> item_names)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
-      m_item_name(item_name), m_item_sp() {
+      m_item_names(item_names), m_item_sp() {
   if (valobj_sp)
     Update();
 }
 
 bool VectorIteratorSyntheticFrontEnd::Update() {
   m_item_sp.reset();
 
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
 
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name, true));
+  ValueObjectSP item_ptr =
+      formatters::GetChildMemberWithName(*valobj_sp, m_item_names);
   if (!item_ptr)
     return false;
   if (item_ptr->GetValueAsUnsigned(0) == 0)
     return false;
   Status err;
   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
   m_item_sp = CreateValueObjectFromAddress(
       "item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref,

lldb/test/API/commands/expression/import-std-module/deque-basic/TestDequeFromStdModule.py

 """
 Test basic std::list functionality.
 """
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestBasicDeque(TestBase):
 
     @add_test_categories(["libc++"])
-    @expectedFailureDarwin
+    @expectedFailureDarwin # FIXME: May need to force system libcxx here.
     @skipIf(compiler=no_match("clang"))
     def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py

class LibcxxIteratorDataFormatterTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
         self.namespace = 'std'
 
-    @expectedFailureDarwin # FIXME: May need to force system libcxx here.
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that libc++ iterators format properly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=-1)

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/span/TestDataFormatterLibcxxSpan.py

def check_numbers(self, var_name):
         # check access-by-index
         self.expect_var_path(f'{var_name}[0]', type='int', value='1')
         self.expect_var_path(f'{var_name}[1]', type='int', value='12')
         self.expect_var_path(f'{var_name}[2]', type='int', value='123')
         self.expect_var_path(f'{var_name}[3]', type='int', value='1234')
         self.expect_var_path(f'{var_name}[4]', type='int', value='12345')
 
     @add_test_categories(['libc++'])
-    @expectedFailureDarwin # FIXME: May need to force system libcxx here.
     @skipIf(compiler='clang', compiler_version=['<', '11.0'])
     def test_with_run_command(self):
         """Test that std::span variables are formatted correctly when printed."""
         self.build()
         (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('main.cpp', False))
 
         lldbutil.continue_to_breakpoint(process, bkpt)

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string_view/TestDataFormatterLibcxxStringView.py

class LibcxxStringViewDataFormatterTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line1 = line_number('main.cpp', '// Set break point at this line.')
         self.line2 = line_number('main.cpp', '// Break here to look at bad string view.' )
 
     @add_test_categories(["libc++"])
-    @expectedFailureDarwin # FIXME: May need to force system libcxx here.
     @expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android")
     # Inline namespace is randomly ignored as Clang due to broken lookup inside
     # the std namespace.
     @expectedFailureAll(debug_info="gmodules")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/variant/TestDataFormatterLibcxxVariant.py

class LibcxxVariantDataFormatterTestCase(TestBase):
     @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'])
     ## std::get is unavailable for std::variant before macOS 10.14
     @skipIf(macos_version=["<", "10.14"])
-    @expectedFailureDarwin # FIXME: May need to force system libcxx here.
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
 
         (self.target, self.process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.runCmd( "frame variable has_variant" )