[LLDB] Add type summaries for MSVC STL strings

Author: Nerixyz

lldb/include/lldb/DataFormatters/FormatClasses.h

@@ -149,13 +149,16 @@ class FormattersMatchData {
   CandidateLanguagesVector m_candidate_languages;
 };
 
+using CxxTypeCandidateMatchFn = bool(const FormattersMatchCandidate &);
+
 class TypeNameSpecifierImpl {
 public:
   TypeNameSpecifierImpl() = default;
 
   TypeNameSpecifierImpl(llvm::StringRef name,
-                        lldb::FormatterMatchType match_type)
-      : m_match_type(match_type) {
+                        lldb::FormatterMatchType match_type,
+                        CxxTypeCandidateMatchFn *match_fn = nullptr)
+      : m_match_type(match_type), m_match_fn(match_fn) {
     m_type.m_type_name = std::string(name);
   }
 
@@ -188,6 +191,8 @@ class TypeNameSpecifierImpl {
     return CompilerType();
   }
 
+  CxxTypeCandidateMatchFn *GetCxxMatchFunction() const { return m_match_fn; }
+
   lldb::FormatterMatchType GetMatchType() { return m_match_type; }
 
   bool IsRegex() { return m_match_type == lldb::eFormatterMatchRegex; }
@@ -200,6 +205,7 @@ class TypeNameSpecifierImpl {
     CompilerType m_compiler_type;
   };
   TypeOrName m_type;
+  CxxTypeCandidateMatchFn *m_match_fn = nullptr;
 
   TypeNameSpecifierImpl(const TypeNameSpecifierImpl &) = delete;
   const TypeNameSpecifierImpl &

lldb/include/lldb/DataFormatters/FormattersContainer.h

@@ -50,6 +50,7 @@ class TypeMatcher {
   /// - eFormatterMatchCallback: run the function in m_name to decide if a type
   ///   matches or not.
   lldb::FormatterMatchType m_match_type;
+  CxxTypeCandidateMatchFn *m_match_fn = nullptr;
 
   // if the user tries to add formatters for, say, "struct Foo" those will not
   // match any type because of the way we strip qualifiers from typenames this
@@ -86,42 +87,29 @@ class TypeMatcher {
   /// name specifier.
   TypeMatcher(lldb::TypeNameSpecifierImplSP type_specifier)
       : m_name(type_specifier->GetName()),
-        m_match_type(type_specifier->GetMatchType()) {
+        m_match_type(type_specifier->GetMatchType()),
+        m_match_fn(type_specifier->GetCxxMatchFunction()) {
     if (m_match_type == lldb::eFormatterMatchRegex)
       m_type_name_regex = RegularExpression(type_specifier->GetName());
   }
 
   /// True iff this matches the given type.
   bool Matches(FormattersMatchCandidate candidate_type) const {
-    ConstString type_name = candidate_type.GetTypeName();
-    switch (m_match_type) {
-    case lldb::eFormatterMatchExact:
-      return m_name == type_name ||
-             StripTypeName(m_name) == StripTypeName(type_name);
-    case lldb::eFormatterMatchRegex:
-      return m_type_name_regex.Execute(type_name.GetStringRef());
-    case lldb::eFormatterMatchCallback:
-      // CommandObjectType{Synth,Filter}Add tries to prevent the user from
-      // creating both a synthetic child provider and a filter for the same type
-      // in the same category, but we don't have a type object at that point, so
-      // it creates a dummy candidate without type or script interpreter.
-      // Skip callback matching in these cases.
-      if (candidate_type.GetScriptInterpreter())
-        return candidate_type.GetScriptInterpreter()->FormatterCallbackFunction(
-            m_name.AsCString(),
-            std::make_shared<TypeImpl>(candidate_type.GetType()));
-    }
-    return false;
+    if (!MatchesName(candidate_type))
+      return false;
+    if (m_match_fn && !m_match_fn(candidate_type))
+      return false;
+    return true;
   }
 
   lldb::FormatterMatchType GetMatchType() const { return m_match_type; }
 
   /// Returns the underlying match string for this TypeMatcher.
   ConstString GetMatchString() const {
     if (m_match_type == lldb::eFormatterMatchExact)
-        return StripTypeName(m_name);
+      return StripTypeName(m_name);
     if (m_match_type == lldb::eFormatterMatchRegex)
-        return ConstString(m_type_name_regex.GetText());
+      return ConstString(m_type_name_regex.GetText());
     return m_name;
   }
 
@@ -134,7 +122,31 @@ class TypeMatcher {
   /// (lldb) type summary add --summary-string \"A\" -x TypeName
   /// (lldb) type summary delete TypeName
   bool CreatedBySameMatchString(TypeMatcher other) const {
-    return GetMatchString() == other.GetMatchString();
+    return GetMatchString() == other.GetMatchString() &&
+           m_match_fn == other.m_match_fn;
+  }
+
+private:
+  bool MatchesName(FormattersMatchCandidate candidate_type) const {
+    ConstString type_name = candidate_type.GetTypeName();
+    switch (m_match_type) {
+    case lldb::eFormatterMatchExact:
+      return m_name == type_name ||
+             StripTypeName(m_name) == StripTypeName(type_name);
+    case lldb::eFormatterMatchRegex:
+      return m_type_name_regex.Execute(type_name.GetStringRef());
+    case lldb::eFormatterMatchCallback:
+      // CommandObjectType{Synth,Filter}Add tries to prevent the user from
+      // creating both a synthetic child provider and a filter for the same type
+      // in the same category, but we don't have a type object at that point, so
+      // it creates a dummy candidate without type or script interpreter.
+      // Skip callback matching in these cases.
+      if (candidate_type.GetScriptInterpreter())
+        return candidate_type.GetScriptInterpreter()->FormatterCallbackFunction(
+            m_name.AsCString(),
+            std::make_shared<TypeImpl>(candidate_type.GetType()));
+    }
+    return false;
   }
 };
 

lldb/include/lldb/DataFormatters/StringPrinter.h

@@ -152,6 +152,21 @@ class StringPrinter {
   template <StringElementType element_type>
   static bool
   ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions &options);
+
+  template <StringElementType element_type>
+  static constexpr uint64_t ElementByteSize() {
+    switch (element_type) {
+    case StringElementType::ASCII:
+    case StringElementType::UTF8:
+      return 1;
+    case StringElementType::UTF16:
+      return 2;
+    case StringElementType::UTF32:
+      return 3;
+    default:
+      return 0;
+    }
+  }
 };
 
 } // namespace formatters

lldb/packages/Python/lldbsuite/test/dotest.py

@@ -831,6 +831,26 @@ def checkLibstdcxxSupport():
     configuration.skip_categories.append("libstdcxx")
 
 
+def canRunMsvcStlTests():
+    from lldbsuite.test import lldbplatformutil
+
+    platform = lldbplatformutil.getPlatform()
+    if platform == "windows":
+        return True, "MSVC STL is present on Windows"
+    return False, f"Don't know how to build with MSVC's STL on {platform}"
+
+
+def checkMsvcStlSupport():
+    result, reason = canRunMsvcStlTests()
+    if result:
+        return  # msvcstl supported
+    if "msvcstl" in configuration.categories_list:
+        return  # msvcstl category explicitly requested, let it run.
+    if configuration.verbose:
+        print(f"msvcstl tests will not be run because: {reason}")
+    configuration.skip_categories.append("msvcstl")
+
+
 def canRunWatchpointTests():
     from lldbsuite.test import lldbplatformutil
 
@@ -1044,6 +1064,7 @@ def run_suite():
 
     checkLibcxxSupport()
     checkLibstdcxxSupport()
+    checkMsvcStlSupport()
     checkWatchpointSupport()
     checkDebugInfoSupport()
     checkDebugServerSupport()

lldb/packages/Python/lldbsuite/test/test_categories.py

@@ -33,6 +33,7 @@
     "lldb-server": "Tests related to lldb-server",
     "lldb-dap": "Tests for the Debug Adapter Protocol with lldb-dap",
     "llgs": "Tests for the gdb-server functionality of lldb-server",
+    "msvcstl": "Test for MSVC STL data formatters",
     "pexpect": "Tests requiring the pexpect library to be available",
     "objc": "Tests related to the Objective-C programming language support",
     "pyapi": "Tests related to the Python API",

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

@@ -32,6 +32,7 @@ add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   LibStdcpp.cpp
   LibStdcppTuple.cpp
   LibStdcppUniquePointer.cpp
+  MsvcStl.cpp
   MSVCUndecoratedNameParser.cpp
 
   LINK_COMPONENTS

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

@@ -46,6 +46,7 @@
 #include "LibCxxVariant.h"
 #include "LibStdcpp.h"
 #include "MSVCUndecoratedNameParser.h"
+#include "MsvcStl.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
@@ -1372,6 +1373,52 @@ static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
           "${var.__y_} ${var.__m_} ${var.__wdl_}")));
 }
 
