[LLDB] Add formatters for MSVC STL std::tuple #148548
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Member
|
@llvm/pr-subscribers-lldb Author: nerix (Nerixyz) ChangesAdds synthetic children for MSVC STL's template <>
class tuple<> {};
template <class _This, class... _Rest>
class tuple<_This, _Rest...> : private tuple<_Rest...> {
_Tuple_val<_This> _Myfirst;
};So the provider walks the base classes to the desired one. The implementation makes it hard to detect if the empty tuple is from this STL. Fortunately, libstdc++'s synthetic children provider works for empty MSVC STL tuples as well. Towards #24834. Full diff: https://github.com/llvm/llvm-project/pull/148548.diff 6 Files Affected:
diff --git a/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt b/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
index 296159ea28407..ea86b6b4327be 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
+++ b/lldb/source/Plugins/Language/CPlusPlus/CMakeLists.txt
@@ -35,6 +35,7 @@ add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
LibStdcppUniquePointer.cpp
MsvcStl.cpp
MsvcStlSmartPointer.cpp
+ MsvcStlTuple.cpp
MSVCUndecoratedNameParser.cpp
LINK_COMPONENTS
diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
index 2db3e6f0ca315..3ff95aafb8c52 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
@@ -1507,10 +1507,6 @@ static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
"^std::((__debug::)?|(__cxx11::)?)list<.+>(( )?&)?$",
stl_summary_flags, true);
- AddCXXSummary(cpp_category_sp, ContainerSizeSummaryProvider,
- "libstdc++ std::tuple summary provider",
- "^std::tuple<.*>(( )?&)?$", stl_summary_flags, true);
-
cpp_category_sp->AddTypeSummary(
"^std::((__debug::)?|(__cxx11::)?)forward_list<.+>(( )?&)?$",
eFormatterMatchRegex,
@@ -1540,11 +1536,6 @@ static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
"std::unique_ptr synthetic children", "^std::unique_ptr<.+>(( )?&)?$",
stl_synth_flags, true);
- AddCXXSynthetic(
- cpp_category_sp,
- lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
- "std::tuple synthetic children", "^std::tuple<.*>(( )?&)?$",
- stl_synth_flags, true);
static constexpr const char *const libstdcpp_std_coroutine_handle_regex =
"^std::coroutine_handle<.+>(( )?&)?$";
@@ -1599,6 +1590,17 @@ GenericSmartPointerSummaryProvider(ValueObject &valobj, Stream &stream,
return LibStdcppSmartPointerSummaryProvider(valobj, stream, options);
}
+static lldb_private::SyntheticChildrenFrontEnd *
+GenericTupleSyntheticFrontEndCreator(CXXSyntheticChildren *children,
+ lldb::ValueObjectSP valobj_sp) {
+ if (!valobj_sp)
+ return nullptr;
+
+ if (IsMsvcStlTuple(*valobj_sp))
+ return MsvcStlTupleSyntheticFrontEndCreator(children, valobj_sp);
+ return LibStdcppTupleSyntheticFrontEndCreator(children, valobj_sp);
+}
+
/// Load formatters that are formatting types from more than one STL
static void LoadCommonStlFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
if (!cpp_category_sp)
@@ -1648,6 +1650,12 @@ static void LoadCommonStlFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
AddCXXSynthetic(cpp_category_sp, GenericSmartPointerSyntheticFrontEndCreator,
"std::weak_ptr synthetic children",
"^std::weak_ptr<.+>(( )?&)?$", stl_synth_flags, true);
+ AddCXXSynthetic(cpp_category_sp, GenericTupleSyntheticFrontEndCreator,
+ "std::tuple synthetic children", "^std::tuple<.*>(( )?&)?$",
+ stl_synth_flags, true);
+
+ stl_summary_flags.SetDontShowChildren(false);
+ stl_summary_flags.SetSkipPointers(false);
AddCXXSummary(cpp_category_sp, GenericSmartPointerSummaryProvider,
"MSVC STL/libstdc++ std::shared_ptr summary provider",
@@ -1655,6 +1663,9 @@ static void LoadCommonStlFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
AddCXXSummary(cpp_category_sp, GenericSmartPointerSummaryProvider,
"MSVC STL/libstdc++ std::weak_ptr summary provider",
"^std::weak_ptr<.+>(( )?&)?$", stl_summary_flags, true);
+ AddCXXSummary(cpp_category_sp, ContainerSizeSummaryProvider,
+ "MSVC STL/libstdc++ std::tuple summary provider",
+ "^std::tuple<.*>(( )?&)?$", stl_summary_flags, true);
}
static void LoadMsvcStlFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
diff --git a/lldb/source/Plugins/Language/CPlusPlus/MsvcStl.h b/lldb/source/Plugins/Language/CPlusPlus/MsvcStl.h
index edf3f4e8a5387..c66ddf73f3129 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/MsvcStl.h
+++ b/lldb/source/Plugins/Language/CPlusPlus/MsvcStl.h
@@ -37,6 +37,11 @@ bool MsvcStlSmartPointerSummaryProvider(ValueObject &valobj, Stream &stream,
lldb_private::SyntheticChildrenFrontEnd *
MsvcStlSmartPointerSyntheticFrontEndCreator(lldb::ValueObjectSP valobj_sp);
+bool IsMsvcStlTuple(ValueObject &valobj);
+SyntheticChildrenFrontEnd *
+MsvcStlTupleSyntheticFrontEndCreator(CXXSyntheticChildren *,
+ lldb::ValueObjectSP valobj_sp);
+
} // namespace formatters
} // namespace lldb_private
diff --git a/lldb/source/Plugins/Language/CPlusPlus/MsvcStlTuple.cpp b/lldb/source/Plugins/Language/CPlusPlus/MsvcStlTuple.cpp
new file mode 100644
index 0000000000000..fe20b4c141a65
--- /dev/null
+++ b/lldb/source/Plugins/Language/CPlusPlus/MsvcStlTuple.cpp
@@ -0,0 +1,105 @@
+//===-- MsvcStlTuple.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 "MsvcStl.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+class TupleFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+ TupleFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
+ Update();
+ }
+
+ llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override {
+ auto optional_idx = formatters::ExtractIndexFromString(name.GetCString());
+ if (!optional_idx) {
+ return llvm::createStringError("Type has no child named '%s'",
+ name.AsCString());
+ }
+ return *optional_idx;
+ }
+
+ lldb::ChildCacheState Update() override;
+ llvm::Expected<uint32_t> CalculateNumChildren() override {
+ return m_elements.size();
+ }
+ ValueObjectSP GetChildAtIndex(uint32_t idx) override;
+
+private:
+ // The lifetime of a ValueObject and all its derivative ValueObjects
+ // (children, clones, etc.) is managed by a ClusterManager. These
+ // objects are only destroyed when every shared pointer to any of them
+ // is destroyed, so we must not store a shared pointer to any ValueObject
+ // derived from our backend ValueObject (since we're in the same cluster).
+ std::vector<ValueObject *> m_elements;
+};
+
+} // namespace
+
+lldb::ChildCacheState TupleFrontEnd::Update() {
+ m_elements.clear();
+
+ size_t n_elements = 0;
+ for (CompilerType ty = m_backend.GetCompilerType();
+ ty.GetNumDirectBaseClasses() > 0;
+ ty = ty.GetDirectBaseClassAtIndex(0, nullptr))
+ ++n_elements;
+
+ m_elements.assign(n_elements, nullptr);
+ return lldb::ChildCacheState::eRefetch;
+}
+
+ValueObjectSP TupleFrontEnd::GetChildAtIndex(uint32_t idx) {
+ if (idx >= m_elements.size())
+ return nullptr;
+ if (m_elements[idx])
+ return m_elements[idx]->GetSP();
+
+ CompilerType holder_ty = m_backend.GetCompilerType();
+ for (uint32_t i = 0; i < idx; i++) {
+ holder_ty = holder_ty.GetDirectBaseClassAtIndex(0, nullptr);
+ if (!holder_ty.IsValid())
+ return nullptr;
+ }
+
+ ValueObjectSP holder_sp = m_backend.Cast(holder_ty);
+ if (!holder_sp)
+ return nullptr;
+ holder_sp = holder_sp->GetChildMemberWithName("_Myfirst");
+
+ if (!holder_sp)
+ return nullptr;
+
+ ValueObjectSP val_sp = holder_sp->GetChildMemberWithName("_Val");
+ if (!val_sp)
+ return nullptr;
+
+ m_elements[idx] =
+ val_sp->Clone(ConstString(llvm::formatv("[{0}]", idx).str())).get();
+ return m_elements[idx]->GetSP();
+}
+
+bool formatters::IsMsvcStlTuple(ValueObject &valobj) {
+ // This returns false for empty tuples, but the libstdc++ formatter handles
+ // this correctly.
+ if (auto valobj_sp = valobj.GetNonSyntheticValue())
+ return valobj_sp->GetChildMemberWithName("_Myfirst") != nullptr;
+ return false;
+}
+
+SyntheticChildrenFrontEnd *formatters::MsvcStlTupleSyntheticFrontEndCreator(
+ CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+ if (valobj_sp)
+ return new TupleFrontEnd(*valobj_sp);
+ return nullptr;
+}
diff --git a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/TestDataFormatterStdTuple.py b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/TestDataFormatterStdTuple.py
index ade502e12b928..b23d549fe4c18 100644
--- a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/TestDataFormatterStdTuple.py
+++ b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/TestDataFormatterStdTuple.py
@@ -74,3 +74,9 @@ def test_libcxx(self):
def test_libstdcxx(self):
self.build(dictionary={"USE_LIBSTDCPP": 1})
self.do_test()
+
+ @add_test_categories(["msvcstl"])
+ def test_msvcstl(self):
+ # No flags, because the "msvcstl" category checks that the MSVC STL is used by default.
+ self.build()
+ self.do_test()
diff --git a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/main.cpp b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/main.cpp
index d49dbe8a5f1af..53d0a4efd3865 100644
--- a/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/main.cpp
+++ b/lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/tuple/main.cpp
@@ -6,5 +6,6 @@ int main() {
std::tuple<int> one_elt{47};
std::tuple<std::string> string_elt{"foobar"};
std::tuple<int, long, std::string> three_elts{1, 47l, "foo"};
+ auto *foo = ∅ // needed with MSVC STL to keep the variable
return 0; // break here
}
|
Michael137
approved these changes
Jul 14, 2025
Member
This is why i wish we had something definitive in debug-info to tell us what STL a compile-unit was compiled against. I pinged @ldionne about this separately. |
Nerixyz
force-pushed
the
feat/lldb-ms-tuple
branch
from
df31ab8 to
d8983cb
Compare
|
✅ With the latest revision this PR passed the C/C++ code formatter. |
Nerixyz
force-pushed
the
feat/lldb-ms-tuple
branch
from
d8983cb to
90ff1a3
Compare
Michael137
reviewed
Jul 15, 2025
Nerixyz
force-pushed
the
feat/lldb-ms-tuple
branch
from
90ff1a3 to
9950cdb
Compare
Michael137
approved these changes
Jul 15, 2025
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Adds synthetic children for MSVC STL's
std::tuple. Atupleis a chain of base classes:So the provider walks the base classes to the desired one.
The implementation makes it hard to detect if the empty tuple is from this STL. Fortunately, libstdc++'s synthetic children provider works for empty MSVC STL tuples as well.
Towards #24834.