1 //===-- CPlusPlusLanguage.cpp ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CPlusPlusLanguage.h"
10 
11 #include <cctype>
12 #include <cstring>
13 
14 #include <functional>
15 #include <memory>
16 #include <mutex>
17 #include <set>
18 
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Demangle/ItaniumDemangle.h"
21 
22 #include "lldb/Core/Mangled.h"
23 #include "lldb/Core/Module.h"
24 #include "lldb/Core/PluginManager.h"
25 #include "lldb/Core/UniqueCStringMap.h"
26 #include "lldb/DataFormatters/CXXFunctionPointer.h"
27 #include "lldb/DataFormatters/DataVisualization.h"
28 #include "lldb/DataFormatters/FormattersHelpers.h"
29 #include "lldb/DataFormatters/VectorType.h"
30 #include "lldb/Symbol/SymbolFile.h"
31 #include "lldb/Utility/ConstString.h"
32 #include "lldb/Utility/Log.h"
33 #include "lldb/Utility/RegularExpression.h"
34 
35 #include "BlockPointer.h"
36 #include "CPlusPlusNameParser.h"
37 #include "CxxStringTypes.h"
38 #include "Generic.h"
39 #include "LibCxx.h"
40 #include "LibCxxAtomic.h"
41 #include "LibCxxVariant.h"
42 #include "LibStdcpp.h"
43 #include "MSVCUndecoratedNameParser.h"
44 
45 using namespace lldb;
46 using namespace lldb_private;
47 using namespace lldb_private::formatters;
48 
49 LLDB_PLUGIN_DEFINE(CPlusPlusLanguage)
50 
51 void CPlusPlusLanguage::Initialize() {
52   PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
53                                 CreateInstance);
54 }
55 
56 void CPlusPlusLanguage::Terminate() {
57   PluginManager::UnregisterPlugin(CreateInstance);
58 }
59 
60 bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled) const {
61   const char *mangled_name = mangled.GetMangledName().GetCString();
62   return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name);
63 }
64 
65 ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments(
66     Mangled mangled) const {
67   const char *mangled_name_cstr = mangled.GetMangledName().GetCString();
68   ConstString demangled_name = mangled.GetDemangledName();
69   if (demangled_name && mangled_name_cstr && mangled_name_cstr[0]) {
70     if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
71         (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure,
72                                         // typeinfo structure, and typeinfo
73                                         // mangled_name
74          mangled_name_cstr[2] != 'G' && // avoid guard variables
75          mangled_name_cstr[2] != 'Z'))  // named local entities (if we
76                                         // eventually handle eSymbolTypeData,
77                                         // we will want this back)
78     {
79       CPlusPlusLanguage::MethodName cxx_method(demangled_name);
80       if (!cxx_method.GetBasename().empty()) {
81         std::string shortname;
82         if (!cxx_method.GetContext().empty())
83           shortname = cxx_method.GetContext().str() + "::";
84         shortname += cxx_method.GetBasename().str();
85         return ConstString(shortname);
86       }
87     }
88   }
89   if (demangled_name)
90     return demangled_name;
91   return mangled.GetMangledName();
92 }
93 
94 // Static Functions
95 
96 Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
97   // Use plugin for C++ but not for Objective-C++ (which has its own plugin).
98   if (Language::LanguageIsCPlusPlus(language) &&
99       language != eLanguageTypeObjC_plus_plus)
100     return new CPlusPlusLanguage();
101   return nullptr;
102 }
103 
104 void CPlusPlusLanguage::MethodName::Clear() {
105   m_full.Clear();
106   m_basename = llvm::StringRef();
107   m_context = llvm::StringRef();
108   m_arguments = llvm::StringRef();
109   m_qualifiers = llvm::StringRef();
110   m_parsed = false;
111   m_parse_error = false;
112 }
113 
114 static bool ReverseFindMatchingChars(const llvm::StringRef &s,
115                                      const llvm::StringRef &left_right_chars,
116                                      size_t &left_pos, size_t &right_pos,
117                                      size_t pos = llvm::StringRef::npos) {
118   assert(left_right_chars.size() == 2);
119   left_pos = llvm::StringRef::npos;
120   const char left_char = left_right_chars[0];
121   const char right_char = left_right_chars[1];
122   pos = s.find_last_of(left_right_chars, pos);
123   if (pos == llvm::StringRef::npos || s[pos] == left_char)
124     return false;
125   right_pos = pos;
126   uint32_t depth = 1;
127   while (pos > 0 && depth > 0) {
128     pos = s.find_last_of(left_right_chars, pos);
129     if (pos == llvm::StringRef::npos)
130       return false;
131     if (s[pos] == left_char) {
132       if (--depth == 0) {
133         left_pos = pos;
134         return left_pos < right_pos;
135       }
136     } else if (s[pos] == right_char) {
137       ++depth;
138     }
139   }
140   return false;
141 }
142 
143 static bool IsTrivialBasename(const llvm::StringRef &basename) {
144   // Check that the basename matches with the following regular expression
145   // "^~?([A-Za-z_][A-Za-z_0-9]*)$" We are using a hand written implementation
146   // because it is significantly more efficient then using the general purpose
147   // regular expression library.
148   size_t idx = 0;
149   if (basename.size() > 0 && basename[0] == '~')
150     idx = 1;
151 
152   if (basename.size() <= idx)
153     return false; // Empty string or "~"
154 
155   if (!std::isalpha(basename[idx]) && basename[idx] != '_')
156     return false; // First character (after removing the possible '~'') isn't in
157                   // [A-Za-z_]
158 
159   // Read all characters matching [A-Za-z_0-9]
160   ++idx;
161   while (idx < basename.size()) {
162     if (!std::isalnum(basename[idx]) && basename[idx] != '_')
163       break;
164     ++idx;
165   }
166 
167   // We processed all characters. It is a vaild basename.
168   return idx == basename.size();
169 }
170 
171 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
172   // This method tries to parse simple method definitions which are presumably
173   // most comman in user programs. Definitions that can be parsed by this
174   // function don't have return types and templates in the name.
175   // A::B::C::fun(std::vector<T> &) const
176   size_t arg_start, arg_end;
177   llvm::StringRef full(m_full.GetCString());
178   llvm::StringRef parens("()", 2);
179   if (ReverseFindMatchingChars(full, parens, arg_start, arg_end)) {
180     m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
181     if (arg_end + 1 < full.size())
182       m_qualifiers = full.substr(arg_end + 1).ltrim();
183 
184     if (arg_start == 0)
185       return false;
186     size_t basename_end = arg_start;
187     size_t context_start = 0;
188     size_t context_end = full.rfind(':', basename_end);
189     if (context_end == llvm::StringRef::npos)
190       m_basename = full.substr(0, basename_end);
191     else {
192       if (context_start < context_end)
193         m_context = full.substr(context_start, context_end - 1 - context_start);
194       const size_t basename_begin = context_end + 1;
195       m_basename = full.substr(basename_begin, basename_end - basename_begin);
196     }
197 
198     if (IsTrivialBasename(m_basename)) {
199       return true;
200     } else {
201       // The C++ basename doesn't match our regular expressions so this can't
202       // be a valid C++ method, clear everything out and indicate an error
203       m_context = llvm::StringRef();
204       m_basename = llvm::StringRef();
205       m_arguments = llvm::StringRef();
206       m_qualifiers = llvm::StringRef();
207       return false;
208     }
209   }
210   return false;
211 }
212 
213 void CPlusPlusLanguage::MethodName::Parse() {
214   if (!m_parsed && m_full) {
215     if (TrySimplifiedParse()) {
216       m_parse_error = false;
217     } else {
218       CPlusPlusNameParser parser(m_full.GetStringRef());
219       if (auto function = parser.ParseAsFunctionDefinition()) {
220         m_basename = function.getValue().name.basename;
221         m_context = function.getValue().name.context;
222         m_arguments = function.getValue().arguments;
223         m_qualifiers = function.getValue().qualifiers;
224         m_parse_error = false;
225       } else {
226         m_parse_error = true;
227       }
228     }
229     m_parsed = true;
230   }
231 }
232 
233 llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() {
234   if (!m_parsed)
235     Parse();
236   return m_basename;
237 }
238 
239 llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() {
240   if (!m_parsed)
241     Parse();
242   return m_context;
243 }
244 
245 llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() {
246   if (!m_parsed)
247     Parse();
248   return m_arguments;
249 }
250 
251 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
252   if (!m_parsed)
253     Parse();
254   return m_qualifiers;
255 }
256 
257 std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
258   if (!m_parsed)
259     Parse();
260   if (m_context.empty())
261     return std::string(m_basename);
262 
263   std::string res;
264   res += m_context;
265   res += "::";
266   res += m_basename;
267   return res;
268 }
269 
270 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
271   // FIXME!! we should really run through all the known C++ Language plugins
272   // and ask each one if this is a C++ mangled name
273 
274   Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
275 
276   if (scheme == Mangled::eManglingSchemeNone)
277     return false;
278 
279   return true;
280 }
281 
282 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
283     const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
284   if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
285     return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context,
286                                                                   identifier);
287 
288   CPlusPlusNameParser parser(name);
289   if (auto full_name = parser.ParseAsFullName()) {
290     identifier = full_name.getValue().basename;
291     context = full_name.getValue().context;
292     return true;
293   }
294   return false;
295 }
296 
297 namespace {
298 class NodeAllocator {
299   llvm::BumpPtrAllocator Alloc;
300 
301 public:
302   void reset() { Alloc.Reset(); }
303 
304   template <typename T, typename... Args> T *makeNode(Args &&... args) {
305     return new (Alloc.Allocate(sizeof(T), alignof(T)))
306         T(std::forward<Args>(args)...);
307   }
308 
309   void *allocateNodeArray(size_t sz) {
310     return Alloc.Allocate(sizeof(llvm::itanium_demangle::Node *) * sz,
311                           alignof(llvm::itanium_demangle::Node *));
312   }
313 };
314 
315 template <typename Derived>
316 class ManglingSubstitutor
317     : public llvm::itanium_demangle::AbstractManglingParser<Derived,
318                                                             NodeAllocator> {
319   using Base =
320       llvm::itanium_demangle::AbstractManglingParser<Derived, NodeAllocator>;
321 
322 public:
323   ManglingSubstitutor() : Base(nullptr, nullptr) {}
324 
325   template <typename... Ts>
326   ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) {
327     this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...);
328     return substituteImpl(Mangled);
329   }
330 
331 protected:
332   void reset(llvm::StringRef Mangled) {
333     Base::reset(Mangled.begin(), Mangled.end());
334     Written = Mangled.begin();
335     Result.clear();
336     Substituted = false;
337   }
338 
339   ConstString substituteImpl(llvm::StringRef Mangled) {
340     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
341     if (this->parse() == nullptr) {
342       LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled);
343       return ConstString();
344     }
345     if (!Substituted)
346       return ConstString();
347 
348     // Append any trailing unmodified input.
349     appendUnchangedInput();
350     LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result);
351     return ConstString(Result);
352   }
353 
354   void trySubstitute(llvm::StringRef From, llvm::StringRef To) {
355     if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From))
356       return;
357 
358     // We found a match. Append unmodified input up to this point.
359     appendUnchangedInput();
360 
361     // And then perform the replacement.
362     Result += To;
363     Written += From.size();
364     Substituted = true;
365   }
366 
367 private:
368   /// Input character until which we have constructed the respective output
369   /// already.
370   const char *Written;
371 
372   llvm::SmallString<128> Result;
373 
374   /// Whether we have performed any substitutions.
375   bool Substituted;
376 
377   const char *currentParserPos() const { return this->First; }
378 
379   void appendUnchangedInput() {
380     Result +=
381         llvm::StringRef(Written, std::distance(Written, currentParserPos()));
382     Written = currentParserPos();
383   }
384 };
385 
386 /// Given a mangled function `Mangled`, replace all the primitive function type
387 /// arguments of `Search` with type `Replace`.
388 class TypeSubstitutor : public ManglingSubstitutor<TypeSubstitutor> {
389   llvm::StringRef Search;
390   llvm::StringRef Replace;
391 
392 public:
393   void reset(llvm::StringRef Mangled, llvm::StringRef Search,
394              llvm::StringRef Replace) {
395     ManglingSubstitutor::reset(Mangled);
396     this->Search = Search;
397     this->Replace = Replace;
398   }
399 
400   llvm::itanium_demangle::Node *parseType() {
401     trySubstitute(Search, Replace);
402     return ManglingSubstitutor::parseType();
403   }
404 };
405 
406 class CtorDtorSubstitutor : public ManglingSubstitutor<CtorDtorSubstitutor> {
407 public:
408   llvm::itanium_demangle::Node *
409   parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *State) {
410     trySubstitute("C1", "C2");
411     trySubstitute("D1", "D2");
412     return ManglingSubstitutor::parseCtorDtorName(SoFar, State);
413   }
414 };
415 } // namespace
416 
417 std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings(
418     const ConstString mangled_name) const {
419   std::vector<ConstString> alternates;
420 
421   /// Get a basic set of alternative manglings for the given symbol `name`, by
422   /// making a few basic possible substitutions on basic types, storage duration
423   /// and `const`ness for the given symbol. The output parameter `alternates`
424   /// is filled with a best-guess, non-exhaustive set of different manglings
425   /// for the given name.
426 
427   // Maybe we're looking for a const symbol but the debug info told us it was
428   // non-const...
429   if (!strncmp(mangled_name.GetCString(), "_ZN", 3) &&
430       strncmp(mangled_name.GetCString(), "_ZNK", 4)) {
431     std::string fixed_scratch("_ZNK");
432     fixed_scratch.append(mangled_name.GetCString() + 3);
433     alternates.push_back(ConstString(fixed_scratch));
434   }
435 
436   // Maybe we're looking for a static symbol but we thought it was global...
437   if (!strncmp(mangled_name.GetCString(), "_Z", 2) &&
438       strncmp(mangled_name.GetCString(), "_ZL", 3)) {
439     std::string fixed_scratch("_ZL");
440     fixed_scratch.append(mangled_name.GetCString() + 2);
441     alternates.push_back(ConstString(fixed_scratch));
442   }
443 
444   TypeSubstitutor TS;
445   // `char` is implementation defined as either `signed` or `unsigned`.  As a
446   // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed
447   // char, 'h'-unsigned char.  If we're looking for symbols with a signed char
448   // parameter, try finding matches which have the general case 'c'.
449   if (ConstString char_fixup =
450           TS.substitute(mangled_name.GetStringRef(), "a", "c"))
451     alternates.push_back(char_fixup);
452 
453   // long long parameter mangling 'x', may actually just be a long 'l' argument
454   if (ConstString long_fixup =
455           TS.substitute(mangled_name.GetStringRef(), "x", "l"))
456     alternates.push_back(long_fixup);
457 
458   // unsigned long long parameter mangling 'y', may actually just be unsigned
459   // long 'm' argument
460   if (ConstString ulong_fixup =
461           TS.substitute(mangled_name.GetStringRef(), "y", "m"))
462     alternates.push_back(ulong_fixup);
463 
464   if (ConstString ctor_fixup =
465           CtorDtorSubstitutor().substitute(mangled_name.GetStringRef()))
466     alternates.push_back(ctor_fixup);
467 
468   return alternates;
469 }
470 
471 ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
472     const Mangled mangled, const SymbolContext &sym_ctx) const {
473   ConstString demangled = mangled.GetDemangledName();
474   if (!demangled)
475     return ConstString();
476 
477   CPlusPlusLanguage::MethodName cpp_name(demangled);
478   std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
479 
480   if (!scope_qualified_name.size())
481     return ConstString();
482 
483   if (!sym_ctx.module_sp)
484     return ConstString();
485 
486   lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile();
487   if (!sym_file)
488     return ConstString();
489 
490   std::vector<ConstString> alternates;
491   sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
492 
493   std::vector<ConstString> param_and_qual_matches;
494   std::vector<ConstString> param_matches;
495   for (size_t i = 0; i < alternates.size(); i++) {
496     ConstString alternate_mangled_name = alternates[i];
497     Mangled mangled(alternate_mangled_name);
498     ConstString demangled = mangled.GetDemangledName();
499 
500     CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
501     if (!cpp_name.IsValid())
502       continue;
503 
504     if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
505       if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
506         param_and_qual_matches.push_back(alternate_mangled_name);
507       else
508         param_matches.push_back(alternate_mangled_name);
509     }
510   }
511 
512   if (param_and_qual_matches.size())
513     return param_and_qual_matches[0]; // It is assumed that there will be only
514                                       // one!
515   else if (param_matches.size())
516     return param_matches[0]; // Return one of them as a best match
517   else
518     return ConstString();
519 }
520 
521 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
522   if (!cpp_category_sp)
523     return;
524 
525   TypeSummaryImpl::Flags stl_summary_flags;
526   stl_summary_flags.SetCascades(true)
527       .SetSkipPointers(false)
528       .SetSkipReferences(false)
529       .SetDontShowChildren(true)
530       .SetDontShowValue(true)
531       .SetShowMembersOneLiner(false)
532       .SetHideItemNames(false);
533 
534   AddCXXSummary(cpp_category_sp,
535                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
536                 "std::string summary provider",
537                 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags,
538                 true);
539   AddCXXSummary(cpp_category_sp,
540                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
541                 "std::string summary provider",
542                 ConstString("^std::__[[:alnum:]]+::basic_string<char, "
543                             "std::__[[:alnum:]]+::char_traits<char>, "
544                             "std::__[[:alnum:]]+::allocator<char> >$"),
545                 stl_summary_flags, true);
546   AddCXXSummary(cpp_category_sp,
547                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
548                 "std::string summary provider",
549                 ConstString("^std::__[[:alnum:]]+::basic_string<unsigned char, "
550                             "std::__[[:alnum:]]+::char_traits<unsigned char>, "
551                             "std::__[[:alnum:]]+::allocator<unsigned char> >$"),
552                 stl_summary_flags, true);
553 
554   AddCXXSummary(cpp_category_sp,
555                 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
556                 "std::u16string summary provider",
557                 ConstString("^std::__[[:alnum:]]+::basic_string<char16_t, "
558                             "std::__[[:alnum:]]+::char_traits<char16_t>, "
559                             "std::__[[:alnum:]]+::allocator<char16_t> >$"),
560                 stl_summary_flags, true);
561 
562   AddCXXSummary(cpp_category_sp,
563                 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
564                 "std::u32string summary provider",
565                 ConstString("^std::__[[:alnum:]]+::basic_string<char32_t, "
566                             "std::__[[:alnum:]]+::char_traits<char32_t>, "
567                             "std::__[[:alnum:]]+::allocator<char32_t> >$"),
568                 stl_summary_flags, true);
569 
570   AddCXXSummary(
571       cpp_category_sp, lldb_private::formatters::LibcxxWStringSummaryProvider,
572       "std::wstring summary provider",
573       ConstString("^std::__[[:alnum:]]+::wstring$"), stl_summary_flags, true);
574   AddCXXSummary(cpp_category_sp,
575                 lldb_private::formatters::LibcxxWStringSummaryProvider,
576                 "std::wstring summary provider",
577                 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, "
578                             "std::__[[:alnum:]]+::char_traits<wchar_t>, "
579                             "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
580                 stl_summary_flags, true);
581 
582   AddCXXSummary(cpp_category_sp,
583                 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
584                 "std::string_view summary provider",
585                 ConstString("^std::__[[:alnum:]]+::string_view$"),
586                 stl_summary_flags, true);
587   AddCXXSummary(cpp_category_sp,
588                 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
589                 "std::string_view summary provider",
590                 ConstString("^std::__[[:alnum:]]+::basic_string_view<char, "
591                             "std::__[[:alnum:]]+::char_traits<char> >$"),
592                 stl_summary_flags, true);
593   AddCXXSummary(
594       cpp_category_sp,
595       lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
596       "std::string_view summary provider",
597       ConstString("^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
598                   "std::__[[:alnum:]]+::char_traits<unsigned char> >$"),
599       stl_summary_flags, true);
600 
601   AddCXXSummary(cpp_category_sp,
602                 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF16,
603                 "std::u16string_view summary provider",
604                 ConstString("^std::__[[:alnum:]]+::basic_string_view<char16_t, "
605                             "std::__[[:alnum:]]+::char_traits<char16_t> >$"),
606                 stl_summary_flags, true);
607 
608   AddCXXSummary(cpp_category_sp,
609                 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF32,
610                 "std::u32string_view summary provider",
611                 ConstString("^std::__[[:alnum:]]+::basic_string_view<char32_t, "
612                             "std::__[[:alnum:]]+::char_traits<char32_t> >$"),
613                 stl_summary_flags, true);
614 
615   AddCXXSummary(cpp_category_sp,
616                 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
617                 "std::wstring_view summary provider",
618                 ConstString("^std::__[[:alnum:]]+::wstring_view$"),
619                 stl_summary_flags, true);
620   AddCXXSummary(cpp_category_sp,
621                 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
622                 "std::wstring_view summary provider",
623                 ConstString("^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
624                             "std::__[[:alnum:]]+::char_traits<wchar_t> >$"),
625                 stl_summary_flags, true);
626 
627   SyntheticChildren::Flags stl_synth_flags;
628   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
629       false);
630   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
631   stl_deref_flags.SetFrontEndWantsDereference();
632 
633   AddCXXSynthetic(
634       cpp_category_sp,
635       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
636       "libc++ std::bitset synthetic children",
637       ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
638       true);
639   AddCXXSynthetic(
640       cpp_category_sp,
641       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
642       "libc++ std::vector synthetic children",
643       ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
644       true);
645   AddCXXSynthetic(
646       cpp_category_sp,
647       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
648       "libc++ std::forward_list synthetic children",
649       ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
650       stl_synth_flags, true);
651   AddCXXSynthetic(
652       cpp_category_sp,
653       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
654       "libc++ std::list synthetic children",
655       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
656       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
657       ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
658                   "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
659       stl_deref_flags, true);
660   AddCXXSynthetic(
661       cpp_category_sp,
662       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
663       "libc++ std::map synthetic children",
664       ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
665       true);
666   AddCXXSynthetic(
667       cpp_category_sp,
668       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
669       "libc++ std::set synthetic children",
670       ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
671       true);
672   AddCXXSynthetic(
673       cpp_category_sp,
674       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
675       "libc++ std::multiset synthetic children",
676       ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
677       stl_deref_flags, true);
678   AddCXXSynthetic(
679       cpp_category_sp,
680       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
681       "libc++ std::multimap synthetic children",
682       ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
683       stl_synth_flags, true);
684   AddCXXSynthetic(
685       cpp_category_sp,
686       lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
687       "libc++ std::unordered containers synthetic children",
688       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
689       stl_synth_flags, true);
690   AddCXXSynthetic(
691       cpp_category_sp,
692       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
693       "libc++ std::initializer_list synthetic children",
694       ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
695       true);
696   AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
697                   "libc++ std::queue synthetic children",
698                   ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
699                   stl_synth_flags, true);
700   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
701                   "libc++ std::tuple synthetic children",
702                   ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
703                   stl_synth_flags, true);
704   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalSyntheticFrontEndCreator,
705                   "libc++ std::optional synthetic children",
706                   ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
707                   stl_synth_flags, true);
708   AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
709                   "libc++ std::variant synthetic children",
710                   ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
711                   stl_synth_flags, true);
712   AddCXXSynthetic(
713       cpp_category_sp,
714       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
715       "libc++ std::atomic synthetic children",
716       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
717 
718   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
719       RegularExpression("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$"),
720       SyntheticChildrenSP(new ScriptedSyntheticChildren(
721           stl_synth_flags,
722           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
723 
724   AddCXXSynthetic(
725       cpp_category_sp,
726       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
727       "shared_ptr synthetic children",
728       ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
729       stl_synth_flags, true);
730 
731   ConstString libcxx_std_unique_ptr_regex(
732       "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$");
733   AddCXXSynthetic(
734       cpp_category_sp,
735       lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEndCreator,
736       "unique_ptr synthetic children", libcxx_std_unique_ptr_regex,
737       stl_synth_flags, true);
738 
739   AddCXXSynthetic(
740       cpp_category_sp,
741       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
742       "weak_ptr synthetic children",
743       ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
744       stl_synth_flags, true);
745   AddCXXSummary(cpp_category_sp,
746                 lldb_private::formatters::LibcxxFunctionSummaryProvider,
747                 "libc++ std::function summary provider",
748                 ConstString("^std::__[[:alnum:]]+::function<.+>$"),
749                 stl_summary_flags, true);
750 
751   stl_summary_flags.SetDontShowChildren(false);
752   stl_summary_flags.SetSkipPointers(false);
753   AddCXXSummary(cpp_category_sp,
754                 lldb_private::formatters::LibcxxContainerSummaryProvider,
755                 "libc++ std::bitset summary provider",
756                 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
757                 stl_summary_flags, true);
758   AddCXXSummary(cpp_category_sp,
759                 lldb_private::formatters::LibcxxContainerSummaryProvider,
760                 "libc++ std::vector summary provider",
761                 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
762                 stl_summary_flags, true);
763   AddCXXSummary(cpp_category_sp,
764                 lldb_private::formatters::LibcxxContainerSummaryProvider,
765                 "libc++ std::list summary provider",
766                 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
767                 stl_summary_flags, true);
768   AddCXXSummary(
769       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
770       "libc++ std::list summary provider",
771       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
772       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
773       ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
774                   "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
775       stl_summary_flags, true);
776   AddCXXSummary(cpp_category_sp,
777                 lldb_private::formatters::LibcxxContainerSummaryProvider,
778                 "libc++ std::map summary provider",
779                 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
780                 stl_summary_flags, true);
781   AddCXXSummary(cpp_category_sp,
782                 lldb_private::formatters::LibcxxContainerSummaryProvider,
783                 "libc++ std::deque summary provider",
784                 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
785                 stl_summary_flags, true);
786   AddCXXSummary(cpp_category_sp,
787                 lldb_private::formatters::LibcxxContainerSummaryProvider,
788                 "libc++ std::queue summary provider",
789                 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
790                 stl_summary_flags, true);
791   AddCXXSummary(cpp_category_sp,
792                 lldb_private::formatters::LibcxxContainerSummaryProvider,
793                 "libc++ std::set summary provider",
794                 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
795                 stl_summary_flags, true);
796   AddCXXSummary(cpp_category_sp,
797                 lldb_private::formatters::LibcxxContainerSummaryProvider,
798                 "libc++ std::multiset summary provider",
799                 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
800                 stl_summary_flags, true);
801   AddCXXSummary(cpp_category_sp,
802                 lldb_private::formatters::LibcxxContainerSummaryProvider,
803                 "libc++ std::multimap summary provider",
804                 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
805                 stl_summary_flags, true);
806   AddCXXSummary(
807       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
808       "libc++ std::unordered containers summary provider",
809       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
810       stl_summary_flags, true);
811   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
812                 "libc++ std::tuple summary provider",
813                 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
814                 stl_summary_flags, true);
815   AddCXXSummary(cpp_category_sp,
816                 lldb_private::formatters::LibCxxAtomicSummaryProvider,
817                 "libc++ std::atomic summary provider",
818                 ConstString("^std::__[[:alnum:]]+::atomic<.+>$"),
819                 stl_summary_flags, true);
820   AddCXXSummary(cpp_category_sp,
821                 lldb_private::formatters::GenericOptionalSummaryProvider,
822                 "libc++ std::optional summary provider",
823                 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
824                 stl_summary_flags, true);
825   AddCXXSummary(cpp_category_sp,
826                 lldb_private::formatters::LibcxxVariantSummaryProvider,
827                 "libc++ std::variant summary provider",
828                 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
829                 stl_summary_flags, true);
830 
831   stl_summary_flags.SetSkipPointers(true);
832 
833   AddCXXSummary(cpp_category_sp,
834                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
835                 "libc++ std::shared_ptr summary provider",
836                 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
837                 stl_summary_flags, true);
838   AddCXXSummary(cpp_category_sp,
839                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
840                 "libc++ std::weak_ptr summary provider",
841                 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
842                 stl_summary_flags, true);
843   AddCXXSummary(cpp_category_sp,
844                 lldb_private::formatters::LibcxxUniquePointerSummaryProvider,
845                 "libc++ std::unique_ptr summary provider",
846                 libcxx_std_unique_ptr_regex, stl_summary_flags, true);
847 
848   AddCXXSynthetic(
849       cpp_category_sp,
850       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
851       "std::vector iterator synthetic children",
852       ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
853       true);
854 
855   AddCXXSynthetic(
856       cpp_category_sp,
857       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
858       "std::map iterator synthetic children",
859       ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
860       true);
861 }
862 
863 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
864   if (!cpp_category_sp)
865     return;
866 
867   TypeSummaryImpl::Flags stl_summary_flags;
868   stl_summary_flags.SetCascades(true)
869       .SetSkipPointers(false)
870       .SetSkipReferences(false)
871       .SetDontShowChildren(true)
872       .SetDontShowValue(true)
873       .SetShowMembersOneLiner(false)
874       .SetHideItemNames(false);
875 
876   lldb::TypeSummaryImplSP std_string_summary_sp(
877       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
878 
879   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
880       stl_summary_flags, LibStdcppStringSummaryProvider,
881       "libstdc++ c++11 std::string summary provider"));
882   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
883       stl_summary_flags, LibStdcppWStringSummaryProvider,
884       "libstdc++ c++11 std::wstring summary provider"));
885 
886   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
887                                                     std_string_summary_sp);
888   cpp_category_sp->GetTypeSummariesContainer()->Add(
889       ConstString("std::basic_string<char>"), std_string_summary_sp);
890   cpp_category_sp->GetTypeSummariesContainer()->Add(
891       ConstString("std::basic_string<char,std::char_traits<char>,std::"
892                   "allocator<char> >"),
893       std_string_summary_sp);
894   cpp_category_sp->GetTypeSummariesContainer()->Add(
895       ConstString("std::basic_string<char, std::char_traits<char>, "
896                   "std::allocator<char> >"),
897       std_string_summary_sp);
898 
899   cpp_category_sp->GetTypeSummariesContainer()->Add(
900       ConstString("std::__cxx11::string"), cxx11_string_summary_sp);
901   cpp_category_sp->GetTypeSummariesContainer()->Add(
902       ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, "
903                   "std::allocator<char> >"),
904       cxx11_string_summary_sp);
905   cpp_category_sp->GetTypeSummariesContainer()->Add(
906       ConstString("std::__cxx11::basic_string<unsigned char, "
907                   "std::char_traits<unsigned char>, "
908                   "std::allocator<unsigned char> >"),
909       cxx11_string_summary_sp);
910 
911   // making sure we force-pick the summary for printing wstring (_M_p is a
912   // wchar_t*)
913   lldb::TypeSummaryImplSP std_wstring_summary_sp(
914       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
915 
916   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
917                                                     std_wstring_summary_sp);
918   cpp_category_sp->GetTypeSummariesContainer()->Add(
919       ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp);
920   cpp_category_sp->GetTypeSummariesContainer()->Add(
921       ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
922                   "allocator<wchar_t> >"),
923       std_wstring_summary_sp);
924   cpp_category_sp->GetTypeSummariesContainer()->Add(
925       ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, "
926                   "std::allocator<wchar_t> >"),
927       std_wstring_summary_sp);
928 
929   cpp_category_sp->GetTypeSummariesContainer()->Add(
930       ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp);
931   cpp_category_sp->GetTypeSummariesContainer()->Add(
932       ConstString("std::__cxx11::basic_string<wchar_t, "
933                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
934       cxx11_wstring_summary_sp);
935 
936   SyntheticChildren::Flags stl_synth_flags;
937   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
938       false);
939   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
940   stl_deref_flags.SetFrontEndWantsDereference();
941 
942   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
943       RegularExpression("^std::vector<.+>(( )?&)?$"),
944       SyntheticChildrenSP(new ScriptedSyntheticChildren(
945           stl_synth_flags,
946           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
947   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
948       RegularExpression("^std::map<.+> >(( )?&)?$"),
949       SyntheticChildrenSP(new ScriptedSyntheticChildren(
950           stl_synth_flags,
951           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
952   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
953       RegularExpression("^std::deque<.+>(( )?&)?$"),
954       SyntheticChildrenSP(new ScriptedSyntheticChildren(
955           stl_deref_flags,
956           "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider")));
957   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
958       RegularExpression("^std::set<.+> >(( )?&)?$"),
959       SyntheticChildrenSP(new ScriptedSyntheticChildren(
960           stl_deref_flags,
961           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
962   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
963       RegularExpression("^std::multimap<.+> >(( )?&)?$"),
964       SyntheticChildrenSP(new ScriptedSyntheticChildren(
965           stl_deref_flags,
966           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
967   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
968       RegularExpression("^std::multiset<.+> >(( )?&)?$"),
969       SyntheticChildrenSP(new ScriptedSyntheticChildren(
970           stl_deref_flags,
971           "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
972   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
973       RegularExpression("^std::unordered_(multi)?(map|set)<.+> >$"),
974       SyntheticChildrenSP(new ScriptedSyntheticChildren(
975           stl_deref_flags,
976           "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider")));
977   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
978       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
979       SyntheticChildrenSP(new ScriptedSyntheticChildren(
980           stl_deref_flags,
981           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
982   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
983       RegularExpression("^std::(__cxx11::)?forward_list<.+>(( )?&)?$"),
984       SyntheticChildrenSP(new ScriptedSyntheticChildren(
985           stl_synth_flags,
986           "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider")));
987 
988   stl_summary_flags.SetDontShowChildren(false);
989   stl_summary_flags.SetSkipPointers(false);
990   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
991       RegularExpression("^std::bitset<.+>(( )?&)?$"),
992       TypeSummaryImplSP(
993           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
994   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
995       RegularExpression("^std::vector<.+>(( )?&)?$"),
996       TypeSummaryImplSP(
997           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
998   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
999       RegularExpression("^std::map<.+> >(( )?&)?$"),
1000       TypeSummaryImplSP(
1001           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1002   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1003       RegularExpression("^std::set<.+> >(( )?&)?$"),
1004       TypeSummaryImplSP(
1005           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1006   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1007       RegularExpression("^std::deque<.+>(( )?&)?$"),
1008       TypeSummaryImplSP(
1009           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1010   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1011       RegularExpression("^std::multimap<.+> >(( )?&)?$"),
1012       TypeSummaryImplSP(
1013           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1014   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1015       RegularExpression("^std::multiset<.+> >(( )?&)?$"),
1016       TypeSummaryImplSP(
1017           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1018   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1019       RegularExpression("^std::unordered_(multi)?(map|set)<.+> >$"),
1020       TypeSummaryImplSP(
1021           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1022   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1023       RegularExpression("^std::(__cxx11::)?list<.+>(( )?&)?$"),
1024       TypeSummaryImplSP(
1025           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
1026   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
1027       RegularExpression("^std::(__cxx11::)?forward_list<.+>(( )?&)?$"),
1028       TypeSummaryImplSP(
1029           new ScriptSummaryFormat(stl_summary_flags, "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
1030 
1031   AddCXXSynthetic(
1032       cpp_category_sp,
1033       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
1034       "std::vector iterator synthetic children",
1035       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
1036 
1037   AddCXXSynthetic(
1038       cpp_category_sp,
1039       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
1040       "std::map iterator synthetic children",
1041       ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
1042 
1043   AddCXXSynthetic(
1044       cpp_category_sp,
1045       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
1046       "std::unique_ptr synthetic children",
1047       ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
1048   AddCXXSynthetic(
1049       cpp_category_sp,
1050       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
1051       "std::shared_ptr synthetic children",
1052       ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
1053   AddCXXSynthetic(
1054       cpp_category_sp,
1055       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
1056       "std::weak_ptr synthetic children",
1057       ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
1058   AddCXXSynthetic(
1059       cpp_category_sp,
1060       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
1061       "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
1062       stl_synth_flags, true);
1063 
1064   AddCXXSynthetic(
1065       cpp_category_sp,
1066       lldb_private::formatters::LibStdcppBitsetSyntheticFrontEndCreator,
1067       "std::bitset synthetic child", ConstString("^std::bitset<.+>(( )?&)?$"),
1068       stl_deref_flags, true);
1069 
1070   AddCXXSynthetic(
1071       cpp_category_sp,
1072       lldb_private::formatters::LibStdcppOptionalSyntheticFrontEndCreator,
1073       "std::optional synthetic child",
1074       ConstString("^std::optional<.+>(( )?&)?$"), stl_deref_flags, true);
1075 
1076   AddCXXSummary(cpp_category_sp,
1077                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
1078                 "libstdc++ std::unique_ptr summary provider",
1079                 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
1080                 true);
1081   AddCXXSummary(cpp_category_sp,
1082                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
1083                 "libstdc++ std::shared_ptr summary provider",
1084                 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
1085                 true);
1086   AddCXXSummary(cpp_category_sp,
1087                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
1088                 "libstdc++ std::weak_ptr summary provider",
1089                 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
1090                 true);
1091   AddCXXSummary(
1092       cpp_category_sp, lldb_private::formatters::GenericOptionalSummaryProvider,
1093       "libstd++ std::optional summary provider",
1094       ConstString("^std::optional<.+>(( )?&)?$"), stl_summary_flags, true);
1095 }
1096 
1097 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
1098   if (!cpp_category_sp)
1099     return;
1100 
1101   TypeSummaryImpl::Flags string_flags;
1102   string_flags.SetCascades(true)
1103       .SetSkipPointers(true)
1104       .SetSkipReferences(false)
1105       .SetDontShowChildren(true)
1106       .SetDontShowValue(false)
1107       .SetShowMembersOneLiner(false)
1108       .SetHideItemNames(false);
1109 
1110   TypeSummaryImpl::Flags string_array_flags;
1111   string_array_flags.SetCascades(true)
1112       .SetSkipPointers(true)
1113       .SetSkipReferences(false)
1114       .SetDontShowChildren(true)
1115       .SetDontShowValue(true)
1116       .SetShowMembersOneLiner(false)
1117       .SetHideItemNames(false);
1118 
1119   AddCXXSummary(
1120       cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider,
1121       "char8_t * summary provider", ConstString("char8_t *"), string_flags);
1122   AddCXXSummary(cpp_category_sp,
1123                 lldb_private::formatters::Char8StringSummaryProvider,
1124                 "char8_t [] summary provider",
1125                 ConstString("char8_t ?\\[[0-9]+\\]"), string_array_flags, true);
1126 
1127   AddCXXSummary(
1128       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
1129       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
1130   AddCXXSummary(cpp_category_sp,
1131                 lldb_private::formatters::Char16StringSummaryProvider,
1132                 "char16_t [] summary provider",
1133                 ConstString("char16_t ?\\[[0-9]+\\]"), string_array_flags, true);
1134 
1135   AddCXXSummary(
1136       cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
1137       "char32_t * summary provider", ConstString("char32_t *"), string_flags);
1138   AddCXXSummary(cpp_category_sp,
1139                 lldb_private::formatters::Char32StringSummaryProvider,
1140                 "char32_t [] summary provider",
1141                 ConstString("char32_t ?\\[[0-9]+\\]"), string_array_flags, true);
1142 
1143   AddCXXSummary(
1144       cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
1145       "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
1146   AddCXXSummary(cpp_category_sp,
1147                 lldb_private::formatters::WCharStringSummaryProvider,
1148                 "wchar_t * summary provider",
1149                 ConstString("wchar_t ?\\[[0-9]+\\]"), string_array_flags, true);
1150 
1151   AddCXXSummary(
1152       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
1153       "unichar * summary provider", ConstString("unichar *"), string_flags);
1154 
1155   TypeSummaryImpl::Flags widechar_flags;
1156   widechar_flags.SetDontShowValue(true)
1157       .SetSkipPointers(true)
1158       .SetSkipReferences(false)
1159       .SetCascades(true)
1160       .SetDontShowChildren(true)
1161       .SetHideItemNames(true)
1162       .SetShowMembersOneLiner(false);
1163 
1164   AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider,
1165                 "char8_t summary provider", ConstString("char8_t"),
1166                 widechar_flags);
1167   AddCXXSummary(
1168       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
1169       "char16_t summary provider", ConstString("char16_t"), widechar_flags);
1170   AddCXXSummary(
1171       cpp_category_sp, lldb_private::formatters::Char32SummaryProvider,
1172       "char32_t summary provider", ConstString("char32_t"), widechar_flags);
1173   AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
1174                 "wchar_t summary provider", ConstString("wchar_t"),
1175                 widechar_flags);
1176 
1177   AddCXXSummary(
1178       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
1179       "unichar summary provider", ConstString("unichar"), widechar_flags);
1180 }
1181 
1182 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
1183   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
1184   public:
1185     CompilerType AdjustForInclusion(CompilerType &candidate) override {
1186       LanguageType lang_type(candidate.GetMinimumLanguage());
1187       if (!Language::LanguageIsC(lang_type) &&
1188           !Language::LanguageIsCPlusPlus(lang_type))
1189         return CompilerType();
1190       if (candidate.IsTypedefType())
1191         return candidate.GetTypedefedType();
1192       return candidate;
1193     }
1194   };
1195 
1196   return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
1197 }
1198 
1199 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
1200   static llvm::once_flag g_initialize;
1201   static TypeCategoryImplSP g_category;
1202 
1203   llvm::call_once(g_initialize, [this]() -> void {
1204     DataVisualization::Categories::GetCategory(ConstString(GetPluginName()),
1205                                                g_category);
1206     if (g_category) {
1207       LoadLibStdcppFormatters(g_category);
1208       LoadLibCxxFormatters(g_category);
1209       LoadSystemFormatters(g_category);
1210     }
1211   });
1212   return g_category;
1213 }
1214 
1215 HardcodedFormatters::HardcodedSummaryFinder
1216 CPlusPlusLanguage::GetHardcodedSummaries() {
1217   static llvm::once_flag g_initialize;
1218   static ConstString g_vectortypes("VectorTypes");
1219   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
1220 
1221   llvm::call_once(g_initialize, []() -> void {
1222     g_formatters.push_back(
1223         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1224            FormatManager &) -> TypeSummaryImpl::SharedPointer {
1225           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1226               new CXXFunctionSummaryFormat(
1227                   TypeSummaryImpl::Flags(),
1228                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
1229                   "Function pointer summary provider"));
1230           if (valobj.GetCompilerType().IsFunctionPointerType()) {
1231             return formatter_sp;
1232           }
1233           return nullptr;
1234         });
1235     g_formatters.push_back(
1236         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1237            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1238           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1239               new CXXFunctionSummaryFormat(
1240                   TypeSummaryImpl::Flags()
1241                       .SetCascades(true)
1242                       .SetDontShowChildren(true)
1243                       .SetHideItemNames(true)
1244                       .SetShowMembersOneLiner(true)
1245                       .SetSkipPointers(true)
1246                       .SetSkipReferences(false),
1247                   lldb_private::formatters::VectorTypeSummaryProvider,
1248                   "vector_type pointer summary provider"));
1249           if (valobj.GetCompilerType().IsVectorType()) {
1250             if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1251               return formatter_sp;
1252           }
1253           return nullptr;
1254         });
1255     g_formatters.push_back(
1256         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1257            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1258           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1259               new CXXFunctionSummaryFormat(
1260                   TypeSummaryImpl::Flags()
1261                       .SetCascades(true)
1262                       .SetDontShowChildren(true)
1263                       .SetHideItemNames(true)
1264                       .SetShowMembersOneLiner(true)
1265                       .SetSkipPointers(true)
1266                       .SetSkipReferences(false),
1267                   lldb_private::formatters::BlockPointerSummaryProvider,
1268                   "block pointer summary provider"));
1269           if (valobj.GetCompilerType().IsBlockPointerType()) {
1270             return formatter_sp;
1271           }
1272           return nullptr;
1273         });
1274   });
1275 
1276   return g_formatters;
1277 }
1278 
1279 HardcodedFormatters::HardcodedSyntheticFinder
1280 CPlusPlusLanguage::GetHardcodedSynthetics() {
1281   static llvm::once_flag g_initialize;
1282   static ConstString g_vectortypes("VectorTypes");
1283   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
1284 
1285   llvm::call_once(g_initialize, []() -> void {
1286     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1287                               lldb::DynamicValueType, FormatManager &fmt_mgr)
1288                                -> SyntheticChildren::SharedPointer {
1289       static CXXSyntheticChildren::SharedPointer formatter_sp(
1290           new CXXSyntheticChildren(
1291               SyntheticChildren::Flags()
1292                   .SetCascades(true)
1293                   .SetSkipPointers(true)
1294                   .SetSkipReferences(true)
1295                   .SetNonCacheable(true),
1296               "vector_type synthetic children",
1297               lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
1298       if (valobj.GetCompilerType().IsVectorType()) {
1299         if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1300           return formatter_sp;
1301       }
1302       return nullptr;
1303     });
1304     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1305                               lldb::DynamicValueType, FormatManager &fmt_mgr)
1306                                -> SyntheticChildren::SharedPointer {
1307       static CXXSyntheticChildren::SharedPointer formatter_sp(
1308           new CXXSyntheticChildren(
1309               SyntheticChildren::Flags()
1310                   .SetCascades(true)
1311                   .SetSkipPointers(true)
1312                   .SetSkipReferences(true)
1313                   .SetNonCacheable(true),
1314               "block pointer synthetic children",
1315               lldb_private::formatters::BlockPointerSyntheticFrontEndCreator));
1316       if (valobj.GetCompilerType().IsBlockPointerType()) {
1317         return formatter_sp;
1318       }
1319       return nullptr;
1320     });
1321   });
1322 
1323   return g_formatters;
1324 }
1325 
1326 bool CPlusPlusLanguage::IsNilReference(ValueObject &valobj) {
1327   if (!Language::LanguageIsCPlusPlus(valobj.GetObjectRuntimeLanguage()) ||
1328       !valobj.IsPointerType())
1329     return false;
1330   bool canReadValue = true;
1331   bool isZero = valobj.GetValueAsUnsigned(0, &canReadValue) == 0;
1332   return canReadValue && isZero;
1333 }
1334 
1335 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
1336   const auto suffixes = {".cpp", ".cxx", ".c++", ".cc",  ".c",
1337                          ".h",   ".hh",  ".hpp", ".hxx", ".h++"};
1338   for (auto suffix : suffixes) {
1339     if (file_path.endswith_insensitive(suffix))
1340       return true;
1341   }
1342 
1343   // Check if we're in a STL path (where the files usually have no extension
1344   // that we could check for.
1345   return file_path.contains("/usr/include/c++/");
1346 }
1347