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