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 charater (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   AddCXXSynthetic(
615       cpp_category_sp,
616       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
617       "weak_ptr synthetic children",
618       ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
619       stl_synth_flags, true);
620   AddCXXSummary(cpp_category_sp,
621                 lldb_private::formatters::LibcxxFunctionSummaryProvider,
622                 "libc++ std::function summary provider",
623                 ConstString("^std::__[[:alnum:]]+::function<.+>$"),
624                 stl_summary_flags, true);
625 
626   stl_summary_flags.SetDontShowChildren(false);
627   stl_summary_flags.SetSkipPointers(false);
628   AddCXXSummary(cpp_category_sp,
629                 lldb_private::formatters::LibcxxContainerSummaryProvider,
630                 "libc++ std::bitset summary provider",
631                 ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
632                 stl_summary_flags, true);
633   AddCXXSummary(cpp_category_sp,
634                 lldb_private::formatters::LibcxxContainerSummaryProvider,
635                 "libc++ std::vector summary provider",
636                 ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
637                 stl_summary_flags, true);
638   AddCXXSummary(cpp_category_sp,
639                 lldb_private::formatters::LibcxxContainerSummaryProvider,
640                 "libc++ std::list summary provider",
641                 ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
642                 stl_summary_flags, true);
643   AddCXXSummary(
644       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
645       "libc++ std::list summary provider",
646       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
647       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
648       ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
649                   "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
650       stl_summary_flags, true);
651   AddCXXSummary(cpp_category_sp,
652                 lldb_private::formatters::LibcxxContainerSummaryProvider,
653                 "libc++ std::map summary provider",
654                 ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
655                 stl_summary_flags, true);
656   AddCXXSummary(cpp_category_sp,
657                 lldb_private::formatters::LibcxxContainerSummaryProvider,
658                 "libc++ std::deque summary provider",
659                 ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
660                 stl_summary_flags, true);
661   AddCXXSummary(cpp_category_sp,
662                 lldb_private::formatters::LibcxxContainerSummaryProvider,
663                 "libc++ std::queue summary provider",
664                 ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
665                 stl_summary_flags, true);
666   AddCXXSummary(cpp_category_sp,
667                 lldb_private::formatters::LibcxxContainerSummaryProvider,
668                 "libc++ std::set summary provider",
669                 ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
670                 stl_summary_flags, true);
671   AddCXXSummary(cpp_category_sp,
672                 lldb_private::formatters::LibcxxContainerSummaryProvider,
673                 "libc++ std::multiset summary provider",
674                 ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
675                 stl_summary_flags, true);
676   AddCXXSummary(cpp_category_sp,
677                 lldb_private::formatters::LibcxxContainerSummaryProvider,
678                 "libc++ std::multimap summary provider",
679                 ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
680                 stl_summary_flags, true);
681   AddCXXSummary(
682       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
683       "libc++ std::unordered containers summary provider",
684       ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
685       stl_summary_flags, true);
686   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
687                 "libc++ std::tuple summary provider",
688                 ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
689                 stl_summary_flags, true);
690   AddCXXSummary(
691       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
692       "libc++ std::atomic summary provider",
693       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_summary_flags,
694       true);
695   AddCXXSummary(cpp_category_sp,
696                 lldb_private::formatters::LibcxxOptionalSummaryProvider,
697                 "libc++ std::optional summary provider",
698                 ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
699                 stl_summary_flags, true);
700   AddCXXSummary(cpp_category_sp,
701                 lldb_private::formatters::LibcxxVariantSummaryProvider,
702                 "libc++ std::variant summary provider",
703                 ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
704                 stl_summary_flags, true);
705 
706   stl_summary_flags.SetSkipPointers(true);
707 
708   AddCXXSummary(cpp_category_sp,
709                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
710                 "libc++ std::shared_ptr summary provider",
711                 ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
712                 stl_summary_flags, true);
713   AddCXXSummary(cpp_category_sp,
714                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
715                 "libc++ std::weak_ptr summary provider",
716                 ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
717                 stl_summary_flags, true);
718 
719   AddCXXSynthetic(
720       cpp_category_sp,
721       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
722       "std::vector iterator synthetic children",
723       ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
724       true);
725 
726   AddCXXSynthetic(
727       cpp_category_sp,
728       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
729       "std::map iterator synthetic children",
730       ConstString("^std::__[[:alnum:]]+::__map_iterator<.+>$"), stl_synth_flags,
731       true);
732 }
733 
734 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
735   if (!cpp_category_sp)
736     return;
737 
738   TypeSummaryImpl::Flags stl_summary_flags;
739   stl_summary_flags.SetCascades(true)
740       .SetSkipPointers(false)
741       .SetSkipReferences(false)
742       .SetDontShowChildren(true)
743       .SetDontShowValue(true)
744       .SetShowMembersOneLiner(false)
745       .SetHideItemNames(false);
746 
747   lldb::TypeSummaryImplSP std_string_summary_sp(
748       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
749 
750   lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
751       stl_summary_flags, LibStdcppStringSummaryProvider,
752       "libstdc++ c++11 std::string summary provider"));
753   lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
754       stl_summary_flags, LibStdcppWStringSummaryProvider,
755       "libstdc++ c++11 std::wstring summary provider"));
756 
757   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::string"),
758                                                     std_string_summary_sp);
759   cpp_category_sp->GetTypeSummariesContainer()->Add(
760       ConstString("std::basic_string<char>"), std_string_summary_sp);
761   cpp_category_sp->GetTypeSummariesContainer()->Add(
762       ConstString("std::basic_string<char,std::char_traits<char>,std::"
763                   "allocator<char> >"),
764       std_string_summary_sp);
765   cpp_category_sp->GetTypeSummariesContainer()->Add(
766       ConstString("std::basic_string<char, std::char_traits<char>, "
767                   "std::allocator<char> >"),
768       std_string_summary_sp);
769 
770   cpp_category_sp->GetTypeSummariesContainer()->Add(
771       ConstString("std::__cxx11::string"), cxx11_string_summary_sp);
772   cpp_category_sp->GetTypeSummariesContainer()->Add(
773       ConstString("std::__cxx11::basic_string<char, std::char_traits<char>, "
774                   "std::allocator<char> >"),
775       cxx11_string_summary_sp);
776   cpp_category_sp->GetTypeSummariesContainer()->Add(
777       ConstString("std::__cxx11::basic_string<unsigned char, std::char_traits<unsigned char>, "
778                   "std::allocator<unsigned char> >"),
779       cxx11_string_summary_sp);
780 
781   // making sure we force-pick the summary for printing wstring (_M_p is a
782   // wchar_t*)
783   lldb::TypeSummaryImplSP std_wstring_summary_sp(
784       new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
785 
786   cpp_category_sp->GetTypeSummariesContainer()->Add(ConstString("std::wstring"),
787                                                     std_wstring_summary_sp);
788   cpp_category_sp->GetTypeSummariesContainer()->Add(
789       ConstString("std::basic_string<wchar_t>"), std_wstring_summary_sp);
790   cpp_category_sp->GetTypeSummariesContainer()->Add(
791       ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::"
792                   "allocator<wchar_t> >"),
793       std_wstring_summary_sp);
794   cpp_category_sp->GetTypeSummariesContainer()->Add(
795       ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, "
796                   "std::allocator<wchar_t> >"),
797       std_wstring_summary_sp);
798 
799   cpp_category_sp->GetTypeSummariesContainer()->Add(
800       ConstString("std::__cxx11::wstring"), cxx11_wstring_summary_sp);
801   cpp_category_sp->GetTypeSummariesContainer()->Add(
802       ConstString("std::__cxx11::basic_string<wchar_t, "
803                   "std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
804       cxx11_wstring_summary_sp);
805 
806   SyntheticChildren::Flags stl_synth_flags;
807   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
808       false);
809 
810   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
811       RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")),
812       SyntheticChildrenSP(new ScriptedSyntheticChildren(
813           stl_synth_flags,
814           "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
815   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
816       RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")),
817       SyntheticChildrenSP(new ScriptedSyntheticChildren(
818           stl_synth_flags,
819           "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
820   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
821       RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")),
822       SyntheticChildrenSP(new ScriptedSyntheticChildren(
823           stl_synth_flags,
824           "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
825   stl_summary_flags.SetDontShowChildren(false);
826   stl_summary_flags.SetSkipPointers(true);
827   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
828       RegularExpression(llvm::StringRef("^std::vector<.+>(( )?&)?$")),
829       TypeSummaryImplSP(
830           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
831   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
832       RegularExpression(llvm::StringRef("^std::map<.+> >(( )?&)?$")),
833       TypeSummaryImplSP(
834           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
835   cpp_category_sp->GetRegexTypeSummariesContainer()->Add(
836       RegularExpression(llvm::StringRef("^std::(__cxx11::)?list<.+>(( )?&)?$")),
837       TypeSummaryImplSP(
838           new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
839 
840   AddCXXSynthetic(
841       cpp_category_sp,
842       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
843       "std::vector iterator synthetic children",
844       ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
845 
846   AddCXXSynthetic(
847       cpp_category_sp,
848       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
849       "std::map iterator synthetic children",
850       ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
851 
852   AddCXXSynthetic(
853       cpp_category_sp,
854       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
855       "std::unique_ptr synthetic children",
856       ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
857   AddCXXSynthetic(
858       cpp_category_sp,
859       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
860       "std::shared_ptr synthetic children",
861       ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
862   AddCXXSynthetic(
863       cpp_category_sp,
864       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
865       "std::weak_ptr synthetic children",
866       ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
867   AddCXXSynthetic(
868       cpp_category_sp,
869       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
870       "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
871       stl_synth_flags, true);
872 
873   AddCXXSummary(cpp_category_sp,
874                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
875                 "libstdc++ std::unique_ptr summary provider",
876                 ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
877                 true);
878   AddCXXSummary(cpp_category_sp,
879                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
880                 "libstdc++ std::shared_ptr summary provider",
881                 ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
882                 true);
883   AddCXXSummary(cpp_category_sp,
884                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
885                 "libstdc++ std::weak_ptr summary provider",
886                 ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
887                 true);
888 }
889 
890 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
891   if (!cpp_category_sp)
892     return;
893 
894   TypeSummaryImpl::Flags string_flags;
895   string_flags.SetCascades(true)
896       .SetSkipPointers(true)
897       .SetSkipReferences(false)
898       .SetDontShowChildren(true)
899       .SetDontShowValue(false)
900       .SetShowMembersOneLiner(false)
901       .SetHideItemNames(false);
902 
903   TypeSummaryImpl::Flags string_array_flags;
904   string_array_flags.SetCascades(true)
905       .SetSkipPointers(true)
906       .SetSkipReferences(false)
907       .SetDontShowChildren(true)
908       .SetDontShowValue(true)
909       .SetShowMembersOneLiner(false)
910       .SetHideItemNames(false);
911 
912   // FIXME because of a bug in the FormattersContainer we need to add a summary
913   // for both X* and const X* (<rdar://problem/12717717>)
914   AddCXXSummary(
915       cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider,
916       "char8_t * summary provider", ConstString("char8_t *"), string_flags);
917   AddCXXSummary(cpp_category_sp,
918                 lldb_private::formatters::Char8StringSummaryProvider,
919                 "char8_t [] summary provider",
920                 ConstString("char8_t \\[[0-9]+\\]"), string_array_flags, true);
921 
922   AddCXXSummary(
923       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
924       "char16_t * summary provider", ConstString("char16_t *"), string_flags);
925   AddCXXSummary(cpp_category_sp,
926                 lldb_private::formatters::Char16StringSummaryProvider,
927                 "char16_t [] summary provider",
928                 ConstString("char16_t \\[[0-9]+\\]"), string_array_flags, true);
929 
930   AddCXXSummary(
931       cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
932       "char32_t * summary provider", ConstString("char32_t *"), string_flags);
933   AddCXXSummary(cpp_category_sp,
934                 lldb_private::formatters::Char32StringSummaryProvider,
935                 "char32_t [] summary provider",
936                 ConstString("char32_t \\[[0-9]+\\]"), string_array_flags, true);
937 
938   AddCXXSummary(
939       cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
940       "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
941   AddCXXSummary(cpp_category_sp,
942                 lldb_private::formatters::WCharStringSummaryProvider,
943                 "wchar_t * summary provider",
944                 ConstString("wchar_t \\[[0-9]+\\]"), string_array_flags, true);
945 
946   AddCXXSummary(
947       cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
948       "unichar * summary provider", ConstString("unichar *"), string_flags);
949 
950   TypeSummaryImpl::Flags widechar_flags;
951   widechar_flags.SetDontShowValue(true)
952       .SetSkipPointers(true)
953       .SetSkipReferences(false)
954       .SetCascades(true)
955       .SetDontShowChildren(true)
956       .SetHideItemNames(true)
957       .SetShowMembersOneLiner(false);
958 
959   AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider,
960                 "char8_t summary provider", ConstString("char8_t"),
961                 widechar_flags);
962   AddCXXSummary(
963       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
964       "char16_t summary provider", ConstString("char16_t"), widechar_flags);
965   AddCXXSummary(
966       cpp_category_sp, lldb_private::formatters::Char32SummaryProvider,
967       "char32_t summary provider", ConstString("char32_t"), widechar_flags);
968   AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
969                 "wchar_t summary provider", ConstString("wchar_t"),
970                 widechar_flags);
971 
972   AddCXXSummary(
973       cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
974       "unichar summary provider", ConstString("unichar"), widechar_flags);
975 }
976 
977 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
978   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
979   public:
980     CompilerType AdjustForInclusion(CompilerType &candidate) override {
981       LanguageType lang_type(candidate.GetMinimumLanguage());
982       if (!Language::LanguageIsC(lang_type) &&
983           !Language::LanguageIsCPlusPlus(lang_type))
984         return CompilerType();
985       if (candidate.IsTypedefType())
986         return candidate.GetTypedefedType();
987       return candidate;
988     }
989   };
990 
991   return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
992 }
993 
994 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
995   static llvm::once_flag g_initialize;
996   static TypeCategoryImplSP g_category;
997 
998   llvm::call_once(g_initialize, [this]() -> void {
999     DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
1000     if (g_category) {
1001       LoadLibStdcppFormatters(g_category);
1002       LoadLibCxxFormatters(g_category);
1003       LoadSystemFormatters(g_category);
1004     }
1005   });
1006   return g_category;
1007 }
1008 
1009 HardcodedFormatters::HardcodedSummaryFinder
1010 CPlusPlusLanguage::GetHardcodedSummaries() {
1011   static llvm::once_flag g_initialize;
1012   static ConstString g_vectortypes("VectorTypes");
1013   static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
1014 
1015   llvm::call_once(g_initialize, []() -> void {
1016     g_formatters.push_back(
1017         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1018            FormatManager &) -> TypeSummaryImpl::SharedPointer {
1019           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1020               new CXXFunctionSummaryFormat(
1021                   TypeSummaryImpl::Flags(),
1022                   lldb_private::formatters::CXXFunctionPointerSummaryProvider,
1023                   "Function pointer summary provider"));
1024           if (valobj.GetCompilerType().IsFunctionPointerType()) {
1025             return formatter_sp;
1026           }
1027           return nullptr;
1028         });
1029     g_formatters.push_back(
1030         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1031            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1032           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1033               new CXXFunctionSummaryFormat(
1034                   TypeSummaryImpl::Flags()
1035                       .SetCascades(true)
1036                       .SetDontShowChildren(true)
1037                       .SetHideItemNames(true)
1038                       .SetShowMembersOneLiner(true)
1039                       .SetSkipPointers(true)
1040                       .SetSkipReferences(false),
1041                   lldb_private::formatters::VectorTypeSummaryProvider,
1042                   "vector_type pointer summary provider"));
1043           if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) {
1044             if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1045               return formatter_sp;
1046           }
1047           return nullptr;
1048         });
1049     g_formatters.push_back(
1050         [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1051            FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1052           static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1053               new CXXFunctionSummaryFormat(
1054                   TypeSummaryImpl::Flags()
1055                       .SetCascades(true)
1056                       .SetDontShowChildren(true)
1057                       .SetHideItemNames(true)
1058                       .SetShowMembersOneLiner(true)
1059                       .SetSkipPointers(true)
1060                       .SetSkipReferences(false),
1061                   lldb_private::formatters::BlockPointerSummaryProvider,
1062                   "block pointer summary provider"));
1063           if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1064             return formatter_sp;
1065           }
1066           return nullptr;
1067         });
1068   });
1069 
1070   return g_formatters;
1071 }
1072 
1073 HardcodedFormatters::HardcodedSyntheticFinder
1074 CPlusPlusLanguage::GetHardcodedSynthetics() {
1075   static llvm::once_flag g_initialize;
1076   static ConstString g_vectortypes("VectorTypes");
1077   static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
1078 
1079   llvm::call_once(g_initialize, []() -> void {
1080     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1081                               lldb::DynamicValueType,
1082                               FormatManager &
1083                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1084       static CXXSyntheticChildren::SharedPointer formatter_sp(
1085           new CXXSyntheticChildren(
1086               SyntheticChildren::Flags()
1087                   .SetCascades(true)
1088                   .SetSkipPointers(true)
1089                   .SetSkipReferences(true)
1090                   .SetNonCacheable(true),
1091               "vector_type synthetic children",
1092               lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
1093       if (valobj.GetCompilerType().IsVectorType(nullptr, nullptr)) {
1094         if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1095           return formatter_sp;
1096       }
1097       return nullptr;
1098     });
1099     g_formatters.push_back([](lldb_private::ValueObject &valobj,
1100                               lldb::DynamicValueType,
1101                               FormatManager &
1102                                   fmt_mgr) -> SyntheticChildren::SharedPointer {
1103       static CXXSyntheticChildren::SharedPointer formatter_sp(
1104           new CXXSyntheticChildren(
1105               SyntheticChildren::Flags()
1106                   .SetCascades(true)
1107                   .SetSkipPointers(true)
1108                   .SetSkipReferences(true)
1109                   .SetNonCacheable(true),
1110               "block pointer synthetic children",
1111               lldb_private::formatters::BlockPointerSyntheticFrontEndCreator));
1112       if (valobj.GetCompilerType().IsBlockPointerType(nullptr)) {
1113         return formatter_sp;
1114       }
1115       return nullptr;
1116     });
1117 
1118   });
1119 
1120   return g_formatters;
1121 }
1122 
1123 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
1124   const auto suffixes = {".cpp", ".cxx", ".c++", ".cc",  ".c",
1125                          ".h",   ".hh",  ".hpp", ".hxx", ".h++"};
1126   for (auto suffix : suffixes) {
1127     if (file_path.endswith_lower(suffix))
1128       return true;
1129   }
1130 
1131   // Check if we're in a STL path (where the files usually have no extension
1132   // that we could check for.
1133   return file_path.contains("/usr/include/c++/");
1134 }
1135