+static bool IsMsvcStdStringType(const FormattersMatchCandidate &candidate) {
+  std::vector<uint32_t> indexes;
+  return candidate.GetType()
+             .GetCompilerType(true)
+             .GetIndexOfChildMemberWithName("_Mypair", true, indexes) > 0;
+}
+
+static bool
+IsLibstdcppStdStringType(const FormattersMatchCandidate &candidate) {
+  std::vector<uint32_t> indexes;
+  return candidate.GetType()
+             .GetCompilerType(true)
+             .GetIndexOfChildMemberWithName("_M_dataplus", true, indexes) > 0;
+}
+
+static void RegisterStdStringSummaryProvider(
+    const lldb::TypeCategoryImplSP &category_sp, llvm::StringRef string_ty,
+    llvm::StringRef char_ty, CxxTypeCandidateMatchFn *match_fn,
+    lldb::TypeSummaryImplSP summary_sp) {
+  auto makeSpecifier = [match_fn](llvm::StringRef name) {
+    return std::make_shared<lldb_private::TypeNameSpecifierImpl>(
+        name, eFormatterMatchExact, match_fn);
+  };
+
+  category_sp->AddTypeSummary(makeSpecifier(string_ty), summary_sp);
+
+  // std::basic_string<char>
+  category_sp->AddTypeSummary(
+      makeSpecifier((llvm::Twine("std::basic_string<") + char_ty + ">").str()),
+      summary_sp);
+  // std::basic_string<char,std::char_traits<char>,std::allocator<char> >
+  category_sp->AddTypeSummary(
+      makeSpecifier((llvm::Twine("std::basic_string<") + char_ty +
+                     ",std::char_traits<" + char_ty + ">,std::allocator<" +
+                     char_ty + "> >")
+                        .str()),
+      summary_sp);
+  // std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+  category_sp->AddTypeSummary(
+      makeSpecifier((llvm::Twine("std::basic_string<") + char_ty +
+                     ", std::char_traits<" + char_ty + ">, std::allocator<" +
+                     char_ty + "> >")
+                        .str()),
+      summary_sp);
+}
+
 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
