[Lldb-commits] [lldb] [LLDB][libc++] Adds valarray proxy data formatters. (PR #88613)
via lldb-commits
lldb-commits at lists.llvm.org
Sat Apr 13 03:11:52 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lldb
Author: Mark de Wever (mordante)
<details>
<summary>Changes</summary>
These proxies are returned by operator[](...). These proxies all "behave" the same. They store a pointer to the data of the valarray they are a proxy for and they have an internal array of indices. This internal array is considered its contents.
---
Full diff: https://github.com/llvm/llvm-project/pull/88613.diff
6 Files Affected:
- (modified) lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt (+1)
- (modified) lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp (+11)
- (modified) lldb/source/Plugins/Language/CPlusPlus/LibCxx.h (+4)
- (added) lldb/source/Plugins/Language/CPlusPlus/LibCxxProxyArray.cpp (+194)
- (modified) lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/TestDataFormatterLibcxxValarray.py (+80-8)
- (modified) lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/main.cpp (+5-1)
``````````diff
diff --git a/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt b/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
index 0c6fdb2b957315..f59032c423880f 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
+++ b/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
@@ -14,6 +14,7 @@ add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
LibCxxQueue.cpp
LibCxxRangesRefView.cpp
LibCxxSliceArray.cpp
+ LibCxxProxyArray.cpp
LibCxxSpan.cpp
LibCxxTuple.cpp
LibCxxUnorderedMap.cpp
diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
index afb683f7d846a6..5f0684163328f5 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
@@ -760,6 +760,12 @@ static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
lldb_private::formatters::LibcxxStdSliceArraySyntheticFrontEndCreator,
"libc++ std::slice_array synthetic children",
"^std::__[[:alnum:]]+::slice_array<.+>$", stl_deref_flags, true);
+ AddCXXSynthetic(
+ cpp_category_sp,
+ lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEndCreator,
+ "libc++ synthetic children for the valarray proxy arrays",
+ "^std::__[[:alnum:]]+::(gslice|mask|indirect)_array<.+>$",
+ stl_deref_flags, true);
AddCXXSynthetic(
cpp_category_sp,
lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
@@ -890,6 +896,11 @@ static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
"libc++ std::slice_array summary provider",
"^std::__[[:alnum:]]+::slice_array<.+>$", stl_summary_flags,
true);
+ AddCXXSummary(cpp_category_sp,
+ lldb_private::formatters::LibcxxContainerSummaryProvider,
+ "libc++ summary provider for the valarray proxy arrays",
+ "^std::__[[:alnum:]]+::(gslice|mask|indirect)_array<.+>$",
+ stl_summary_flags, true);
AddCXXSummary(
cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
"libc++ std::list summary provider",
diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h b/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h
index 8e97174dc30757..7fe15d1bf3f7af 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h
+++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxx.h
@@ -231,6 +231,10 @@ SyntheticChildrenFrontEnd *
LibcxxStdSliceArraySyntheticFrontEndCreator(CXXSyntheticChildren *,
lldb::ValueObjectSP);
+SyntheticChildrenFrontEnd *
+LibcxxStdProxyArraySyntheticFrontEndCreator(CXXSyntheticChildren *,
+ lldb::ValueObjectSP);
+
SyntheticChildrenFrontEnd *
LibcxxStdListSyntheticFrontEndCreator(CXXSyntheticChildren *,
lldb::ValueObjectSP);
diff --git a/lldb/source/Plugins/Language/CPlusPlus/LibCxxProxyArray.cpp b/lldb/source/Plugins/Language/CPlusPlus/LibCxxProxyArray.cpp
new file mode 100644
index 00000000000000..726f06523b97b4
--- /dev/null
+++ b/lldb/source/Plugins/Language/CPlusPlus/LibCxxProxyArray.cpp
@@ -0,0 +1,194 @@
+//===-- LibCxxProxyArray.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 "LibCxx.h"
+
+#include "lldb/Core/ValueObject.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include <optional>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+namespace lldb_private {
+namespace formatters {
+
+/// Data formatter for libc++'s std::"proxy_array".
+///
+/// A proxy_array's are created by using:
+/// std::gslice_array operator[](const std::gslice& gslicearr);
+/// std::mask_array operator[](const std::valarray<bool>& boolarr);
+/// std::indirect_array operator[](const std::valarray<std::size_t>& indarr);
+///
+/// These arrays have the following members:
+/// - __vp_ points to std::valarray::__begin_
+/// - __1d_ an array of offsets of the elements from @a __vp_
+class LibcxxStdProxyArraySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+ LibcxxStdProxyArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+ ~LibcxxStdProxyArraySyntheticFrontEnd() override;
+
+ llvm::Expected<uint32_t> CalculateNumChildren() override;
+
+ lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override;
+
+ lldb::ChildCacheState Update() override;
+
+ bool MightHaveChildren() override;
+
+ size_t GetIndexOfChildWithName(ConstString name) override;
+
+private:
+ /// A non-owning pointer to the array's __vp_.
+ ValueObject *m_base = nullptr;
+ /// The type of the array's template argument T.
+ CompilerType m_element_type;
+ /// The sizeof the array's template argument T.
+ uint32_t m_element_size = 0;
+
+ /// A non-owning pointer to the array's __1d_.__begin_.
+ ValueObject *m_start = nullptr;
+ /// A non-owning pointer to the array's __1d_.__end_.
+ ValueObject *m_finish = nullptr;
+ /// The type of the __1d_ array's template argument T (size_t).
+ CompilerType m_element_type_size_t;
+ /// The sizeof the __1d_ array's template argument T (size_t)
+ uint32_t m_element_size_size_t = 0;
+};
+
+} // namespace formatters
+} // namespace lldb_private
+
+lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::
+ LibcxxStdProxyArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+ : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type() {
+ if (valobj_sp)
+ Update();
+}
+
+lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::
+ ~LibcxxStdProxyArraySyntheticFrontEnd() {
+ // these need to stay around because they are child objects who will follow
+ // their parent's life cycle
+ // delete m_base;
+}
+
+llvm::Expected<uint32_t> lldb_private::formatters::
+ LibcxxStdProxyArraySyntheticFrontEnd::CalculateNumChildren() {
+
+ if (!m_start || !m_finish)
+ return 0;
+ uint64_t start_val = m_start->GetValueAsUnsigned(0);
+ uint64_t finish_val = m_finish->GetValueAsUnsigned(0);
+
+ if (start_val == 0 || finish_val == 0)
+ return 0;
+
+ if (start_val >= finish_val)
+ return 0;
+
+ size_t num_children = (finish_val - start_val);
+ if (num_children % m_element_size_size_t)
+ return 0;
+ return num_children / m_element_size_size_t;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::GetChildAtIndex(
+ uint32_t idx) {
+ if (!m_base)
+ return lldb::ValueObjectSP();
+
+ uint64_t offset = idx * m_element_size_size_t;
+ offset = offset + m_start->GetValueAsUnsigned(0);
+
+ lldb::ValueObjectSP indirect = CreateValueObjectFromAddress(
+ "", offset, m_backend.GetExecutionContextRef(), m_element_type_size_t);
+ if (!indirect)
+ return lldb::ValueObjectSP();
+
+ const size_t value = indirect->GetValueAsUnsigned(0);
+ if (!value)
+ return lldb::ValueObjectSP();
+
+ offset = value * m_element_size;
+ offset = offset + m_base->GetValueAsUnsigned(0);
+
+ StreamString name;
+ name.Printf("[%" PRIu64 "] -> [%zu]", (uint64_t)idx, value);
+ return CreateValueObjectFromAddress(name.GetString(), offset,
+ m_backend.GetExecutionContextRef(),
+ m_element_type);
+}
+
+lldb::ChildCacheState
+lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::Update() {
+ m_base = nullptr;
+ m_start = nullptr;
+ m_finish = nullptr;
+
+ CompilerType type = m_backend.GetCompilerType();
+ if (type.GetNumTemplateArguments() == 0)
+ return ChildCacheState::eRefetch;
+
+ m_element_type = type.GetTypeTemplateArgument(0);
+ if (std::optional<uint64_t> size = m_element_type.GetByteSize(nullptr))
+ m_element_size = *size;
+
+ if (m_element_size == 0)
+ return ChildCacheState::eRefetch;
+
+ ValueObjectSP vector = m_backend.GetChildMemberWithName("__1d_");
+ if (!vector)
+ return ChildCacheState::eRefetch;
+
+ type = vector->GetCompilerType();
+ if (type.GetNumTemplateArguments() == 0)
+ return ChildCacheState::eRefetch;
+
+ m_element_type_size_t = type.GetTypeTemplateArgument(0);
+ if (std::optional<uint64_t> size = m_element_type_size_t.GetByteSize(nullptr))
+ m_element_size_size_t = *size;
+
+ if (m_element_size_size_t == 0)
+ return ChildCacheState::eRefetch;
+
+ ValueObjectSP base = m_backend.GetChildMemberWithName("__vp_");
+ ValueObjectSP start = vector->GetChildMemberWithName("__begin_");
+ ValueObjectSP finish = vector->GetChildMemberWithName("__end_");
+ if (!base || !start || !finish)
+ return ChildCacheState::eRefetch;
+
+ m_base = base.get();
+ m_start = start.get();
+ m_finish = finish.get();
+
+ return ChildCacheState::eRefetch;
+}
+
+bool lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::
+ MightHaveChildren() {
+ return true;
+}
+
+size_t lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEnd::
+ GetIndexOfChildWithName(ConstString name) {
+ if (!m_base)
+ return std::numeric_limits<size_t>::max();
+ return ExtractIndexFromString(name.GetCString());
+}
+
+lldb_private::SyntheticChildrenFrontEnd *
+lldb_private::formatters::LibcxxStdProxyArraySyntheticFrontEndCreator(
+ CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+ if (!valobj_sp)
+ return nullptr;
+ return new LibcxxStdProxyArraySyntheticFrontEnd(valobj_sp);
+}
diff --git a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/TestDataFormatterLibcxxValarray.py b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/TestDataFormatterLibcxxValarray.py
index b59b770ed6790d..613546b50a770a 100644
--- a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/TestDataFormatterLibcxxValarray.py
+++ b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/TestDataFormatterLibcxxValarray.py
@@ -89,21 +89,93 @@ def test_with_run_command(self):
"frame variable sa",
substrs=[
"sa = stride=2 size=4",
- "[0] = 1",
- "[1] = 3",
- "[2] = 5",
- "[3] = 7",
+ "[0] = 11",
+ "[1] = 13",
+ "[2] = 15",
+ "[3] = 17",
"}",
],
)
# check access-by-index
- self.expect("frame variable sa[0]", substrs=["1"])
- self.expect("frame variable sa[1]", substrs=["3"])
- self.expect("frame variable sa[2]", substrs=["5"])
- self.expect("frame variable sa[3]", substrs=["7"])
+ self.expect("frame variable sa[0]", substrs=["11"])
+ self.expect("frame variable sa[1]", substrs=["13"])
+ self.expect("frame variable sa[2]", substrs=["15"])
+ self.expect("frame variable sa[3]", substrs=["17"])
self.expect(
"frame variable sa[4]",
error=True,
substrs=['array index 4 is not valid for "(slice_array<int>) sa"'],
)
+
+ #
+ # std::gslice_array
+ #
+
+ self.expect(
+ "frame variable ga",
+ substrs=[
+ "ga = size=3",
+ "[0] -> [3] = 13",
+ "[1] -> [4] = 14",
+ "[2] -> [5] = 15",
+ "}",
+ ],
+ )
+
+ # check access-by-index
+ self.expect("frame variable ga[0]", substrs=["13"])
+ self.expect("frame variable ga[1]", substrs=["14"])
+ self.expect("frame variable ga[2]", substrs=["15"])
+ self.expect(
+ "frame variable ga[3]",
+ error=True,
+ substrs=['array index 3 is not valid for "(gslice_array<int>) ga"'],
+ )
+ #
+ # std::mask_array
+ #
+
+ self.expect(
+ "frame variable ma",
+ substrs=[
+ "ma = size=2",
+ "[0] -> [1] = 11",
+ "[1] -> [2] = 12",
+ "}",
+ ],
+ )
+
+ # check access-by-index
+ self.expect("frame variable ma[0]", substrs=["11"])
+ self.expect("frame variable ma[1]", substrs=["12"])
+ self.expect(
+ "frame variable ma[2]",
+ error=True,
+ substrs=['array index 2 is not valid for "(mask_array<int>) ma"'],
+ )
+
+ #
+ # std::indirect_array
+ #
+
+ self.expect(
+ "frame variable ia",
+ substrs=[
+ "ia = size=3",
+ "[0] -> [3] = 13",
+ "[1] -> [6] = 16",
+ "[2] -> [9] = 19",
+ "}",
+ ],
+ )
+
+ # check access-by-index
+ self.expect("frame variable ia[0]", substrs=["13"])
+ self.expect("frame variable ia[1]", substrs=["16"])
+ self.expect("frame variable ia[2]", substrs=["19"])
+ self.expect(
+ "frame variable ia[3]",
+ error=True,
+ substrs=['array index 3 is not valid for "(indirect_array<int>) ia"'],
+ )
diff --git a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/main.cpp b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/main.cpp
index 1481d8b4032927..d31951c755eac0 100644
--- a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/main.cpp
+++ b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/valarray/main.cpp
@@ -13,8 +13,12 @@ int main() {
std::valarray<double> va_double({1.0, 0.5, 0.25, 0.125});
- std::valarray<int> va({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+ std::valarray<int> va({10, 11, 12, 13, 14, 15, 16, 17, 18, 19});
std::slice_array<int> sa = va[std::slice(1, 4, 2)];
+ std::gslice_array<int> ga = va[std::gslice(
+ 3, std::valarray<std::size_t>(3, 1), std::valarray<std::size_t>(1, 1))];
+ std::mask_array<int> ma = va[std::valarray<bool>{false, true, true}];
+ std::indirect_array<int> ia = va[std::valarray<size_t>{3, 6, 9}];
std::cout << "break here\n";
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/88613
More information about the lldb-commits
mailing list