xref: /llvm-project/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp (revision 506144da04b94d7d492ad34f7d3d81e8368677bb) 
1 //===-- CPlusPlusLanguage.cpp -----------------------------------*- C++ -*-===//
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/PluginManager.h"
24 #include "lldb/Core/UniqueCStringMap.h"
25 #include "lldb/DataFormatters/CXXFunctionPointer.h"
26 #include "lldb/DataFormatters/DataVisualization.h"
27 #include "lldb/DataFormatters/FormattersHelpers.h"
28 #include "lldb/DataFormatters/VectorType.h"
29 #include "lldb/Utility/ConstString.h"
30 #include "lldb/Utility/Log.h"
31 #include "lldb/Utility/RegularExpression.h"
32 
33 #include "BlockPointer.h"
34 #include "CPlusPlusNameParser.h"
35 #include "CxxStringTypes.h"
36 #include "LibCxx.h"
37 #include "LibCxxAtomic.h"
38 #include "LibCxxVariant.h"
39 #include "LibStdcpp.h"
40 #include "MSVCUndecoratedNameParser.h"
41 
42 using namespace lldb;
43 using namespace lldb_private;
44 using namespace lldb_private::formatters;
45 
46 void CPlusPlusLanguage::Initialize() {
47   PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
48                                 CreateInstance);
49 }
50 
51 void CPlusPlusLanguage::Terminate() {
52   PluginManager::UnregisterPlugin(CreateInstance);
53 }
54 
55 lldb_private::ConstString CPlusPlusLanguage::GetPluginNameStatic() {
56   static ConstString g_name("cplusplus");
57   return g_name;
58 }
59 
60 // PluginInterface protocol
61 
62 lldb_private::ConstString CPlusPlusLanguage::GetPluginName() {
63   return GetPluginNameStatic();
64 }
65 
66 uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; }
67 
68 // Static Functions
69 
70 Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
71   if (Language::LanguageIsCPlusPlus(language))
72     return new CPlusPlusLanguage();
73   return nullptr;
74 }
75 
76 void CPlusPlusLanguage::MethodName::Clear() {
77   m_full.Clear();
78   m_basename = llvm::StringRef();
79   m_context = llvm::StringRef();
80   m_arguments = llvm::StringRef();
81   m_qualifiers = llvm::StringRef();
82   m_parsed = false;
83   m_parse_error = false;
84 }
85 
86 static bool ReverseFindMatchingChars(const llvm::StringRef &s,
87                                      const llvm::StringRef &left_right_chars,
88                                      size_t &left_pos, size_t &right_pos,
89                                      size_t pos = llvm::StringRef::npos) {
90   assert(left_right_chars.size() == 2);
91   left_pos = llvm::StringRef::npos;
92   const char left_char = left_right_chars[0];
93   const char right_char = left_right_chars[1];
94   pos = s.find_last_of(left_right_chars, pos);
95   if (pos == llvm::StringRef::npos || s[pos] == left_char)
96     return false;
97   right_pos = pos;
98   uint32_t depth = 1;
99   while (pos > 0 && depth > 0) {
100     pos = s.find_last_of(left_right_chars, pos);
101     if (pos == llvm::StringRef::npos)
102       return false;
103     if (s[pos] == left_char) {
104       if (--depth == 0) {
105         left_pos = pos;
106         return left_pos < right_pos;
107       }
108     } else if (s[pos] == right_char) {
109       ++depth;
110     }
111   }
112   return false;
113 }
114 
115 static bool IsTrivialBasename(const llvm::StringRef &basename) {
116   // Check that the basename matches with the following regular expression
117   // "^~?([A-Za-z_][A-Za-z_0-9]*)$" We are using a hand written implementation
118   // because it is significantly more efficient then using the general purpose
119   // regular expression library.
120   size_t idx = 0;
121   if (basename.size() > 0 && basename[0] == '~')
122     idx = 1;
123 
124   if (basename.size() <= idx)
125     return false; // Empty string or "~"
126 
127   if (!std::isalpha(basename[idx]) && basename[idx] != '_')
128     return false; // First charater (after removing the possible '~'') isn't in
129                   // [A-Za-z_]
130 
131   // Read all characters matching [A-Za-z_0-9]
132   ++idx;
133   while (idx < basename.size()) {
134     if (!std::isalnum(basename[idx]) && basename[idx] != '_')
135       break;
136     ++idx;
137   }
138 
139   // We processed all characters. It is a vaild basename.
140   return idx == basename.size();
141 }
142 
143 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
144   // This method tries to parse simple method definitions which are presumably
145   // most comman in user programs. Definitions that can be parsed by this
146   // function don't have return types and templates in the name.
147   // A::B::C::fun(std::vector<T> &) const
148   size_t arg_start, arg_end;
149   llvm::StringRef full(m_full.GetCString());
150   llvm::StringRef parens("()", 2);
151   if (ReverseFindMatchingChars(full, parens, arg_start, arg_end)) {
152     m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
153     if (arg_end + 1 < full.size())
154       m_qualifiers = full.substr(arg_end + 1).ltrim();
155 
156     if (arg_start == 0)
157       return false;
158     size_t basename_end = arg_start;
159     size_t context_start = 0;
160     size_t context_end = full.rfind(':', basename_end);
161     if (context_end == llvm::StringRef::npos)
162       m_basename = full.substr(0, basename_end);
163     else {
164       if (context_start < context_end)
165         m_context = full.substr(context_start, context_end - 1 - context_start);
166       const size_t basename_begin = context_end + 1;
167       m_basename = full.substr(basename_begin, basename_end - basename_begin);
168     }
169 
170     if (IsTrivialBasename(m_basename)) {
171       return true;
172     } else {
173       // The C++ basename doesn't match our regular expressions so this can't
174       // be a valid C++ method, clear everything out and indicate an error
175       m_context = llvm::StringRef();
176       m_basename = llvm::StringRef();
177       m_arguments = llvm::StringRef();
178       m_qualifiers = llvm::StringRef();
179       return false;
180     }
181   }
182   return false;
183 }
184 
185 void CPlusPlusLanguage::MethodName::Parse() {
186   if (!m_parsed && m_full) {
187     if (TrySimplifiedParse()) {
188       m_parse_error = false;
189     } else {
190       CPlusPlusNameParser parser(m_full.GetStringRef());
191       if (auto function = parser.ParseAsFunctionDefinition()) {
192         m_basename = function.getValue().name.basename;
193         m_context = function.getValue().name.context;
194         m_arguments = function.getValue().arguments;
195         m_qualifiers = function.getValue().qualifiers;
196         m_parse_error = false;
197       } else {
198         m_parse_error = true;
199       }
200     }
201     m_parsed = true;
202   }
203 }
204 
205 llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() {
206   if (!m_parsed)
207     Parse();
208   return m_basename;
209 }
210 
211 llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() {
212   if (!m_parsed)
213     Parse();
214   return m_context;
215 }
216 
217 llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() {
218   if (!m_parsed)
219     Parse();
220   return m_arguments;
221 }
222 
223 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
224   if (!m_parsed)
225     Parse();
226   return m_qualifiers;
227 }
228 
229 std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
230   if (!m_parsed)
231     Parse();
232   if (m_context.empty())
233     return m_basename;
234 
235   std::string res;
236   res += m_context;
237   res += "::";
238   res += m_basename;
239   return res;
240 }
241 
242 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
243   // FIXME!! we should really run through all the known C++ Language plugins
244   // and ask each one if this is a C++ mangled name
245 
246   Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
247 
248   if (scheme == Mangled::eManglingSchemeNone)
249     return false;
250 
251   return true;
252 }
253 
254 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
255     const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
256   if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
257     return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context,
258                                                                   identifier);
259 
260   CPlusPlusNameParser parser(name);
261   if (auto full_name = parser.ParseAsFullName()) {
262     identifier = full_name.getValue().basename;
263     context = full_name.getValue().context;
264     return true;
265   }
266   return false;
267 }
268 
269 namespace {
270 class NodeAllocator {
271   llvm::BumpPtrAllocator Alloc;
272 
273 public:
274   void reset() { Alloc.Reset(); }
275 
276   template <typename T, typename... Args> T *makeNode(Args &&... args) {
277     return new (Alloc.Allocate(sizeof(T), alignof(T)))
278         T(std::forward<Args>(args)...);
279   }
280 
281   void *allocateNodeArray(size_t sz) {
282     return Alloc.Allocate(sizeof(llvm::itanium_demangle::Node *) * sz,
283                           alignof(llvm::itanium_demangle::Node *));
284   }
285 };
286 
287 /// Given a mangled function `Mangled`, replace all the primitive function type
288 /// arguments of `Search` with type `Replace`.
289 class TypeSubstitutor
290     : public llvm::itanium_demangle::AbstractManglingParser<TypeSubstitutor,
291                                                             NodeAllocator> {
292   /// Input character until which we have constructed the respective output
293   /// already
294   const char *Written;
295 
296   llvm::StringRef Search;
297   llvm::StringRef Replace;
298   llvm::SmallString<128> Result;
299 
300   /// Whether we have performed any substitutions.
301   bool Substituted;
302 
303   void reset(llvm::StringRef Mangled, llvm::StringRef Search,
304              llvm::StringRef Replace) {
305     AbstractManglingParser::reset(Mangled.begin(), Mangled.end());
306     Written = Mangled.begin();
307     this->Search = Search;
308     this->Replace = Replace;
309     Result.clear();
310     Substituted = false;
311   }
312 
313   void appendUnchangedInput() {
314     Result += llvm::StringRef(Written, First - Written);
315     Written = First;
316   }
317 
318 public:
319   TypeSubstitutor() : AbstractManglingParser(nullptr, nullptr) {}
320 
321   ConstString substitute(llvm::StringRef Mangled, llvm::StringRef From,
322                          llvm::StringRef To) {
323     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
324 
325     reset(Mangled, From, To);
326     if (parse() == nullptr) {
327       LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled);
328       return ConstString();
329     }
330     if (!Substituted)
331       return ConstString();
332 
333     // Append any trailing unmodified input.
334     appendUnchangedInput();
335     LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result);
336     return ConstString(Result);
337   }
338 
339   llvm::itanium_demangle::Node *parseType() {
340     if (llvm::StringRef(First, numLeft()).startswith(Search)) {
341       // We found a match. Append unmodified input up to this point.
342       appendUnchangedInput();
343 
344       // And then perform the replacement.
345       Result += Replace;
346       Written += Search.size();
347       Substituted = true;
348     }
349     return AbstractManglingParser::parseType();
350   }
351 };
352 }
353 
354 uint32_t CPlusPlusLanguage::FindAlternateFunctionManglings(
355     const ConstString mangled_name, std::set<ConstString> &alternates) {
356   const auto start_size = alternates.size();
357   /// Get a basic set of alternative manglings for the given symbol `name`, by
358   /// making a few basic possible substitutions on basic types, storage duration
359   /// and `const`ness for the given symbol. The output parameter `alternates`
360   /// is filled with a best-guess, non-exhaustive set of different manglings
361   /// for the given name.
362 
363   // Maybe we're looking for a const symbol but the debug info told us it was
364   // non-const...
365   if (!strncmp(mangled_name.GetCString(), "_ZN", 3) &&
366       strncmp(mangled_name.GetCString(), "_ZNK", 4)) {
367     std::string fixed_scratch("_ZNK");
368     fixed_scratch.append(mangled_name.GetCString() + 3);
369     alternates.insert(ConstString(fixed_scratch));
370   }
371 
372   // Maybe we're looking for a static symbol but we thought it was global...
373   if (!strncmp(mangled_name.GetCString(), "_Z", 2) &&
374       strncmp(mangled_name.GetCString(), "_ZL", 3)) {
375     std::string fixed_scratch("_ZL");
376     fixed_scratch.append(mangled_name.GetCString() + 2);
377     alternates.insert(ConstString(fixed_scratch));
378   }
379 
380   TypeSubstitutor TS;
381   // `char` is implementation defined as either `signed` or `unsigned`.  As a
382   // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed
383   // char, 'h'-unsigned char.  If we're looking for symbols with a signed char
384   // parameter, try finding matches which have the general case 'c'.
385   if (ConstString char_fixup =
386           TS.substitute(mangled_name.GetStringRef(), "a", "c"))
387     alternates.insert(char_fixup);
388 
389   // long long parameter mangling 'x', may actually just be a long 'l' argument
390   if (ConstString long_fixup =
391           TS.substitute(mangled_name.GetStringRef(), "x", "l"))
392     alternates.insert(long_fixup);
393 
394   // unsigned long long parameter mangling 'y', may actually just be unsigned
395   // long 'm' argument
396   if (ConstString ulong_fixup =
397           TS.substitute(mangled_name.GetStringRef(), "y", "m"))
398     alternates.insert(ulong_fixup);
399 
400   return alternates.size() - start_size;
401 }
402 
403 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
404   if (!cpp_category_sp)
405     return;
406 
407   TypeSummaryImpl::Flags stl_summary_flags;
408   stl_summary_flags.SetCascades(true)
409       .SetSkipPointers(false)
410       .SetSkipReferences(false)
411       .SetDontShowChildren(true)
412       .SetDontShowValue(true)
413       .SetShowMembersOneLiner(false)
414       .SetHideItemNames(false);
415 
416   AddCXXSummary(cpp_category_sp,
417                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
418                 "std::string summary provider",
419                 ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags,
420                 true);
421   AddCXXSummary(cpp_category_sp,
422                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
423                 "std::string summary provider",
424                 ConstString("^std::__[[:alnum:]]+::basic_string<char, "
425                             "std::__[[:alnum:]]+::char_traits<char>, "
426                             "std::__[[:alnum:]]+::allocator<char> >$"),
427                 stl_summary_flags, true);
428   AddCXXSummary(cpp_category_sp,
429                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
430                 "std::string summary provider",
431                 ConstString("^std::__[[:alnum:]]+::basic_string<unsigned char, "
432                             "std::__[[:alnum:]]+::char_traits<unsigned char>, "
433                             "std::__[[:alnum:]]+::allocator<unsigned char> >$"),
434                 stl_summary_flags, true);
435 
436   AddCXXSummary(cpp_category_sp,
437                 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
438                 "std::u16string summary provider",
439                 ConstString(
440                     "^std::__[[:alnum:]]+::basic_string<char16_t, "
441                     "std::__[[:alnum:]]+::char_traits<char16_t>, "
442                     "std::__[[:alnum:]]+::allocator<char16_t> >$"),
443                 stl_summary_flags, true);
444 
445   AddCXXSummary(cpp_category_sp,
446                 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
447                 "std::u32string summary provider",
448                 ConstString(
449                     "^std::__[[:alnum:]]+::basic_string<char32_t, "
450                     "std::__[[:alnum:]]+::char_traits<char32_t>, "
451                     "std::__[[:alnum:]]+::allocator<char32_t> >$"),
452                 stl_summary_flags, true);
453 
454   AddCXXSummary(cpp_category_sp,
455                 lldb_private::formatters::LibcxxWStringSummaryProvider,
456                 "std::wstring summary provider",
457                 ConstString("^std::__[[:alnum:]]+::wstring$"),
458                 stl_summary_flags, true);
459   AddCXXSummary(cpp_category_sp,
460                 lldb_private::formatters::LibcxxWStringSummaryProvider,
461                 "std::wstring summary provider",
462                 ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, "
463                             "std::__[[:alnum:]]+::char_traits<wchar_t>, "
464                             "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
465                 stl_summary_flags, true);
466 
467   SyntheticChildren::Flags stl_synth_flags;
468   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
469       false);
470   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
471   stl_deref_flags.SetFrontEndWantsDereference();
472 
473   AddCXXSynthetic(
474       cpp_category_sp,
475       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
476       "libc++ std::bitset synthetic children",
477       ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
478       true);
479   AddCXXSynthetic(
480       cpp_category_sp,
481       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
482       "libc++ std::vector synthetic children",
483       ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
484       true);
485   AddCXXSynthetic(
486       cpp_category_sp,
487       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
488       "libc++ std::forward_list synthetic children",
489       ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
490       stl_synth_flags, true);
491   AddCXXSynthetic(
492       cpp_category_sp,
493       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
494       "libc++ std::list synthetic children",
495       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
496       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
497       ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
498                   "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
499       stl_deref_flags, true);
500   AddCXXSynthetic(
501       cpp_category_sp,
502       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
503       "libc++ std::map synthetic children",
504       ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
505       true);
506   AddCXXSynthetic(
507       cpp_category_sp,
508       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
509       "libc++ std::set synthetic children",
510       ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
511       true);
512   AddCXXSynthetic(
513       cpp_category_sp,
514       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
515       "libc++ std::multiset synthetic children",
516       ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
517       stl_deref_flags, true);
518   AddCXXSynthetic(
519       cpp_category_sp,
520       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
521       "libc++ std::multimap synthetic children",
522       ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
523       stl_synth_flags, true);
524   AddCXXSynthetic(
525       cpp_category_sp,
526       lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
527       "libc++ std::unordered containers synthetic children",
528       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
529       stl_synth_flags, true);
530   AddCXXSynthetic(
531       cpp_category_sp,
532       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
533       "libc++ std::initializer_list synthetic children",
534       ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
535       true);
536   AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
537                   "libc++ std::queue synthetic children",
538                   ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
539                   stl_synth_flags, true);
540   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
541                   "libc++ std::tuple synthetic children",
542                   ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
543                   stl_synth_flags, true);
544   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalFrontEndCreator,
545                   "libc++ std::optional synthetic children",
546                   ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
547                   stl_synth_flags, true);
548   AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
549                   "libc++ std::variant synthetic children",
550                   ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
551                   stl_synth_flags, true);
552   AddCXXSynthetic(
553       cpp_category_sp,
554       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
555       "libc++ std::atomic synthetic children",
556       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
557 
558   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
559       RegularExpression(
560           llvm::StringRef("^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$")),
561       SyntheticChildrenSP(new ScriptedSyntheticChildren(
562           stl_synth_flags,
563           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
564 
565   AddCXXSynthetic(
566       cpp_category_sp,
567       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
568       "shared_ptr synthetic children",
569       ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
570       stl_synth_flags, true);
571   AddCXXSynthetic(
572       cpp_category_sp,
573       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
574       "weak_ptr synthetic children",
575       ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
576       stl_synth_flags, true);
577   AddCXXSummary(cpp_category_sp,
578                 lldb_private::formatters::LibcxxFunctionSummaryProvider,
579                 "libc++ std::function summary provider",
580                 ConstString("^std::__[[:alnum:]]+::function<.+>$"),
581                 stl_summary_flags, true);
582 
583   stl_summary_flags.SetDontShowChildren(false);
584   stl_summary_flags.SetSkipPointers(false);
585   AddCXXSummary(cpp_category_sp,
586                 lldb_private::formatters::LibcxxContainerSummaryProvider,
587                 "libc++ std::bitset summary provider",
588                 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
589                 stl_summary_flags, true);
590   AddCXXSummary(cpp_category_sp,
591                 lldb_private::formatters::LibcxxContainerSummaryProvider,
592                 "libc++ std::vector summary provider",
593                 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
594                 stl_summary_flags, true);
595   AddCXXSummary(cpp_category_sp,
596                 lldb_private::formatters::LibcxxContainerSummaryProvider,
597                 "libc++ std::list summary provider",
598                 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
599                 stl_summary_flags, true);
600   AddCXXSummary(
601       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
602       "libc++ std::list summary provider",
603       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
604       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
605       ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
606                   "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
607       stl_summary_flags, true);
608   AddCXXSummary(cpp_category_sp,
609                 lldb_private::formatters::LibcxxContainerSummaryProvider,
610                 "libc++ std::map summary provider",
611                 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
612                 stl_summary_flags, true);
613   AddCXXSummary(cpp_category_sp,
614                 lldb_private::formatters::LibcxxContainerSummaryProvider,
615                 "libc++ std::deque summary provider",
616                 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
617                 stl_summary_flags, true);
618   AddCXXSummary(cpp_category_sp,
619                 lldb_private::formatters::LibcxxContainerSummaryProvider,
620                 "libc++ std::queue summary provider",
621                 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
622                 stl_summary_flags, true);
623   AddCXXSummary(cpp_category_sp,
624                 lldb_private::formatters::LibcxxContainerSummaryProvider,
625                 "libc++ std::set summary provider",
626                 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
627                 stl_summary_flags, true);
628   AddCXXSummary(cpp_category_sp,
629                 lldb_private::formatters::LibcxxContainerSummaryProvider,
630                 "libc++ std::multiset summary provider",
631                 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
632                 stl_summary_flags, true);
633   AddCXXSummary(cpp_category_sp,
634                 lldb_private::formatters::LibcxxContainerSummaryProvider,
635                 "libc++ std::multimap summary provider",
636                 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
637                 stl_summary_flags, true);
638   AddCXXSummary(
639       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
640       "libc++ std::unordered containers summary provider",
641       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
642       stl_summary_flags, true);
643   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
644                 "libc++ std::tuple summary provider",
645                 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
646                 stl_summary_flags, true);
647   AddCXXSummary(
648       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
649       "libc++ std::atomic summary provider",
650       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags,
651       true);
652   AddCXXSummary(cpp_category_sp,
653                 lldb_private::formatters::LibcxxOptionalSummaryProvider,
654                 "libc++ std::optional summary provider",
655                 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
656                 stl_summary_flags, true);
657   AddCXXSummary(cpp_category_sp,
658                 lldb_private::formatters::LibcxxVariantSummaryProvider,
659                 "libc++ std::variant summary provider",
660                 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
661                 stl_summary_flags, true);
662 
663   stl_summary_flags.SetSkipPointers(true);
664 
665   AddCXXSummary(cpp_category_sp,
666                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
667                 "libc++ std::shared_ptr summary provider",
668                 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
669                 stl_summary_flags, true);
670   AddCXXSummary(cpp_category_sp,
671                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
672                 "libc++ std::weak_ptr summary provider",
673                 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
674                 stl_summary_flags, true);
675 
676   AddCXXSynthetic(
677       cpp_category_sp,
678       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
679       "std::vector iterator synthetic children",
680       ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
681       true);
682 
683   AddCXXSynthetic(
684       cpp_category_sp,
685       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
686       "std::map iterator synthetic children",
687       ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
688       true);
689 }
690 
691 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
692   if (!cpp_category_sp)
693     return;
694 
695   TypeSummaryImpl::Flags stl_summary_flags;
696   stl_summary_flags.SetCascades(true)
697       .SetSkipPointers(false)
698       .SetSkipReferences(false)
699       .SetDontShowChildren(true)
700       .SetDontShowValue(true)
701       .SetShowMembersOneLiner(false)
702       .SetHideItemNames(false);
703 
704   lldb::TypeSummaryImplSP std_string_summary_sp(
705       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
706 
707   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
708       stl_summary_flags, LibStdcppStringSummaryProvider,
709       "libstdc++ c++11 std::string summary provider"));
710   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
711       stl_summary_flags, LibStdcppWStringSummaryProvider,
712       "libstdc++ c++11 std::wstring summary provider"));
713 
714   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
715                                                     std_string_summary_sp);
716   cpp_category_sp->GetTypeSummariesContainer()->Add(
717       ConstString("std::basic_string<char>"), std_string_summary_sp);
718   cpp_category_sp->GetTypeSummariesContainer()->Add(
719       ConstString("std::basic_string<char,std::char_traits<char>,std::"
720                   "allocator<char> >"),
721       std_string_summary_sp);
722   cpp_category_sp->GetTypeSummariesContainer()->Add(
723       ConstString("std::basic_string<char, std::char_traits<char>, "
724                   "std::allocator<char> >"),
725       std_string_summary_sp);
726 
727   cpp_category_sp->GetTypeSummariesContainer()->Add(
728       ConstString("std::__cxx11::string"), cxx11_string_summary_sp);
729   cpp_category_sp->GetTypeSummariesContainer()->Add(
730       ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, "
731                   "std::allocator<char> >"),
732       cxx11_string_summary_sp);
733   cpp_category_sp->GetTypeSummariesContainer()->Add(
734       ConstString("std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, "
735                   "std::allocator<unsigned char> >"),
736       cxx11_string_summary_sp);
737 
738   // making sure we force-pick the summary for printing wstring (_M_p is a
739   // wchar_t*)
740   lldb::TypeSummaryImplSP std_wstring_summary_sp(
741       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
742 
743   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
744                                                     std_wstring_summary_sp);
745   cpp_category_sp->GetTypeSummariesContainer()->Add(
746       ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp);
747   cpp_category_sp->GetTypeSummariesContainer()->Add(
748       ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
749                   "allocator<wchar_t> >"),
750       std_wstring_summary_sp);
751   cpp_category_sp->GetTypeSummariesContainer()->Add(
752       ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, "
753                   "std::allocator<wchar_t> >"),
754       std_wstring_summary_sp);
755 
756   cpp_category_sp->GetTypeSummariesContainer()->Add(
757       ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp);
758   cpp_category_sp->GetTypeSummariesContainer()->Add(
759       ConstString("std::__cxx11::basic_string<wchar_t, "
760                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
761       cxx11_wstring_summary_sp);
762 
763   SyntheticChildren::Flags stl_synth_flags;
764   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
765       false);
766 
767   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
768       RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")),
769       SyntheticChildrenSP(new ScriptedSyntheticChildren(
770           stl_synth_flags,
771           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
772   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
773       RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")),
774       SyntheticChildrenSP(new ScriptedSyntheticChildren(
775           stl_synth_flags,
776           "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
777   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
778       RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")),
779       SyntheticChildrenSP(new ScriptedSyntheticChildren(
780           stl_synth_flags,
781           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
782   stl_summary_flags.SetDontShowChildren(false);
783   stl_summary_flags.SetSkipPointers(true);
784   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
785       RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")),
786       TypeSummaryImplSP(
787           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
788   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
789       RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")),
790       TypeSummaryImplSP(
791           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
792   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
793       RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")),
794       TypeSummaryImplSP(
795           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
796 
797   AddCXXSynthetic(
798       cpp_category_sp,
799       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
800       "std::vector iterator synthetic children",
801       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
802 
803   AddCXXSynthetic(
804       cpp_category_sp,
805       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
806       "std::map iterator synthetic children",
807       ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
808 
809   AddCXXSynthetic(
810       cpp_category_sp,
811       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
812       "std::unique_ptr synthetic children",
813       ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
814   AddCXXSynthetic(
815       cpp_category_sp,
816       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
817       "std::shared_ptr synthetic children",
818       ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
819   AddCXXSynthetic(
820       cpp_category_sp,
821       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
822       "std::weak_ptr synthetic children",
823       ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
824   AddCXXSynthetic(
825       cpp_category_sp,
826       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
827       "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
828       stl_synth_flags, true);
829 
830   AddCXXSummary(cpp_category_sp,
831                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
832                 "libstdc++ std::unique_ptr summary provider",
833                 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
834                 true);
835   AddCXXSummary(cpp_category_sp,
836                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
837                 "libstdc++ std::shared_ptr summary provider",
838                 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
839                 true);
840   AddCXXSummary(cpp_category_sp,
841                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
842                 "libstdc++ std::weak_ptr summary provider",
843                 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
844                 true);
845 }
846 
847 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
848   if (!cpp_category_sp)
849     return;
850 
851   TypeSummaryImpl::Flags string_flags;
852   string_flags.SetCascades(true)
853       .SetSkipPointers(true)
854       .SetSkipReferences(false)
855       .SetDontShowChildren(true)
856       .SetDontShowValue(false)
857       .SetShowMembersOneLiner(false)
858       .SetHideItemNames(false);
859 
860   TypeSummaryImpl::Flags string_array_flags;
861   string_array_flags.SetCascades(true)
862       .SetSkipPointers(true)
863       .SetSkipReferences(false)
864       .SetDontShowChildren(true)
865       .SetDontShowValue(true)
866       .SetShowMembersOneLiner(false)
867       .SetHideItemNames(false);
868 
869   // FIXME because of a bug in the FormattersContainer we need to add a summary
870   // for both X* and const X* (<rdar://problem/12717717>)
871   AddCXXSummary(
872       cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider,
873       "char8_t * summary provider", ConstString("char8_t *"), string_flags);
874   AddCXXSummary(cpp_category_sp,
875                 lldb_private::formatters::Char8StringSummaryProvider,
876                 "char8_t [] summary provider",
877                 ConstString("char8_t \\[[0-9]+\\]"), string_array_flags, true);
878 
879   AddCXXSummary(
880       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
881       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
882   AddCXXSummary(cpp_category_sp,
883                 lldb_private::formatters::Char16StringSummaryProvider,
884                 "char16_t [] summary provider",
885                 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true);
886 
887   AddCXXSummary(
888       cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
889       "char32_t * summary provider", ConstString("char32_t *"), string_flags);
890   AddCXXSummary(cpp_category_sp,
891                 lldb_private::formatters::Char32StringSummaryProvider,
892                 "char32_t [] summary provider",
893                 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true);
894 
895   AddCXXSummary(
896       cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
897       "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
898   AddCXXSummary(cpp_category_sp,
899                 lldb_private::formatters::WCharStringSummaryProvider,
900                 "wchar_t * summary provider",
901                 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
902 
903   AddCXXSummary(
904       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
905       "unichar * summary provider", ConstString("unichar *"), string_flags);
906 
907   TypeSummaryImpl::Flags widechar_flags;
908   widechar_flags.SetDontShowValue(true)
909       .SetSkipPointers(true)
910       .SetSkipReferences(false)
911       .SetCascades(true)
912       .SetDontShowChildren(true)
913       .SetHideItemNames(true)
914       .SetShowMembersOneLiner(false);
915 
916   AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider,
917                 "char8_t summary provider", ConstString("char8_t"),
918                 widechar_flags);
919   AddCXXSummary(
920       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
921       "char16_t summary provider", ConstString("char16_t"), widechar_flags);
922   AddCXXSummary(
923       cpp_category_sp, lldb_private::formatters::Char32SummaryProvider,
924       "char32_t summary provider", ConstString("char32_t"), widechar_flags);
925   AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
926                 "wchar_t summary provider", ConstString("wchar_t"),
927                 widechar_flags);
928 
929   AddCXXSummary(
930       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
931       "unichar summary provider", ConstString("unichar"), widechar_flags);
932 }
933 
934 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
935   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
936   public:
937     CompilerType AdjustForInclusion(CompilerType &candidate) override {
938       LanguageType lang_type(candidate.GetMinimumLanguage());
939       if (!Language::LanguageIsC(lang_type) &&
940           !Language::LanguageIsCPlusPlus(lang_type))
941         return CompilerType();
942       if (candidate.IsTypedefType())
943         return candidate.GetTypedefedType();
944       return candidate;
945     }
946   };
947 
948   return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
949 }
950 
951 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
952   static llvm::once_flag g_initialize;
953   static TypeCategoryImplSP g_category;
954 
955   llvm::call_once(g_initialize, [this]() -> void {
956     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
957     if (g_category) {
958       LoadLibStdcppFormatters(g_category);
959       LoadLibCxxFormatters(g_category);
960       LoadSystemFormatters(g_category);
961     }
962   });
963   return g_category;
964 }
965 
966 HardcodedFormatters::HardcodedSummaryFinder
967 CPlusPlusLanguage::GetHardcodedSummaries() {
968   static llvm::once_flag g_initialize;
969   static ConstString g_vectortypes("VectorTypes");
970   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
971 
972   llvm::call_once(g_initialize, []() -> void {
973     g_formatters.push_back(
974         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
975            FormatManager &) -> TypeSummaryImpl::SharedPointer {
976           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
977               new CXXFunctionSummaryFormat(
978                   TypeSummaryImpl::Flags(),
979                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
980                   "Function pointer summary provider"));
981           if (valobj.GetCompilerType().IsFunctionPointerType()) {
982             return formatter_sp;
983           }
984           return nullptr;
985         });
986     g_formatters.push_back(
987         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
988            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
989           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
990               new CXXFunctionSummaryFormat(
991                   TypeSummaryImpl::Flags()
992                       .SetCascades(true)
993                       .SetDontShowChildren(true)
994                       .SetHideItemNames(true)
995                       .SetShowMembersOneLiner(true)
996                       .SetSkipPointers(true)
997                       .SetSkipReferences(false),
998                   lldb_private::formatters::VectorTypeSummaryProvider,
999                   "vector_type pointer summary provider"));
1000           if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) {
1001             if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1002               return formatter_sp;
1003           }
1004           return nullptr;
1005         });
1006     g_formatters.push_back(
1007         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1008            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1009           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1010               new CXXFunctionSummaryFormat(
1011                   TypeSummaryImpl::Flags()
1012                       .SetCascades(true)
1013                       .SetDontShowChildren(true)
1014                       .SetHideItemNames(true)
1015                       .SetShowMembersOneLiner(true)
1016                       .SetSkipPointers(true)
1017                       .SetSkipReferences(false),
1018                   lldb_private::formatters::BlockPointerSummaryProvider,
1019                   "block pointer summary provider"));
1020           if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1021             return formatter_sp;
1022           }
1023           return nullptr;
1024         });
1025   });
1026 
1027   return g_formatters;
1028 }
1029 
1030 HardcodedFormatters::HardcodedSyntheticFinder
1031 CPlusPlusLanguage::GetHardcodedSynthetics() {
1032   static llvm::once_flag g_initialize;
1033   static ConstString g_vectortypes("VectorTypes");
1034   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
1035 
1036   llvm::call_once(g_initialize, []() -> void {
1037     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1038                               lldb::DynamicValueType,
1039                               FormatManager &
1040                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1041       static CXXSyntheticChildren::SharedPointer formatter_sp(
1042           new CXXSyntheticChildren(
1043               SyntheticChildren::Flags()
1044                   .SetCascades(true)
1045                   .SetSkipPointers(true)
1046                   .SetSkipReferences(true)
1047                   .SetNonCacheable(true),
1048               "vector_type synthetic children",
1049               lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
1050       if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) {
1051         if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1052           return formatter_sp;
1053       }
1054       return nullptr;
1055     });
1056     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1057                               lldb::DynamicValueType,
1058                               FormatManager &
1059                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1060       static CXXSyntheticChildren::SharedPointer formatter_sp(
1061           new CXXSyntheticChildren(
1062               SyntheticChildren::Flags()
1063                   .SetCascades(true)
1064                   .SetSkipPointers(true)
1065                   .SetSkipReferences(true)
1066                   .SetNonCacheable(true),
1067               "block pointer synthetic children",
1068               lldb_private::formatters::BlockPointerSyntheticFrontEndCreator));
1069       if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1070         return formatter_sp;
1071       }
1072       return nullptr;
1073     });
1074 
1075   });
1076 
1077   return g_formatters;
1078 }
1079 
1080 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
1081   const auto suffixes = {".cpp", ".cxx", ".c++", ".cc",  ".c",
1082                          ".h",   ".hh",  ".hpp", ".hxx", ".h++"};
1083   for (auto suffix : suffixes) {
1084     if (file_path.endswith_lower(suffix))
1085       return true;
1086   }
1087 
1088   // Check if we're in a STL path (where the files usually have no extension
1089   // that we could check for.
1090   return file_path.contains("/usr/include/c++/");
1091 }
1092