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