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