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/Module.h"
24 #include "lldb/Core/PluginManager.h"
25 #include "lldb/Core/UniqueCStringMap.h"
26 #include "lldb/Core/ValueObjectVariable.h"
27 #include "lldb/DataFormatters/CXXFunctionPointer.h"
28 #include "lldb/DataFormatters/DataVisualization.h"
29 #include "lldb/DataFormatters/FormattersHelpers.h"
30 #include "lldb/DataFormatters/VectorType.h"
31 #include "lldb/Symbol/SymbolFile.h"
32 #include "lldb/Symbol/VariableList.h"
33 #include "lldb/Utility/ConstString.h"
34 #include "lldb/Utility/LLDBLog.h"
35 #include "lldb/Utility/Log.h"
36 #include "lldb/Utility/RegularExpression.h"
37
38 #include "BlockPointer.h"
39 #include "CPlusPlusNameParser.h"
40 #include "Coroutines.h"
41 #include "CxxStringTypes.h"
42 #include "Generic.h"
43 #include "LibCxx.h"
44 #include "LibCxxAtomic.h"
45 #include "LibCxxVariant.h"
46 #include "LibStdcpp.h"
47 #include "MSVCUndecoratedNameParser.h"
48 #include "lldb/lldb-enumerations.h"
49
50 using namespace lldb;
51 using namespace lldb_private;
52 using namespace lldb_private::formatters;
53
LLDB_PLUGIN_DEFINE(CPlusPlusLanguage)54 LLDB_PLUGIN_DEFINE(CPlusPlusLanguage)
55
56 void CPlusPlusLanguage::Initialize() {
57 PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
58 CreateInstance);
59 }
60
Terminate()61 void CPlusPlusLanguage::Terminate() {
62 PluginManager::UnregisterPlugin(CreateInstance);
63 }
64
SymbolNameFitsToLanguage(Mangled mangled) const65 bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled) const {
66 const char *mangled_name = mangled.GetMangledName().GetCString();
67 return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name);
68 }
69
GetDemangledFunctionNameWithoutArguments(Mangled mangled) const70 ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments(
71 Mangled mangled) const {
72 const char *mangled_name_cstr = mangled.GetMangledName().GetCString();
73 ConstString demangled_name = mangled.GetDemangledName();
74 if (demangled_name && mangled_name_cstr && mangled_name_cstr[0]) {
75 if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
76 (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure,
77 // typeinfo structure, and typeinfo
78 // mangled_name
79 mangled_name_cstr[2] != 'G' && // avoid guard variables
80 mangled_name_cstr[2] != 'Z')) // named local entities (if we
81 // eventually handle eSymbolTypeData,
82 // we will want this back)
83 {
84 CPlusPlusLanguage::MethodName cxx_method(demangled_name);
85 if (!cxx_method.GetBasename().empty()) {
86 std::string shortname;
87 if (!cxx_method.GetContext().empty())
88 shortname = cxx_method.GetContext().str() + "::";
89 shortname += cxx_method.GetBasename().str();
90 return ConstString(shortname);
91 }
92 }
93 }
94 if (demangled_name)
95 return demangled_name;
96 return mangled.GetMangledName();
97 }
98
99 // Static Functions
100
CreateInstance(lldb::LanguageType language)101 Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
102 // Use plugin for C++ but not for Objective-C++ (which has its own plugin).
103 if (Language::LanguageIsCPlusPlus(language) &&
104 language != eLanguageTypeObjC_plus_plus)
105 return new CPlusPlusLanguage();
106 return nullptr;
107 }
108
Clear()109 void CPlusPlusLanguage::MethodName::Clear() {
110 m_full.Clear();
111 m_basename = llvm::StringRef();
112 m_context = llvm::StringRef();
113 m_arguments = llvm::StringRef();
114 m_qualifiers = llvm::StringRef();
115 m_return_type = llvm::StringRef();
116 m_parsed = false;
117 m_parse_error = false;
118 }
119
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)120 static bool ReverseFindMatchingChars(const llvm::StringRef &s,
121 const llvm::StringRef &left_right_chars,
122 size_t &left_pos, size_t &right_pos,
123 size_t pos = llvm::StringRef::npos) {
124 assert(left_right_chars.size() == 2);
125 left_pos = llvm::StringRef::npos;
126 const char left_char = left_right_chars[0];
127 const char right_char = left_right_chars[1];
128 pos = s.find_last_of(left_right_chars, pos);
129 if (pos == llvm::StringRef::npos || s[pos] == left_char)
130 return false;
131 right_pos = pos;
132 uint32_t depth = 1;
133 while (pos > 0 && depth > 0) {
134 pos = s.find_last_of(left_right_chars, pos);
135 if (pos == llvm::StringRef::npos)
136 return false;
137 if (s[pos] == left_char) {
138 if (--depth == 0) {
139 left_pos = pos;
140 return left_pos < right_pos;
141 }
142 } else if (s[pos] == right_char) {
143 ++depth;
144 }
145 }
146 return false;
147 }
148
IsTrivialBasename(const llvm::StringRef & basename)149 static bool IsTrivialBasename(const llvm::StringRef &basename) {
150 // Check that the basename matches with the following regular expression
151 // "^~?([A-Za-z_][A-Za-z_0-9]*)$" We are using a hand written implementation
152 // because it is significantly more efficient then using the general purpose
153 // regular expression library.
154 size_t idx = 0;
155 if (basename.size() > 0 && basename[0] == '~')
156 idx = 1;
157
158 if (basename.size() <= idx)
159 return false; // Empty string or "~"
160
161 if (!std::isalpha(basename[idx]) && basename[idx] != '_')
162 return false; // First character (after removing the possible '~'') isn't in
163 // [A-Za-z_]
164
165 // Read all characters matching [A-Za-z_0-9]
166 ++idx;
167 while (idx < basename.size()) {
168 if (!std::isalnum(basename[idx]) && basename[idx] != '_')
169 break;
170 ++idx;
171 }
172
173 // We processed all characters. It is a vaild basename.
174 return idx == basename.size();
175 }
176
177 /// Writes out the function name in 'full_name' to 'out_stream'
178 /// but replaces each argument type with the variable name
179 /// and the corresponding pretty-printed value
PrettyPrintFunctionNameWithArgs(Stream & out_stream,char const * full_name,ExecutionContextScope * exe_scope,VariableList const & args)180 static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
181 char const *full_name,
182 ExecutionContextScope *exe_scope,
183 VariableList const &args) {
184 CPlusPlusLanguage::MethodName cpp_method{ConstString(full_name)};
185
186 if (!cpp_method.IsValid())
187 return false;
188
189 llvm::StringRef return_type = cpp_method.GetReturnType();
190 if (!return_type.empty()) {
191 out_stream.PutCString(return_type);
192 out_stream.PutChar(' ');
193 }
194
195 out_stream.PutCString(cpp_method.GetScopeQualifiedName());
196 out_stream.PutChar('(');
197
198 FormatEntity::PrettyPrintFunctionArguments(out_stream, args, exe_scope);
199
200 out_stream.PutChar(')');
201
202 llvm::StringRef qualifiers = cpp_method.GetQualifiers();
203 if (!qualifiers.empty()) {
204 out_stream.PutChar(' ');
205 out_stream.PutCString(qualifiers);
206 }
207
208 return true;
209 }
210
TrySimplifiedParse()211 bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
212 // This method tries to parse simple method definitions which are presumably
213 // most comman in user programs. Definitions that can be parsed by this
214 // function don't have return types and templates in the name.
215 // A::B::C::fun(std::vector<T> &) const
216 size_t arg_start, arg_end;
217 llvm::StringRef full(m_full.GetCString());
218 llvm::StringRef parens("()", 2);
219 if (ReverseFindMatchingChars(full, parens, arg_start, arg_end)) {
220 m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
221 if (arg_end + 1 < full.size())
222 m_qualifiers = full.substr(arg_end + 1).ltrim();
223
224 if (arg_start == 0)
225 return false;
226 size_t basename_end = arg_start;
227 size_t context_start = 0;
228 size_t context_end = full.rfind(':', basename_end);
229 if (context_end == llvm::StringRef::npos)
230 m_basename = full.substr(0, basename_end);
231 else {
232 if (context_start < context_end)
233 m_context = full.substr(context_start, context_end - 1 - context_start);
234 const size_t basename_begin = context_end + 1;
235 m_basename = full.substr(basename_begin, basename_end - basename_begin);
236 }
237
238 if (IsTrivialBasename(m_basename)) {
239 return true;
240 } else {
241 // The C++ basename doesn't match our regular expressions so this can't
242 // be a valid C++ method, clear everything out and indicate an error
243 m_context = llvm::StringRef();
244 m_basename = llvm::StringRef();
245 m_arguments = llvm::StringRef();
246 m_qualifiers = llvm::StringRef();
247 m_return_type = llvm::StringRef();
248 return false;
249 }
250 }
251 return false;
252 }
253
Parse()254 void CPlusPlusLanguage::MethodName::Parse() {
255 if (!m_parsed && m_full) {
256 if (TrySimplifiedParse()) {
257 m_parse_error = false;
258 } else {
259 CPlusPlusNameParser parser(m_full.GetStringRef());
260 if (auto function = parser.ParseAsFunctionDefinition()) {
261 m_basename = function->name.basename;
262 m_context = function->name.context;
263 m_arguments = function->arguments;
264 m_qualifiers = function->qualifiers;
265 m_return_type = function->return_type;
266 m_parse_error = false;
267 } else {
268 m_parse_error = true;
269 }
270 }
271 m_parsed = true;
272 }
273 }
274
GetBasename()275 llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() {
276 if (!m_parsed)
277 Parse();
278 return m_basename;
279 }
280
GetContext()281 llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() {
282 if (!m_parsed)
283 Parse();
284 return m_context;
285 }
286
GetArguments()287 llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() {
288 if (!m_parsed)
289 Parse();
290 return m_arguments;
291 }
292
GetQualifiers()293 llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
294 if (!m_parsed)
295 Parse();
296 return m_qualifiers;
297 }
298
GetReturnType()299 llvm::StringRef CPlusPlusLanguage::MethodName::GetReturnType() {
300 if (!m_parsed)
301 Parse();
302 return m_return_type;
303 }
304
GetScopeQualifiedName()305 std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
306 if (!m_parsed)
307 Parse();
308 if (m_context.empty())
309 return std::string(m_basename);
310
311 std::string res;
312 res += m_context;
313 res += "::";
314 res += m_basename;
315 return res;
316 }
317
318 llvm::StringRef
GetBasenameNoTemplateParameters()319 CPlusPlusLanguage::MethodName::GetBasenameNoTemplateParameters() {
320 llvm::StringRef basename = GetBasename();
321 size_t arg_start, arg_end;
322 llvm::StringRef parens("<>", 2);
323 if (ReverseFindMatchingChars(basename, parens, arg_start, arg_end))
324 return basename.substr(0, arg_start);
325
326 return basename;
327 }
328
ContainsPath(llvm::StringRef path)329 bool CPlusPlusLanguage::MethodName::ContainsPath(llvm::StringRef path) {
330 if (!m_parsed)
331 Parse();
332
333 // If we can't parse the incoming name, then just check that it contains path.
334 if (m_parse_error)
335 return m_full.GetStringRef().contains(path);
336
337 llvm::StringRef identifier;
338 llvm::StringRef context;
339 std::string path_str = path.str();
340 bool success = CPlusPlusLanguage::ExtractContextAndIdentifier(
341 path_str.c_str(), context, identifier);
342 if (!success)
343 return m_full.GetStringRef().contains(path);
344
345 // Basename may include template arguments.
346 // E.g.,
347 // GetBaseName(): func<int>
348 // identifier : func
349 //
350 // ...but we still want to account for identifiers with template parameter
351 // lists, e.g., when users set breakpoints on template specializations.
352 //
353 // E.g.,
354 // GetBaseName(): func<uint32_t>
355 // identifier : func<int32_t*>
356 //
357 // Try to match the basename with or without template parameters.
358 if (GetBasename() != identifier &&
359 GetBasenameNoTemplateParameters() != identifier)
360 return false;
361
362 // Incoming path only had an identifier, so we match.
363 if (context.empty())
364 return true;
365 // Incoming path has context but this method does not, no match.
366 if (m_context.empty())
367 return false;
368
369 llvm::StringRef haystack = m_context;
370 if (!haystack.consume_back(context))
371 return false;
372 if (haystack.empty() || !isalnum(haystack.back()))
373 return true;
374
375 return false;
376 }
377
IsCPPMangledName(llvm::StringRef name)378 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
379 // FIXME!! we should really run through all the known C++ Language plugins
380 // and ask each one if this is a C++ mangled name
381
382 Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
383
384 if (scheme == Mangled::eManglingSchemeNone)
385 return false;
386
387 return true;
388 }
389
DemangledNameContainsPath(llvm::StringRef path,ConstString demangled) const390 bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path,
391 ConstString demangled) const {
392 MethodName demangled_name(demangled);
393 return demangled_name.ContainsPath(path);
394 }
395
ExtractContextAndIdentifier(const char * name,llvm::StringRef & context,llvm::StringRef & identifier)396 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
397 const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
398 if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
399 return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context,
400 identifier);
401
402 CPlusPlusNameParser parser(name);
403 if (auto full_name = parser.ParseAsFullName()) {
404 identifier = full_name->basename;
405 context = full_name->context;
406 return true;
407 }
408 return false;
409 }
410
411 namespace {
412 class NodeAllocator {
413 llvm::BumpPtrAllocator Alloc;
414
415 public:
reset()416 void reset() { Alloc.Reset(); }
417
418 template <typename T, typename... Args> T *makeNode(Args &&... args) {
419 return new (Alloc.Allocate(sizeof(T), alignof(T)))
420 T(std::forward<Args>(args)...);
421 }
422
allocateNodeArray(size_t sz)423 void *allocateNodeArray(size_t sz) {
424 return Alloc.Allocate(sizeof(llvm::itanium_demangle::Node *) * sz,
425 alignof(llvm::itanium_demangle::Node *));
426 }
427 };
428
429 template <typename Derived>
430 class ManglingSubstitutor
431 : public llvm::itanium_demangle::AbstractManglingParser<Derived,
432 NodeAllocator> {
433 using Base =
434 llvm::itanium_demangle::AbstractManglingParser<Derived, NodeAllocator>;
435
436 public:
ManglingSubstitutor()437 ManglingSubstitutor() : Base(nullptr, nullptr) {}
438
439 template <typename... Ts>
substitute(llvm::StringRef Mangled,Ts &&...Vals)440 ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) {
441 this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...);
442 return substituteImpl(Mangled);
443 }
444
445 protected:
reset(llvm::StringRef Mangled)446 void reset(llvm::StringRef Mangled) {
447 Base::reset(Mangled.begin(), Mangled.end());
448 Written = Mangled.begin();
449 Result.clear();
450 Substituted = false;
451 }
452
substituteImpl(llvm::StringRef Mangled)453 ConstString substituteImpl(llvm::StringRef Mangled) {
454 Log *log = GetLog(LLDBLog::Language);
455 if (this->parse() == nullptr) {
456 LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled);
457 return ConstString();
458 }
459 if (!Substituted)
460 return ConstString();
461
462 // Append any trailing unmodified input.
463 appendUnchangedInput();
464 LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result);
465 return ConstString(Result);
466 }
467
trySubstitute(llvm::StringRef From,llvm::StringRef To)468 void trySubstitute(llvm::StringRef From, llvm::StringRef To) {
469 if (!llvm::StringRef(currentParserPos(), this->numLeft()).starts_with(From))
470 return;
471
472 // We found a match. Append unmodified input up to this point.
473 appendUnchangedInput();
474
475 // And then perform the replacement.
476 Result += To;
477 Written += From.size();
478 Substituted = true;
479 }
480
481 private:
482 /// Input character until which we have constructed the respective output
483 /// already.
484 const char *Written = "";
485
486 llvm::SmallString<128> Result;
487
488 /// Whether we have performed any substitutions.
489 bool Substituted = false;
490
currentParserPos() const491 const char *currentParserPos() const { return this->First; }
492
appendUnchangedInput()493 void appendUnchangedInput() {
494 Result +=
495 llvm::StringRef(Written, std::distance(Written, currentParserPos()));
496 Written = currentParserPos();
497 }
498 };
499
500 /// Given a mangled function `Mangled`, replace all the primitive function type
501 /// arguments of `Search` with type `Replace`.
502 class TypeSubstitutor : public ManglingSubstitutor<TypeSubstitutor> {
503 llvm::StringRef Search;
504 llvm::StringRef Replace;
505
506 public:
reset(llvm::StringRef Mangled,llvm::StringRef Search,llvm::StringRef Replace)507 void reset(llvm::StringRef Mangled, llvm::StringRef Search,
508 llvm::StringRef Replace) {
509 ManglingSubstitutor::reset(Mangled);
510 this->Search = Search;
511 this->Replace = Replace;
512 }
513
parseType()514 llvm::itanium_demangle::Node *parseType() {
515 trySubstitute(Search, Replace);
516 return ManglingSubstitutor::parseType();
517 }
518 };
519
520 class CtorDtorSubstitutor : public ManglingSubstitutor<CtorDtorSubstitutor> {
521 public:
522 llvm::itanium_demangle::Node *
parseCtorDtorName(llvm::itanium_demangle::Node * & SoFar,NameState * State)523 parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *State) {
524 trySubstitute("C1", "C2");
525 trySubstitute("D1", "D2");
526 return ManglingSubstitutor::parseCtorDtorName(SoFar, State);
527 }
528 };
529 } // namespace
530
GenerateAlternateFunctionManglings(const ConstString mangled_name) const531 std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings(
532 const ConstString mangled_name) const {
533 std::vector<ConstString> alternates;
534
535 /// Get a basic set of alternative manglings for the given symbol `name`, by
536 /// making a few basic possible substitutions on basic types, storage duration
537 /// and `const`ness for the given symbol. The output parameter `alternates`
538 /// is filled with a best-guess, non-exhaustive set of different manglings
539 /// for the given name.
540
541 // Maybe we're looking for a const symbol but the debug info told us it was
542 // non-const...
543 if (!strncmp(mangled_name.GetCString(), "_ZN", 3) &&
544 strncmp(mangled_name.GetCString(), "_ZNK", 4)) {
545 std::string fixed_scratch("_ZNK");
546 fixed_scratch.append(mangled_name.GetCString() + 3);
547 alternates.push_back(ConstString(fixed_scratch));
548 }
549
550 // Maybe we're looking for a static symbol but we thought it was global...
551 if (!strncmp(mangled_name.GetCString(), "_Z", 2) &&
552 strncmp(mangled_name.GetCString(), "_ZL", 3)) {
553 std::string fixed_scratch("_ZL");
554 fixed_scratch.append(mangled_name.GetCString() + 2);
555 alternates.push_back(ConstString(fixed_scratch));
556 }
557
558 TypeSubstitutor TS;
559 // `char` is implementation defined as either `signed` or `unsigned`. As a
560 // result a char parameter has 3 possible manglings: 'c'-char, 'a'-signed
561 // char, 'h'-unsigned char. If we're looking for symbols with a signed char
562 // parameter, try finding matches which have the general case 'c'.
563 if (ConstString char_fixup =
564 TS.substitute(mangled_name.GetStringRef(), "a", "c"))
565 alternates.push_back(char_fixup);
566
567 // long long parameter mangling 'x', may actually just be a long 'l' argument
568 if (ConstString long_fixup =
569 TS.substitute(mangled_name.GetStringRef(), "x", "l"))
570 alternates.push_back(long_fixup);
571
572 // unsigned long long parameter mangling 'y', may actually just be unsigned
573 // long 'm' argument
574 if (ConstString ulong_fixup =
575 TS.substitute(mangled_name.GetStringRef(), "y", "m"))
576 alternates.push_back(ulong_fixup);
577
578 if (ConstString ctor_fixup =
579 CtorDtorSubstitutor().substitute(mangled_name.GetStringRef()))
580 alternates.push_back(ctor_fixup);
581
582 return alternates;
583 }
584
FindBestAlternateFunctionMangledName(const Mangled mangled,const SymbolContext & sym_ctx) const585 ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
586 const Mangled mangled, const SymbolContext &sym_ctx) const {
587 ConstString demangled = mangled.GetDemangledName();
588 if (!demangled)
589 return ConstString();
590
591 CPlusPlusLanguage::MethodName cpp_name(demangled);
592 std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
593
594 if (!scope_qualified_name.size())
595 return ConstString();
596
597 if (!sym_ctx.module_sp)
598 return ConstString();
599
600 lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile();
601 if (!sym_file)
602 return ConstString();
603
604 std::vector<ConstString> alternates;
605 sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
606
607 std::vector<ConstString> param_and_qual_matches;
608 std::vector<ConstString> param_matches;
609 for (size_t i = 0; i < alternates.size(); i++) {
610 ConstString alternate_mangled_name = alternates[i];
611 Mangled mangled(alternate_mangled_name);
612 ConstString demangled = mangled.GetDemangledName();
613
614 CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
615 if (!cpp_name.IsValid())
616 continue;
617
618 if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
619 if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
620 param_and_qual_matches.push_back(alternate_mangled_name);
621 else
622 param_matches.push_back(alternate_mangled_name);
623 }
624 }
625
626 if (param_and_qual_matches.size())
627 return param_and_qual_matches[0]; // It is assumed that there will be only
628 // one!
629 else if (param_matches.size())
630 return param_matches[0]; // Return one of them as a best match
631 else
632 return ConstString();
633 }
634
LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp)635 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
636 if (!cpp_category_sp)
637 return;
638
639 TypeSummaryImpl::Flags stl_summary_flags;
640 stl_summary_flags.SetCascades(true)
641 .SetSkipPointers(false)
642 .SetSkipReferences(false)
643 .SetDontShowChildren(true)
644 .SetDontShowValue(true)
645 .SetShowMembersOneLiner(false)
646 .SetHideItemNames(false);
647
648 AddCXXSummary(cpp_category_sp,
649 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
650 "std::string summary provider", "^std::__[[:alnum:]]+::string$",
651 stl_summary_flags, true);
652 AddCXXSummary(cpp_category_sp,
653 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
654 "std::string summary provider",
655 "^std::__[[:alnum:]]+::basic_string<char, "
656 "std::__[[:alnum:]]+::char_traits<char>, "
657 "std::__[[:alnum:]]+::allocator<char> >$",
658 stl_summary_flags, true);
659 AddCXXSummary(cpp_category_sp,
660 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
661 "std::string summary provider",
662 "^std::__[[:alnum:]]+::basic_string<unsigned char, "
663 "std::__[[:alnum:]]+::char_traits<unsigned char>, "
664 "std::__[[:alnum:]]+::allocator<unsigned char> >$",
665 stl_summary_flags, true);
666
667 AddCXXSummary(cpp_category_sp,
668 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
669 "std::u16string summary provider",
670 "^std::__[[:alnum:]]+::basic_string<char16_t, "
671 "std::__[[:alnum:]]+::char_traits<char16_t>, "
672 "std::__[[:alnum:]]+::allocator<char16_t> >$",
673 stl_summary_flags, true);
674
675 AddCXXSummary(cpp_category_sp,
676 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
677 "std::u32string summary provider",
678 "^std::__[[:alnum:]]+::basic_string<char32_t, "
679 "std::__[[:alnum:]]+::char_traits<char32_t>, "
680 "std::__[[:alnum:]]+::allocator<char32_t> >$",
681 stl_summary_flags, true);
682
683 AddCXXSummary(cpp_category_sp,
684 lldb_private::formatters::LibcxxWStringSummaryProvider,
685 "std::wstring summary provider",
686 "^std::__[[:alnum:]]+::wstring$", stl_summary_flags, true);
687 AddCXXSummary(cpp_category_sp,
688 lldb_private::formatters::LibcxxWStringSummaryProvider,
689 "std::wstring summary provider",
690 "^std::__[[:alnum:]]+::basic_string<wchar_t, "
691 "std::__[[:alnum:]]+::char_traits<wchar_t>, "
692 "std::__[[:alnum:]]+::allocator<wchar_t> >$",
693 stl_summary_flags, true);
694
695 AddCXXSummary(cpp_category_sp,
696 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
697 "std::string_view summary provider",
698 "^std::__[[:alnum:]]+::string_view$", stl_summary_flags, true);
699 AddCXXSummary(cpp_category_sp,
700 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
701 "std::string_view summary provider",
702 "^std::__[[:alnum:]]+::basic_string_view<char, "
703 "std::__[[:alnum:]]+::char_traits<char> >$",
704 stl_summary_flags, true);
705 AddCXXSummary(cpp_category_sp,
706 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
707 "std::string_view summary provider",
708 "^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
709 "std::__[[:alnum:]]+::char_traits<unsigned char> >$",
710 stl_summary_flags, true);
711
712 AddCXXSummary(cpp_category_sp,
713 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF16,
714 "std::u16string_view summary provider",
715 "^std::__[[:alnum:]]+::basic_string_view<char16_t, "
716 "std::__[[:alnum:]]+::char_traits<char16_t> >$",
717 stl_summary_flags, true);
718
719 AddCXXSummary(cpp_category_sp,
720 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF32,
721 "std::u32string_view summary provider",
722 "^std::__[[:alnum:]]+::basic_string_view<char32_t, "
723 "std::__[[:alnum:]]+::char_traits<char32_t> >$",
724 stl_summary_flags, true);
725
726 AddCXXSummary(cpp_category_sp,
727 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
728 "std::wstring_view summary provider",
729 "^std::__[[:alnum:]]+::wstring_view$", stl_summary_flags, true);
730 AddCXXSummary(cpp_category_sp,
731 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
732 "std::wstring_view summary provider",
733 "^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
734 "std::__[[:alnum:]]+::char_traits<wchar_t> >$",
735 stl_summary_flags, true);
736
737 SyntheticChildren::Flags stl_synth_flags;
738 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
739 false);
740 SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
741 stl_deref_flags.SetFrontEndWantsDereference();
742
743 AddCXXSynthetic(
744 cpp_category_sp,
745 lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
746 "libc++ std::bitset synthetic children",
747 "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_deref_flags, true);
748 AddCXXSynthetic(
749 cpp_category_sp,
750 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
751 "libc++ std::vector synthetic children",
752 "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_deref_flags, true);
753 AddCXXSynthetic(
754 cpp_category_sp,
755 lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
756 "libc++ std::forward_list synthetic children",
757 "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$", stl_synth_flags, true);
758 AddCXXSynthetic(
759 cpp_category_sp,
760 lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
761 "libc++ std::list synthetic children",
762 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
763 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
764 "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
765 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$",
766 stl_deref_flags, true);
767 AddCXXSynthetic(
768 cpp_category_sp,
769 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
770 "libc++ std::map synthetic children",
771 "^std::__[[:alnum:]]+::map<.+> >(( )?&)?$", stl_synth_flags, true);
772 AddCXXSynthetic(
773 cpp_category_sp,
774 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
775 "libc++ std::set synthetic children",
776 "^std::__[[:alnum:]]+::set<.+> >(( )?&)?$", stl_deref_flags, true);
777 AddCXXSynthetic(
778 cpp_category_sp,
779 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
780 "libc++ std::multiset synthetic children",
781 "^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$", stl_deref_flags, true);
782 AddCXXSynthetic(
783 cpp_category_sp,
784 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
785 "libc++ std::multimap synthetic children",
786 "^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$", stl_synth_flags, true);
787 AddCXXSynthetic(
788 cpp_category_sp,
789 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
790 "libc++ std::unordered containers synthetic children",
791 "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$",
792 stl_synth_flags, true);
793 AddCXXSynthetic(
794 cpp_category_sp,
795 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
796 "libc++ std::initializer_list synthetic children",
797 "^std::initializer_list<.+>(( )?&)?$", stl_synth_flags, true);
798 AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
799 "libc++ std::queue synthetic children",
800 "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_synth_flags,
801 true);
802 AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
803 "libc++ std::tuple synthetic children",
804 "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_synth_flags,
805 true);
806 AddCXXSynthetic(cpp_category_sp, LibcxxOptionalSyntheticFrontEndCreator,
807 "libc++ std::optional synthetic children",
808 "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$",
809 stl_synth_flags, true);
810 AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
811 "libc++ std::variant synthetic children",
812 "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_synth_flags,
813 true);
814 AddCXXSynthetic(
815 cpp_category_sp,
816 lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
817 "libc++ std::atomic synthetic children",
818 "^std::__[[:alnum:]]+::atomic<.+>$", stl_synth_flags, true);
819 AddCXXSynthetic(
820 cpp_category_sp,
821 lldb_private::formatters::LibcxxStdSpanSyntheticFrontEndCreator,
822 "libc++ std::span synthetic children",
823 "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_deref_flags, true);
824 AddCXXSynthetic(
825 cpp_category_sp,
826 lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEndCreator,
827 "libc++ std::ranges::ref_view synthetic children",
828 "^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$", stl_deref_flags,
829 true);
830
831 cpp_category_sp->AddTypeSynthetic(
832 "^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$", eFormatterMatchRegex,
833 SyntheticChildrenSP(new ScriptedSyntheticChildren(
834 stl_synth_flags,
835 "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
836
837 AddCXXSynthetic(
838 cpp_category_sp,
839 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
840 "shared_ptr synthetic children",
841 "^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$", stl_synth_flags, true);
842
843 static constexpr const char *const libcxx_std_unique_ptr_regex =
844 "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$";
845 AddCXXSynthetic(
846 cpp_category_sp,
847 lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEndCreator,
848 "unique_ptr synthetic children", libcxx_std_unique_ptr_regex,
849 stl_synth_flags, true);
850
851 AddCXXSynthetic(
852 cpp_category_sp,
853 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
854 "weak_ptr synthetic children",
855 "^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$", stl_synth_flags, true);
856 AddCXXSummary(cpp_category_sp,
857 lldb_private::formatters::LibcxxFunctionSummaryProvider,
858 "libc++ std::function summary provider",
859 "^std::__[[:alnum:]]+::function<.+>$", stl_summary_flags, true);
860
861 static constexpr const char *const libcxx_std_coroutine_handle_regex =
862 "^std::__[[:alnum:]]+::coroutine_handle<.+>(( )?&)?$";
863 AddCXXSynthetic(
864 cpp_category_sp,
865 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator,
866 "coroutine_handle synthetic children", libcxx_std_coroutine_handle_regex,
867 stl_deref_flags, true);
868
869 stl_summary_flags.SetDontShowChildren(false);
870 stl_summary_flags.SetSkipPointers(false);
871 AddCXXSummary(
872 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
873 "libc++ std::bitset summary provider",
874 "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_summary_flags, true);
875 AddCXXSummary(
876 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
877 "libc++ std::vector summary provider",
878 "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_summary_flags, true);
879 AddCXXSummary(cpp_category_sp,
880 lldb_private::formatters::LibcxxContainerSummaryProvider,
881 "libc++ std::list summary provider",
882 "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$",
883 stl_summary_flags, true);
884 AddCXXSummary(
885 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
886 "libc++ std::list summary provider",
887 // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
888 // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
889 "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
890 "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$",
891 stl_summary_flags, true);
892 AddCXXSummary(
893 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
894 "libc++ std::map summary provider",
895 "^std::__[[:alnum:]]+::map<.+>(( )?&)?$", stl_summary_flags, true);
896 AddCXXSummary(
897 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
898 "libc++ std::deque summary provider",
899 "^std::__[[:alnum:]]+::deque<.+>(( )?&)?$", stl_summary_flags, true);
900 AddCXXSummary(
901 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
902 "libc++ std::queue summary provider",
903 "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_summary_flags, true);
904 AddCXXSummary(
905 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
906 "libc++ std::set summary provider",
907 "^std::__[[:alnum:]]+::set<.+>(( )?&)?$", stl_summary_flags, true);
908 AddCXXSummary(
909 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
910 "libc++ std::multiset summary provider",
911 "^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$", stl_summary_flags, true);
912 AddCXXSummary(
913 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
914 "libc++ std::multimap summary provider",
915 "^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$", stl_summary_flags, true);
916 AddCXXSummary(cpp_category_sp,
917 lldb_private::formatters::LibcxxContainerSummaryProvider,
918 "libc++ std::unordered containers summary provider",
919 "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$",
920 stl_summary_flags, true);
921 AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
922 "libc++ std::tuple summary provider",
923 "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_summary_flags,
924 true);
925 AddCXXSummary(cpp_category_sp,
926 lldb_private::formatters::LibCxxAtomicSummaryProvider,
927 "libc++ std::atomic summary provider",
928 "^std::__[[:alnum:]]+::atomic<.+>$", stl_summary_flags, true);
929 AddCXXSummary(
930 cpp_category_sp, lldb_private::formatters::GenericOptionalSummaryProvider,
931 "libc++ std::optional summary provider",
932 "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$", stl_summary_flags, true);
933 AddCXXSummary(
934 cpp_category_sp, lldb_private::formatters::LibcxxVariantSummaryProvider,
935 "libc++ std::variant summary provider",
936 "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_summary_flags, true);
937 AddCXXSummary(
938 cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
939 "libc++ std::span summary provider",
940 "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_summary_flags, true);
941
942 stl_summary_flags.SetSkipPointers(true);
943
944 AddCXXSummary(cpp_category_sp,
945 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
946 "libc++ std::shared_ptr summary provider",
947 "^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$",
948 stl_summary_flags, true);
949 AddCXXSummary(cpp_category_sp,
950 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
951 "libc++ std::weak_ptr summary provider",
952 "^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$",
953 stl_summary_flags, true);
954 AddCXXSummary(cpp_category_sp,
955 lldb_private::formatters::LibcxxUniquePointerSummaryProvider,
956 "libc++ std::unique_ptr summary provider",
957 libcxx_std_unique_ptr_regex, stl_summary_flags, true);
958
959 AddCXXSummary(cpp_category_sp,
960 lldb_private::formatters::StdlibCoroutineHandleSummaryProvider,
961 "libc++ std::coroutine_handle summary provider",
962 libcxx_std_coroutine_handle_regex, stl_summary_flags, true);
963
964 AddCXXSynthetic(
965 cpp_category_sp,
966 lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
967 "std::vector iterator synthetic children",
968 "^std::__[[:alnum:]]+::__wrap_iter<.+>$", stl_synth_flags, true);
969
970 AddCXXSynthetic(
971 cpp_category_sp,
972 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
973 "std::map iterator synthetic children",
974 "^std::__[[:alnum:]]+::__map_(const_)?iterator<.+>$", stl_synth_flags,
975 true);
976
977 AddCXXSynthetic(cpp_category_sp,
978 lldb_private::formatters::
979 LibCxxUnorderedMapIteratorSyntheticFrontEndCreator,
980 "std::unordered_map iterator synthetic children",
981 "^std::__[[:alnum:]]+::__hash_map_(const_)?iterator<.+>$",
982 stl_synth_flags, true);
983 // Chrono duration typedefs
984 cpp_category_sp->AddTypeSummary(
985 "^std::__[[:alnum:]]+::chrono::nanoseconds", eFormatterMatchRegex,
986 TypeSummaryImplSP(new StringSummaryFormat(
987 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} ns")));
988 cpp_category_sp->AddTypeSummary(
989 "^std::__[[:alnum:]]+::chrono::microseconds", eFormatterMatchRegex,
990 TypeSummaryImplSP(new StringSummaryFormat(
991 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} µs")));
992 cpp_category_sp->AddTypeSummary(
993 "^std::__[[:alnum:]]+::chrono::milliseconds", eFormatterMatchRegex,
994 TypeSummaryImplSP(new StringSummaryFormat(
995 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} ms")));
996 cpp_category_sp->AddTypeSummary(
997 "^std::__[[:alnum:]]+::chrono::seconds", eFormatterMatchRegex,
998 TypeSummaryImplSP(new StringSummaryFormat(
999 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} s")));
1000 cpp_category_sp->AddTypeSummary(
1001 "^std::__[[:alnum:]]+::chrono::minutes", eFormatterMatchRegex,
1002 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1003 eTypeOptionHideValue,
1004 "${var.__rep_} min")));
1005 cpp_category_sp->AddTypeSummary(
1006 "^std::__[[:alnum:]]+::chrono::hours", eFormatterMatchRegex,
1007 TypeSummaryImplSP(new StringSummaryFormat(
1008 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} h")));
1009
1010 cpp_category_sp->AddTypeSummary(
1011 "^std::__[[:alnum:]]+::chrono::days", eFormatterMatchRegex,
1012 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1013 eTypeOptionHideValue,
1014 "${var.__rep_} days")));
1015 cpp_category_sp->AddTypeSummary(
1016 "^std::__[[:alnum:]]+::chrono::weeks", eFormatterMatchRegex,
1017 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1018 eTypeOptionHideValue,
1019 "${var.__rep_} weeks")));
1020 cpp_category_sp->AddTypeSummary(
1021 "^std::__[[:alnum:]]+::chrono::months", eFormatterMatchRegex,
1022 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1023 eTypeOptionHideValue,
1024 "${var.__rep_} months")));
1025 cpp_category_sp->AddTypeSummary(
1026 "^std::__[[:alnum:]]+::chrono::years", eFormatterMatchRegex,
1027 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1028 eTypeOptionHideValue,
1029 "${var.__rep_} years")));
1030 cpp_category_sp->AddTypeSummary(
1031 "^std::__[[:alnum:]]+::chrono::seconds", eFormatterMatchRegex,
1032 TypeSummaryImplSP(new StringSummaryFormat(
1033 eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} s")));
1034
1035 // Chrono time point types
1036
1037 AddCXXSummary(cpp_category_sp,
1038 lldb_private::formatters::LibcxxChronoSysSecondsSummaryProvider,
1039 "libc++ std::chrono::sys_seconds summary provider",
1040 "^std::__[[:alnum:]]+::chrono::time_point<"
1041 "std::__[[:alnum:]]+::chrono::system_clock, "
1042 "std::__[[:alnum:]]+::chrono::duration<long long, "
1043 "std::__[[:alnum:]]+::ratio<1, 1> "
1044 "> >$",
1045 eTypeOptionHideChildren | eTypeOptionHideValue |
1046 eTypeOptionCascade,
1047 true);
1048 AddCXXSummary(cpp_category_sp,
1049 lldb_private::formatters::LibcxxChronoSysDaysSummaryProvider,
1050 "libc++ std::chrono::sys_seconds summary provider",
1051 "^std::__[[:alnum:]]+::chrono::time_point<"
1052 "std::__[[:alnum:]]+::chrono::system_clock, "
1053 "std::__[[:alnum:]]+::chrono::duration<int, "
1054 "std::__[[:alnum:]]+::ratio<86400, 1> "
1055 "> >$",
1056 eTypeOptionHideChildren | eTypeOptionHideValue |
1057 eTypeOptionCascade,
1058 true);
1059
1060 // Chrono calendar types
1061
1062 cpp_category_sp->AddTypeSummary(
1063 "^std::__[[:alnum:]]+::chrono::day$", eFormatterMatchRegex,
1064 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1065 eTypeOptionHideValue,
1066 "day=${var.__d_%u}")));
1067
1068 AddCXXSummary(cpp_category_sp,
1069 lldb_private::formatters::LibcxxChronoMonthSummaryProvider,
1070 "libc++ std::chrono::month summary provider",
1071 "^std::__[[:alnum:]]+::chrono::month$",
1072 eTypeOptionHideChildren | eTypeOptionHideValue, true);
1073
1074 cpp_category_sp->AddTypeSummary(
1075 "^std::__[[:alnum:]]+::chrono::year$", eFormatterMatchRegex,
1076 TypeSummaryImplSP(new StringSummaryFormat(
1077 eTypeOptionHideChildren | eTypeOptionHideValue, "year=${var.__y_}")));
1078
1079 AddCXXSummary(cpp_category_sp,
1080 lldb_private::formatters::LibcxxChronoWeekdaySummaryProvider,
1081 "libc++ std::chrono::weekday summary provider",
1082 "^std::__[[:alnum:]]+::chrono::weekday$",
1083 eTypeOptionHideChildren | eTypeOptionHideValue, true);
1084
1085 cpp_category_sp->AddTypeSummary(
1086 "^std::__[[:alnum:]]+::chrono::weekday_indexed$", eFormatterMatchRegex,
1087 TypeSummaryImplSP(new StringSummaryFormat(
1088 eTypeOptionHideChildren | eTypeOptionHideValue,
1089 "${var.__wd_} index=${var.__idx_%u}")));
1090
1091 cpp_category_sp->AddTypeSummary(
1092 "^std::__[[:alnum:]]+::chrono::weekday_last$", eFormatterMatchRegex,
1093 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1094 eTypeOptionHideValue,
1095 "${var.__wd_} index=last")));
1096 cpp_category_sp->AddTypeSummary(
1097 "^std::__[[:alnum:]]+::chrono::month_day$", eFormatterMatchRegex,
1098 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1099 eTypeOptionHideValue,
1100 "${var.__m_} ${var.__d_}")));
1101 cpp_category_sp->AddTypeSummary(
1102 "^std::__[[:alnum:]]+::chrono::month_day_last$", eFormatterMatchRegex,
1103 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1104 eTypeOptionHideValue,
1105 "${var.__m_} day=last")));
1106
1107 cpp_category_sp->AddTypeSummary(
1108 "^std::__[[:alnum:]]+::chrono::month_weekday$", eFormatterMatchRegex,
1109 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1110 eTypeOptionHideValue,
1111 "${var.__m_} ${var.__wdi_}")));
1112
1113 cpp_category_sp->AddTypeSummary(
1114 "^std::__[[:alnum:]]+::chrono::month_weekday_last$", eFormatterMatchRegex,
1115 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1116 eTypeOptionHideValue,
1117 "${var.__m_} ${var.__wdl_}")));
1118
1119 cpp_category_sp->AddTypeSummary(
1120 "^std::__[[:alnum:]]+::chrono::year_month$", eFormatterMatchRegex,
1121 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1122 eTypeOptionHideValue,
1123 "${var.__y_} ${var.__m_}")));
1124
1125 AddCXXSummary(
1126 cpp_category_sp,
1127 lldb_private::formatters::LibcxxChronoYearMonthDaySummaryProvider,
1128 "libc++ std::chrono::year_month_day summary provider",
1129 "^std::__[[:alnum:]]+::chrono::year_month_day$",
1130 eTypeOptionHideChildren | eTypeOptionHideValue, true);
1131
1132 cpp_category_sp->AddTypeSummary(
1133 "^std::__[[:alnum:]]+::chrono::year_month_day_last$",
1134 eFormatterMatchRegex,
1135 TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren |
1136 eTypeOptionHideValue,
1137 "${var.__y_} ${var.__mdl_}")));
1138
1139 cpp_category_sp->AddTypeSummary(
1140 "^std::__[[:alnum:]]+::chrono::year_month_weekday$", eFormatterMatchRegex,
1141 TypeSummaryImplSP(new StringSummaryFormat(
1142 eTypeOptionHideChildren | eTypeOptionHideValue,
1143 "${var.__y_} ${var.__m_} ${var.__wdi_}")));
1144
1145 cpp_category_sp->AddTypeSummary(
1146 "^std::__[[:alnum:]]+::chrono::year_month_weekday_last$",
1147 eFormatterMatchRegex,
1148 TypeSummaryImplSP(new StringSummaryFormat(
1149 eTypeOptionHideChildren | eTypeOptionHideValue,
1150 "${var.__y_} ${var.__m_} ${var.__wdl_}")));
1151 }
1152
LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp)1153 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
1154 if (!cpp_category_sp)
1155 return;
1156
1157 TypeSummaryImpl::Flags stl_summary_flags;
1158 stl_summary_flags.SetCascades(true)
1159 .SetSkipPointers(false)
1160 .SetSkipReferences(false)
1161 .SetDontShowChildren(true)
1162 .SetDontShowValue(true)
1163 .SetShowMembersOneLiner(false)
1164 .SetHideItemNames(false);
1165
1166 lldb::TypeSummaryImplSP std_string_summary_sp(
1167 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}"));
1168
1169 lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat(
1170 stl_summary_flags, LibStdcppStringSummaryProvider,
1171 "libstdc++ c++11 std::string summary provider"));
1172 lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat(
1173 stl_summary_flags, LibStdcppWStringSummaryProvider,
1174 "libstdc++ c++11 std::wstring summary provider"));
1175
1176 cpp_category_sp->AddTypeSummary("std::string", eFormatterMatchExact,
1177 std_string_summary_sp);
1178 cpp_category_sp->AddTypeSummary("std::basic_string<char>",
1179 eFormatterMatchExact, std_string_summary_sp);
1180 cpp_category_sp->AddTypeSummary(
1181 "std::basic_string<char,std::char_traits<char>,std::allocator<char> >",
1182 eFormatterMatchExact, std_string_summary_sp);
1183 cpp_category_sp->AddTypeSummary(
1184 "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
1185 eFormatterMatchExact, std_string_summary_sp);
1186
1187 cpp_category_sp->AddTypeSummary("std::__cxx11::string", eFormatterMatchExact,
1188 cxx11_string_summary_sp);
1189 cpp_category_sp->AddTypeSummary(
1190 "std::__cxx11::basic_string<char, std::char_traits<char>, "
1191 "std::allocator<char> >",
1192 eFormatterMatchExact, cxx11_string_summary_sp);
1193 cpp_category_sp->AddTypeSummary("std::__cxx11::basic_string<unsigned char, "
1194 "std::char_traits<unsigned char>, "
1195 "std::allocator<unsigned char> >",
1196 eFormatterMatchExact,
1197 cxx11_string_summary_sp);
1198
1199 // making sure we force-pick the summary for printing wstring (_M_p is a
1200 // wchar_t*)
1201 lldb::TypeSummaryImplSP std_wstring_summary_sp(
1202 new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}"));
1203
1204 cpp_category_sp->AddTypeSummary("std::wstring", eFormatterMatchExact,
1205 std_wstring_summary_sp);
1206 cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t>",
1207 eFormatterMatchExact, std_wstring_summary_sp);
1208 cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t,std::char_traits<"
1209 "wchar_t>,std::allocator<wchar_t> >",
1210 eFormatterMatchExact, std_wstring_summary_sp);
1211 cpp_category_sp->AddTypeSummary(
1212 "std::basic_string<wchar_t, std::char_traits<wchar_t>, "
1213 "std::allocator<wchar_t> >",
1214 eFormatterMatchExact, std_wstring_summary_sp);
1215
1216 cpp_category_sp->AddTypeSummary("std::__cxx11::wstring", eFormatterMatchExact,
1217 cxx11_wstring_summary_sp);
1218 cpp_category_sp->AddTypeSummary(
1219 "std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, "
1220 "std::allocator<wchar_t> >",
1221 eFormatterMatchExact, cxx11_wstring_summary_sp);
1222
1223 SyntheticChildren::Flags stl_synth_flags;
1224 stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
1225 false);
1226 SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
1227 stl_deref_flags.SetFrontEndWantsDereference();
1228
1229 cpp_category_sp->AddTypeSynthetic(
1230 "^std::vector<.+>(( )?&)?$", eFormatterMatchRegex,
1231 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1232 stl_synth_flags,
1233 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
1234 cpp_category_sp->AddTypeSynthetic(
1235 "^std::map<.+> >(( )?&)?$", eFormatterMatchRegex,
1236 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1237 stl_synth_flags,
1238 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1239 cpp_category_sp->AddTypeSynthetic(
1240 "^std::deque<.+>(( )?&)?$", eFormatterMatchRegex,
1241 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1242 stl_deref_flags,
1243 "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider")));
1244 cpp_category_sp->AddTypeSynthetic(
1245 "^std::set<.+> >(( )?&)?$", eFormatterMatchRegex,
1246 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1247 stl_deref_flags,
1248 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1249 cpp_category_sp->AddTypeSynthetic(
1250 "^std::multimap<.+> >(( )?&)?$", eFormatterMatchRegex,
1251 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1252 stl_deref_flags,
1253 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1254 cpp_category_sp->AddTypeSynthetic(
1255 "^std::multiset<.+> >(( )?&)?$", eFormatterMatchRegex,
1256 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1257 stl_deref_flags,
1258 "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider")));
1259 cpp_category_sp->AddTypeSynthetic(
1260 "^std::unordered_(multi)?(map|set)<.+> >$", eFormatterMatchRegex,
1261 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1262 stl_deref_flags,
1263 "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider")));
1264 cpp_category_sp->AddTypeSynthetic(
1265 "^std::(__cxx11::)?list<.+>(( )?&)?$", eFormatterMatchRegex,
1266 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1267 stl_deref_flags,
1268 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
1269 cpp_category_sp->AddTypeSynthetic(
1270 "^std::(__cxx11::)?forward_list<.+>(( )?&)?$", eFormatterMatchRegex,
1271 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1272 stl_synth_flags,
1273 "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider")));
1274 cpp_category_sp->AddTypeSynthetic(
1275 "^std::variant<.+>$", eFormatterMatchRegex,
1276 SyntheticChildrenSP(new ScriptedSyntheticChildren(
1277 stl_synth_flags,
1278 "lldb.formatters.cpp.gnu_libstdcpp.VariantSynthProvider")));
1279
1280 stl_summary_flags.SetDontShowChildren(false);
1281 stl_summary_flags.SetSkipPointers(false);
1282 cpp_category_sp->AddTypeSummary("^std::bitset<.+>(( )?&)?$",
1283 eFormatterMatchRegex,
1284 TypeSummaryImplSP(new StringSummaryFormat(
1285 stl_summary_flags, "size=${svar%#}")));
1286 cpp_category_sp->AddTypeSummary("^std::vector<.+>(( )?&)?$",
1287 eFormatterMatchRegex,
1288 TypeSummaryImplSP(new StringSummaryFormat(
1289 stl_summary_flags, "size=${svar%#}")));
1290 cpp_category_sp->AddTypeSummary("^std::map<.+> >(( )?&)?$",
1291 eFormatterMatchRegex,
1292 TypeSummaryImplSP(new StringSummaryFormat(
1293 stl_summary_flags, "size=${svar%#}")));
1294 cpp_category_sp->AddTypeSummary("^std::set<.+> >(( )?&)?$",
1295 eFormatterMatchRegex,
1296 TypeSummaryImplSP(new StringSummaryFormat(
1297 stl_summary_flags, "size=${svar%#}")));
1298 cpp_category_sp->AddTypeSummary("^std::deque<.+>(( )?&)?$",
1299 eFormatterMatchRegex,
1300 TypeSummaryImplSP(new StringSummaryFormat(
1301 stl_summary_flags, "size=${svar%#}")));
1302 cpp_category_sp->AddTypeSummary("^std::multimap<.+> >(( )?&)?$",
1303 eFormatterMatchRegex,
1304 TypeSummaryImplSP(new StringSummaryFormat(
1305 stl_summary_flags, "size=${svar%#}")));
1306 cpp_category_sp->AddTypeSummary("^std::multiset<.+> >(( )?&)?$",
1307 eFormatterMatchRegex,
1308 TypeSummaryImplSP(new StringSummaryFormat(
1309 stl_summary_flags, "size=${svar%#}")));
1310 cpp_category_sp->AddTypeSummary("^std::unordered_(multi)?(map|set)<.+> >$",
1311 eFormatterMatchRegex,
1312 TypeSummaryImplSP(new StringSummaryFormat(
1313 stl_summary_flags, "size=${svar%#}")));
1314 cpp_category_sp->AddTypeSummary("^std::(__cxx11::)?list<.+>(( )?&)?$",
1315 eFormatterMatchRegex,
1316 TypeSummaryImplSP(new StringSummaryFormat(
1317 stl_summary_flags, "size=${svar%#}")));
1318 cpp_category_sp->AddTypeSummary(
1319 "^std::(__cxx11::)?forward_list<.+>(( )?&)?$", eFormatterMatchRegex,
1320 TypeSummaryImplSP(new ScriptSummaryFormat(
1321 stl_summary_flags,
1322 "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
1323 cpp_category_sp->AddTypeSummary(
1324 "^std::variant<.+>$", eFormatterMatchRegex,
1325 TypeSummaryImplSP(new ScriptSummaryFormat(
1326 stl_summary_flags,
1327 "lldb.formatters.cpp.gnu_libstdcpp.VariantSummaryProvider")));
1328
1329 AddCXXSynthetic(
1330 cpp_category_sp,
1331 lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
1332 "std::vector iterator synthetic children",
1333 "^__gnu_cxx::__normal_iterator<.+>$", stl_synth_flags, true);
1334
1335 AddCXXSynthetic(
1336 cpp_category_sp,
1337 lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
1338 "std::map iterator synthetic children", "^std::_Rb_tree_iterator<.+>$",
1339 stl_synth_flags, true);
1340
1341 AddCXXSynthetic(
1342 cpp_category_sp,
1343 lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
1344 "std::unique_ptr synthetic children", "^std::unique_ptr<.+>(( )?&)?$",
1345 stl_synth_flags, true);
1346 AddCXXSynthetic(
1347 cpp_category_sp,
1348 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
1349 "std::shared_ptr synthetic children", "^std::shared_ptr<.+>(( )?&)?$",
1350 stl_synth_flags, true);
1351 AddCXXSynthetic(
1352 cpp_category_sp,
1353 lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
1354 "std::weak_ptr synthetic children", "^std::weak_ptr<.+>(( )?&)?$",
1355 stl_synth_flags, true);
1356 AddCXXSynthetic(
1357 cpp_category_sp,
1358 lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
1359 "std::tuple synthetic children", "^std::tuple<.+>(( )?&)?$",
1360 stl_synth_flags, true);
1361
1362 static constexpr const char *const libstdcpp_std_coroutine_handle_regex =
1363 "^std::coroutine_handle<.+>(( )?&)?$";
1364 AddCXXSynthetic(
1365 cpp_category_sp,
1366 lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator,
1367 "std::coroutine_handle synthetic children",
1368 libstdcpp_std_coroutine_handle_regex, stl_deref_flags, true);
1369
1370 AddCXXSynthetic(
1371 cpp_category_sp,
1372 lldb_private::formatters::LibStdcppBitsetSyntheticFrontEndCreator,
1373 "std::bitset synthetic child", "^std::bitset<.+>(( )?&)?$",
1374 stl_deref_flags, true);
1375
1376 AddCXXSynthetic(
1377 cpp_category_sp,
1378 lldb_private::formatters::LibStdcppOptionalSyntheticFrontEndCreator,
1379 "std::optional synthetic child", "^std::optional<.+>(( )?&)?$",
1380 stl_deref_flags, true);
1381
1382 AddCXXSummary(cpp_category_sp,
1383 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
1384 "libstdc++ std::unique_ptr summary provider",
1385 "^std::unique_ptr<.+>(( )?&)?$", stl_summary_flags, true);
1386 AddCXXSummary(cpp_category_sp,
1387 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
1388 "libstdc++ std::shared_ptr summary provider",
1389 "^std::shared_ptr<.+>(( )?&)?$", stl_summary_flags, true);
1390 AddCXXSummary(cpp_category_sp,
1391 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
1392 "libstdc++ std::weak_ptr summary provider",
1393 "^std::weak_ptr<.+>(( )?&)?$", stl_summary_flags, true);
1394 AddCXXSummary(cpp_category_sp,
1395 lldb_private::formatters::StdlibCoroutineHandleSummaryProvider,
1396 "libstdc++ std::coroutine_handle summary provider",
1397 libstdcpp_std_coroutine_handle_regex, stl_summary_flags, true);
1398 AddCXXSummary(cpp_category_sp,
1399 lldb_private::formatters::GenericOptionalSummaryProvider,
1400 "libstd++ std::optional summary provider",
1401 "^std::optional<.+>(( )?&)?$", stl_summary_flags, true);
1402 }
1403
LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp)1404 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
1405 if (!cpp_category_sp)
1406 return;
1407
1408 TypeSummaryImpl::Flags string_flags;
1409 string_flags.SetCascades(true)
1410 .SetSkipPointers(true)
1411 .SetSkipReferences(false)
1412 .SetDontShowChildren(true)
1413 .SetDontShowValue(false)
1414 .SetShowMembersOneLiner(false)
1415 .SetHideItemNames(false);
1416
1417 TypeSummaryImpl::Flags string_array_flags;
1418 string_array_flags.SetCascades(true)
1419 .SetSkipPointers(true)
1420 .SetSkipReferences(false)
1421 .SetDontShowChildren(true)
1422 .SetDontShowValue(true)
1423 .SetShowMembersOneLiner(false)
1424 .SetHideItemNames(false);
1425
1426 AddCXXSummary(cpp_category_sp,
1427 lldb_private::formatters::Char8StringSummaryProvider,
1428 "char8_t * summary provider", "char8_t *", string_flags);
1429 AddCXXSummary(cpp_category_sp,
1430 lldb_private::formatters::Char8StringSummaryProvider,
1431 "char8_t [] summary provider", "char8_t ?\\[[0-9]+\\]",
1432 string_array_flags, true);
1433
1434 AddCXXSummary(cpp_category_sp,
1435 lldb_private::formatters::Char16StringSummaryProvider,
1436 "char16_t * summary provider", "char16_t *", string_flags);
1437 AddCXXSummary(cpp_category_sp,
1438 lldb_private::formatters::Char16StringSummaryProvider,
1439 "char16_t [] summary provider", "char16_t ?\\[[0-9]+\\]",
1440 string_array_flags, true);
1441
1442 AddCXXSummary(cpp_category_sp,
1443 lldb_private::formatters::Char32StringSummaryProvider,
1444 "char32_t * summary provider", "char32_t *", string_flags);
1445 AddCXXSummary(cpp_category_sp,
1446 lldb_private::formatters::Char32StringSummaryProvider,
1447 "char32_t [] summary provider", "char32_t ?\\[[0-9]+\\]",
1448 string_array_flags, true);
1449
1450 AddCXXSummary(cpp_category_sp,
1451 lldb_private::formatters::WCharStringSummaryProvider,
1452 "wchar_t * summary provider", "wchar_t *", string_flags);
1453 AddCXXSummary(cpp_category_sp,
1454 lldb_private::formatters::WCharStringSummaryProvider,
1455 "wchar_t * summary provider", "wchar_t ?\\[[0-9]+\\]",
1456 string_array_flags, true);
1457
1458 AddCXXSummary(cpp_category_sp,
1459 lldb_private::formatters::Char16StringSummaryProvider,
1460 "unichar * summary provider", "unichar *", string_flags);
1461
1462 TypeSummaryImpl::Flags widechar_flags;
1463 widechar_flags.SetDontShowValue(true)
1464 .SetSkipPointers(true)
1465 .SetSkipReferences(false)
1466 .SetCascades(true)
1467 .SetDontShowChildren(true)
1468 .SetHideItemNames(true)
1469 .SetShowMembersOneLiner(false);
1470
1471 AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider,
1472 "char8_t summary provider", "char8_t", widechar_flags);
1473 AddCXXSummary(cpp_category_sp,
1474 lldb_private::formatters::Char16SummaryProvider,
1475 "char16_t summary provider", "char16_t", widechar_flags);
1476 AddCXXSummary(cpp_category_sp,
1477 lldb_private::formatters::Char32SummaryProvider,
1478 "char32_t summary provider", "char32_t", widechar_flags);
1479 AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
1480 "wchar_t summary provider", "wchar_t", widechar_flags);
1481
1482 AddCXXSummary(cpp_category_sp,
1483 lldb_private::formatters::Char16SummaryProvider,
1484 "unichar summary provider", "unichar", widechar_flags);
1485 }
1486
GetTypeScavenger()1487 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
1488 class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
1489 public:
1490 CompilerType AdjustForInclusion(CompilerType &candidate) override {
1491 LanguageType lang_type(candidate.GetMinimumLanguage());
1492 if (!Language::LanguageIsC(lang_type) &&
1493 !Language::LanguageIsCPlusPlus(lang_type))
1494 return CompilerType();
1495 if (candidate.IsTypedefType())
1496 return candidate.GetTypedefedType();
1497 return candidate;
1498 }
1499 };
1500
1501 return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger());
1502 }
1503
GetFormatters()1504 lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() {
1505 static llvm::once_flag g_initialize;
1506 static TypeCategoryImplSP g_category;
1507
1508 llvm::call_once(g_initialize, [this]() -> void {
1509 DataVisualization::Categories::GetCategory(ConstString(GetPluginName()),
1510 g_category);
1511 if (g_category) {
1512 LoadLibStdcppFormatters(g_category);
1513 LoadLibCxxFormatters(g_category);
1514 LoadSystemFormatters(g_category);
1515 }
1516 });
1517 return g_category;
1518 }
1519
1520 HardcodedFormatters::HardcodedSummaryFinder
GetHardcodedSummaries()1521 CPlusPlusLanguage::GetHardcodedSummaries() {
1522 static llvm::once_flag g_initialize;
1523 static ConstString g_vectortypes("VectorTypes");
1524 static HardcodedFormatters::HardcodedSummaryFinder g_formatters;
1525
1526 llvm::call_once(g_initialize, []() -> void {
1527 g_formatters.push_back(
1528 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1529 FormatManager &) -> TypeSummaryImpl::SharedPointer {
1530 static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1531 new CXXFunctionSummaryFormat(
1532 TypeSummaryImpl::Flags(),
1533 lldb_private::formatters::CXXFunctionPointerSummaryProvider,
1534 "Function pointer summary provider"));
1535 if (CompilerType CT = valobj.GetCompilerType();
1536 CT.IsFunctionPointerType() || CT.IsMemberFunctionPointerType() ||
1537 valobj.GetValueType() == lldb::eValueTypeVTableEntry) {
1538 return formatter_sp;
1539 }
1540 return nullptr;
1541 });
1542 g_formatters.push_back(
1543 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1544 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1545 static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1546 new CXXFunctionSummaryFormat(
1547 TypeSummaryImpl::Flags()
1548 .SetCascades(true)
1549 .SetDontShowChildren(true)
1550 .SetHideItemNames(true)
1551 .SetShowMembersOneLiner(true)
1552 .SetSkipPointers(true)
1553 .SetSkipReferences(false),
1554 lldb_private::formatters::VectorTypeSummaryProvider,
1555 "vector_type pointer summary provider"));
1556 if (valobj.GetCompilerType().IsVectorType()) {
1557 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1558 return formatter_sp;
1559 }
1560 return nullptr;
1561 });
1562 g_formatters.push_back(
1563 [](lldb_private::ValueObject &valobj, lldb::DynamicValueType,
1564 FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer {
1565 static CXXFunctionSummaryFormat::SharedPointer formatter_sp(
1566 new CXXFunctionSummaryFormat(
1567 TypeSummaryImpl::Flags()
1568 .SetCascades(true)
1569 .SetDontShowChildren(true)
1570 .SetHideItemNames(true)
1571 .SetShowMembersOneLiner(true)
1572 .SetSkipPointers(true)
1573 .SetSkipReferences(false),
1574 lldb_private::formatters::BlockPointerSummaryProvider,
1575 "block pointer summary provider"));
1576 if (valobj.GetCompilerType().IsBlockPointerType()) {
1577 return formatter_sp;
1578 }
1579 return nullptr;
1580 });
1581 });
1582
1583 return g_formatters;
1584 }
1585
1586 HardcodedFormatters::HardcodedSyntheticFinder
GetHardcodedSynthetics()1587 CPlusPlusLanguage::GetHardcodedSynthetics() {
1588 static llvm::once_flag g_initialize;
1589 static ConstString g_vectortypes("VectorTypes");
1590 static HardcodedFormatters::HardcodedSyntheticFinder g_formatters;
1591
1592 llvm::call_once(g_initialize, []() -> void {
1593 g_formatters.push_back([](lldb_private::ValueObject &valobj,
1594 lldb::DynamicValueType, FormatManager &fmt_mgr)
1595 -> SyntheticChildren::SharedPointer {
1596 static CXXSyntheticChildren::SharedPointer formatter_sp(
1597 new CXXSyntheticChildren(
1598 SyntheticChildren::Flags()
1599 .SetCascades(true)
1600 .SetSkipPointers(true)
1601 .SetSkipReferences(true)
1602 .SetNonCacheable(true),
1603 "vector_type synthetic children",
1604 lldb_private::formatters::VectorTypeSyntheticFrontEndCreator));
1605 if (valobj.GetCompilerType().IsVectorType()) {
1606 if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled())
1607 return formatter_sp;
1608 }
1609 return nullptr;
1610 });
1611 g_formatters.push_back([](lldb_private::ValueObject &valobj,
1612 lldb::DynamicValueType, FormatManager &fmt_mgr)
1613 -> SyntheticChildren::SharedPointer {
1614 static CXXSyntheticChildren::SharedPointer formatter_sp(
1615 new CXXSyntheticChildren(
1616 SyntheticChildren::Flags()
1617 .SetCascades(true)
1618 .SetSkipPointers(true)
1619 .SetSkipReferences(true)
1620 .SetNonCacheable(true),
1621 "block pointer synthetic children",
1622 lldb_private::formatters::BlockPointerSyntheticFrontEndCreator));
1623 if (valobj.GetCompilerType().IsBlockPointerType()) {
1624 return formatter_sp;
1625 }
1626 return nullptr;
1627 });
1628 });
1629
1630 return g_formatters;
1631 }
1632
IsNilReference(ValueObject & valobj)1633 bool CPlusPlusLanguage::IsNilReference(ValueObject &valobj) {
1634 if (!Language::LanguageIsCPlusPlus(valobj.GetObjectRuntimeLanguage()) ||
1635 !valobj.IsPointerType())
1636 return false;
1637 bool canReadValue = true;
1638 bool isZero = valobj.GetValueAsUnsigned(0, &canReadValue) == 0;
1639 return canReadValue && isZero;
1640 }
1641
IsSourceFile(llvm::StringRef file_path) const1642 bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const {
1643 const auto suffixes = {".cpp", ".cxx", ".c++", ".cc", ".c",
1644 ".h", ".hh", ".hpp", ".hxx", ".h++"};
1645 for (auto suffix : suffixes) {
1646 if (file_path.ends_with_insensitive(suffix))
1647 return true;
1648 }
1649
1650 // Check if we're in a STL path (where the files usually have no extension
1651 // that we could check for.
1652 return file_path.contains("/usr/include/c++/");
1653 }
1654
GetFunctionDisplayName(const SymbolContext * sc,const ExecutionContext * exe_ctx,FunctionNameRepresentation representation,Stream & s)1655 bool CPlusPlusLanguage::GetFunctionDisplayName(
1656 const SymbolContext *sc, const ExecutionContext *exe_ctx,
1657 FunctionNameRepresentation representation, Stream &s) {
1658 switch (representation) {
1659 case FunctionNameRepresentation::eNameWithArgs: {
1660 // Print the function name with arguments in it
1661 if (sc->function) {
1662 ExecutionContextScope *exe_scope =
1663 exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
1664 const char *cstr = sc->function->GetName().AsCString(nullptr);
1665 if (cstr) {
1666 const InlineFunctionInfo *inline_info = nullptr;
1667 VariableListSP variable_list_sp;
1668 bool get_function_vars = true;
1669 if (sc->block) {
1670 Block *inline_block = sc->block->GetContainingInlinedBlock();
1671
1672 if (inline_block) {
1673 get_function_vars = false;
1674 inline_info = inline_block->GetInlinedFunctionInfo();
1675 if (inline_info)
1676 variable_list_sp = inline_block->GetBlockVariableList(true);
1677 }
1678 }
1679
1680 if (get_function_vars) {
1681 variable_list_sp =
1682 sc->function->GetBlock(true).GetBlockVariableList(true);
1683 }
1684
1685 if (inline_info) {
1686 s.PutCString(cstr);
1687 s.PutCString(" [inlined] ");
1688 cstr = inline_info->GetName().GetCString();
1689 }
1690
1691 VariableList args;
1692 if (variable_list_sp)
1693 variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
1694 args);
1695 if (args.GetSize() > 0) {
1696 if (!PrettyPrintFunctionNameWithArgs(s, cstr, exe_scope, args))
1697 return false;
1698 } else {
1699 s.PutCString(cstr);
1700 }
1701 return true;
1702 }
1703 } else if (sc->symbol) {
1704 const char *cstr = sc->symbol->GetName().AsCString(nullptr);
1705 if (cstr) {
1706 s.PutCString(cstr);
1707 return true;
1708 }
1709 }
1710 } break;
1711 default:
1712 return false;
1713 }
1714
1715 return false;
1716 }
1717