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