@@ -1385,26 +1432,17 @@ static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
       .SetShowMembersOneLiner(false)
       .SetHideItemNames(false);
 
-  lldb::TypeSummaryImplSP std_string_summary_sp(
-      new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
-
   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
       stl_summary_flags, LibStdcppStringSummaryProvider,
       "libstdc++ c++11 std::string summary provider"));
   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
       stl_summary_flags, LibStdcppWStringSummaryProvider,
       "libstdc++ c++11 std::wstring summary provider"));
 
-  cpp_category_sp->AddTypeSummary("std::string", eFormatterMatchExact,
-                                  std_string_summary_sp);
-  cpp_category_sp->AddTypeSummary("std::basic_string<char>",
-                                  eFormatterMatchExact, std_string_summary_sp);
-  cpp_category_sp->AddTypeSummary(
-      "std::basic_string<char,std::char_traits<char>,std::allocator<char> >",
-      eFormatterMatchExact, std_string_summary_sp);
-  cpp_category_sp->AddTypeSummary(
-      "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
-      eFormatterMatchExact, std_string_summary_sp);
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::string", "char", IsLibstdcppStdStringType,
+      std::make_shared<StringSummaryFormat>(stl_summary_flags,
+                                            "${var._M_dataplus._M_p}"));
 
   cpp_category_sp->AddTypeSummary("std::__cxx11::string", eFormatterMatchExact,
                                   cxx11_string_summary_sp);
