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