@@ -1420,20 +1458,10 @@ static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
 
   // making sure we force-pick the summary for printing wstring (_M_p is a
   // wchar_t*)
-  lldb::TypeSummaryImplSP std_wstring_summary_sp(
-      new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
-
-  cpp_category_sp->AddTypeSummary("std::wstring", eFormatterMatchExact,
-                                  std_wstring_summary_sp);
-  cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t>",
-                                  eFormatterMatchExact, std_wstring_summary_sp);
-  cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t,std::char_traits<"
-                                  "wchar_t>,std::allocator<wchar_t> >",
-                                  eFormatterMatchExact, std_wstring_summary_sp);
-  cpp_category_sp->AddTypeSummary(
-      "std::basic_string<wchar_t, std::char_traits<wchar_t>, "
-      "std::allocator<wchar_t> >",
-      eFormatterMatchExact, std_wstring_summary_sp);
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::wstring", "wchar_t", IsLibstdcppStdStringType,
+      std::make_shared<StringSummaryFormat>(stl_summary_flags,
+                                            "${var._M_dataplus._M_p%S}"));
 
   cpp_category_sp->AddTypeSummary("std::__cxx11::wstring", eFormatterMatchExact,
                                   cxx11_wstring_summary_sp);
@@ -1629,6 +1657,52 @@ static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
                 "^std::optional<.+>(( )?&)?$", stl_summary_flags, true);
 }
 
+static void LoadMsvcStlFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
+  if (!cpp_category_sp)
+    return;
+
+  TypeSummaryImpl::Flags stl_summary_flags;
+  stl_summary_flags.SetCascades(true)
+      .SetSkipPointers(false)
+      .SetSkipReferences(false)
+      .SetDontShowChildren(true)
+      .SetDontShowValue(false)
+      .SetShowMembersOneLiner(false)
+      .SetHideItemNames(false);
+
+  using StringElementType = StringPrinter::StringElementType;
+
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::string", "char", IsMsvcStdStringType,
+      std::make_shared<CXXFunctionSummaryFormat>(
+          stl_summary_flags,
+          MsvcStlStringSummaryProvider<StringElementType::ASCII>,
+          "MSVC STL std::string summary provider"));
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::wstring", "wchar_t", IsMsvcStdStringType,
+      std::make_shared<CXXFunctionSummaryFormat>(
+          stl_summary_flags, MsvcStlWStringSummaryProvider,
+          "MSVC STL std::wstring summary provider"));
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::u8string", "char8_t", IsMsvcStdStringType,
+      std::make_shared<CXXFunctionSummaryFormat>(
+          stl_summary_flags,
+          MsvcStlStringSummaryProvider<StringElementType::UTF8>,
+          "MSVC STL std::u8string summary provider"));
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::u16string", "char16_t", IsMsvcStdStringType,
+      std::make_shared<CXXFunctionSummaryFormat>(
+          stl_summary_flags,
+          MsvcStlStringSummaryProvider<StringElementType::UTF16>,
+          "MSVC STL std::u16string summary provider"));
+  RegisterStdStringSummaryProvider(
+      cpp_category_sp, "std::u32string", "char32_t", IsMsvcStdStringType,
+      std::make_shared<CXXFunctionSummaryFormat>(
+          stl_summary_flags,
+          MsvcStlStringSummaryProvider<StringElementType::UTF32>,
+          "MSVC STL std::u32string summary provider"));
+}
+
 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
@@ -1743,6 +1817,7 @@ lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
       // LLDB prioritizes the last loaded matching formatter.
       LoadLibCxxFormatters(g_category);
       LoadLibStdcppFormatters(g_category);
+      LoadMsvcStlFormatters(g_category);
       LoadSystemFormatters(g_category);
     }
   });