/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
Line | Count | Source (jump to first uncovered line) |
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 | | |
54 | | LLDB_PLUGIN_DEFINE(CPlusPlusLanguage) |
55 | | |
56 | 3.98k | void CPlusPlusLanguage::Initialize() { |
57 | 3.98k | PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language", |
58 | 3.98k | CreateInstance); |
59 | 3.98k | } |
60 | | |
61 | 3.97k | void CPlusPlusLanguage::Terminate() { |
62 | 3.97k | PluginManager::UnregisterPlugin(CreateInstance); |
63 | 3.97k | } |
64 | | |
65 | 824k | bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled) const { |
66 | 824k | const char *mangled_name = mangled.GetMangledName().GetCString(); |
67 | 824k | return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name)11.6k ; |
68 | 824k | } |
69 | | |
70 | | ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments( |
71 | 377 | Mangled mangled) const { |
72 | 377 | const char *mangled_name_cstr = mangled.GetMangledName().GetCString(); |
73 | 377 | ConstString demangled_name = mangled.GetDemangledName(); |
74 | 377 | if (demangled_name && mangled_name_cstr376 && mangled_name_cstr[0]338 ) { |
75 | 338 | if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' && |
76 | 338 | (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure, |
77 | | // typeinfo structure, and typeinfo |
78 | | // mangled_name |
79 | 338 | mangled_name_cstr[2] != 'G' && // avoid guard variables |
80 | 338 | mangled_name_cstr[2] != 'Z')) // named local entities (if we |
81 | | // eventually handle eSymbolTypeData, |
82 | | // we will want this back) |
83 | 334 | { |
84 | 334 | CPlusPlusLanguage::MethodName cxx_method(demangled_name); |
85 | 334 | if (!cxx_method.GetBasename().empty()) { |
86 | 298 | std::string shortname; |
87 | 298 | if (!cxx_method.GetContext().empty()) |
88 | 178 | shortname = cxx_method.GetContext().str() + "::"; |
89 | 298 | shortname += cxx_method.GetBasename().str(); |
90 | 298 | return ConstString(shortname); |
91 | 298 | } |
92 | 334 | } |
93 | 338 | } |
94 | 79 | if (demangled_name) |
95 | 78 | return demangled_name; |
96 | 1 | return mangled.GetMangledName(); |
97 | 79 | } |
98 | | |
99 | | // Static Functions |
100 | | |
101 | 172k | Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) { |
102 | | // Use plugin for C++ but not for Objective-C++ (which has its own plugin). |
103 | 172k | if (Language::LanguageIsCPlusPlus(language) && |
104 | 172k | language != eLanguageTypeObjC_plus_plus7.82k ) |
105 | 6.71k | return new CPlusPlusLanguage(); |
106 | 165k | return nullptr; |
107 | 172k | } |
108 | | |
109 | 0 | void CPlusPlusLanguage::MethodName::Clear() { |
110 | 0 | m_full.Clear(); |
111 | 0 | m_basename = llvm::StringRef(); |
112 | 0 | m_context = llvm::StringRef(); |
113 | 0 | m_arguments = llvm::StringRef(); |
114 | 0 | m_qualifiers = llvm::StringRef(); |
115 | 0 | m_return_type = llvm::StringRef(); |
116 | 0 | m_parsed = false; |
117 | 0 | m_parse_error = false; |
118 | 0 | } |
119 | | |
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 | 669k | size_t pos = llvm::StringRef::npos) { |
124 | 669k | assert(left_right_chars.size() == 2); |
125 | 669k | left_pos = llvm::StringRef::npos; |
126 | 669k | const char left_char = left_right_chars[0]; |
127 | 669k | const char right_char = left_right_chars[1]; |
128 | 669k | pos = s.find_last_of(left_right_chars, pos); |
129 | 669k | if (pos == llvm::StringRef::npos || s[pos] == left_char6.56k ) |
130 | 662k | return false; |
131 | 6.56k | right_pos = pos; |
132 | 6.56k | uint32_t depth = 1; |
133 | 7.10k | while (pos > 0 && depth > 0) { |
134 | 7.10k | pos = s.find_last_of(left_right_chars, pos); |
135 | 7.10k | if (pos == llvm::StringRef::npos) |
136 | 0 | return false; |
137 | 7.10k | if (s[pos] == left_char) { |
138 | 6.83k | if (--depth == 0) { |
139 | 6.56k | left_pos = pos; |
140 | 6.56k | return left_pos < right_pos; |
141 | 6.56k | } |
142 | 6.83k | } else if (267 s[pos] == right_char267 ) { |
143 | 267 | ++depth; |
144 | 267 | } |
145 | 7.10k | } |
146 | 0 | return false; |
147 | 6.56k | } |
148 | | |
149 | 6.50k | 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 | 6.50k | size_t idx = 0; |
155 | 6.50k | if (basename.size() > 0 && basename[0] == '~'6.50k ) |
156 | 27 | idx = 1; |
157 | | |
158 | 6.50k | if (basename.size() <= idx) |
159 | 1 | return false; // Empty string or "~" |
160 | | |
161 | 6.50k | if (!std::isalpha(basename[idx]) && basename[idx] != '_'190 ) |
162 | 16 | 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 | 6.48k | ++idx; |
167 | 97.1k | while (idx < basename.size()) { |
168 | 91.4k | if (!std::isalnum(basename[idx]) && basename[idx] != '_'10.8k ) |
169 | 778 | break; |
170 | 90.6k | ++idx; |
171 | 90.6k | } |
172 | | |
173 | | // We processed all characters. It is a vaild basename. |
174 | 6.48k | return idx == basename.size(); |
175 | 6.50k | } |
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 |
180 | | static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream, |
181 | | char const *full_name, |
182 | | ExecutionContextScope *exe_scope, |
183 | 1.17k | VariableList const &args) { |
184 | 1.17k | CPlusPlusLanguage::MethodName cpp_method{ConstString(full_name)}; |
185 | | |
186 | 1.17k | if (!cpp_method.IsValid()) |
187 | 460 | return false; |
188 | | |
189 | 719 | llvm::StringRef return_type = cpp_method.GetReturnType(); |
190 | 719 | if (!return_type.empty()) { |
191 | 81 | out_stream.PutCString(return_type); |
192 | 81 | out_stream.PutChar(' '); |
193 | 81 | } |
194 | | |
195 | 719 | out_stream.PutCString(cpp_method.GetScopeQualifiedName()); |
196 | 719 | out_stream.PutChar('('); |
197 | | |
198 | 719 | FormatEntity::PrettyPrintFunctionArguments(out_stream, args, exe_scope); |
199 | | |
200 | 719 | out_stream.PutChar(')'); |
201 | | |
202 | 719 | llvm::StringRef qualifiers = cpp_method.GetQualifiers(); |
203 | 719 | if (!qualifiers.empty()) { |
204 | 6 | out_stream.PutChar(' '); |
205 | 6 | out_stream.PutCString(qualifiers); |
206 | 6 | } |
207 | | |
208 | 719 | return true; |
209 | 1.17k | } |
210 | | |
211 | 669k | 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 | 669k | size_t arg_start, arg_end; |
217 | 669k | llvm::StringRef full(m_full.GetCString()); |
218 | 669k | llvm::StringRef parens("()", 2); |
219 | 669k | if (ReverseFindMatchingChars(full, parens, arg_start, arg_end)) { |
220 | 6.50k | m_arguments = full.substr(arg_start, arg_end - arg_start + 1); |
221 | 6.50k | if (arg_end + 1 < full.size()) |
222 | 365 | m_qualifiers = full.substr(arg_end + 1).ltrim(); |
223 | | |
224 | 6.50k | if (arg_start == 0) |
225 | 0 | return false; |
226 | 6.50k | size_t basename_end = arg_start; |
227 | 6.50k | size_t context_start = 0; |
228 | 6.50k | size_t context_end = full.rfind(':', basename_end); |
229 | 6.50k | if (context_end == llvm::StringRef::npos) |
230 | 5.38k | m_basename = full.substr(0, basename_end); |
231 | 1.12k | else { |
232 | 1.12k | if (context_start < context_end) |
233 | 1.12k | m_context = full.substr(context_start, context_end - 1 - context_start); |
234 | 1.12k | const size_t basename_begin = context_end + 1; |
235 | 1.12k | m_basename = full.substr(basename_begin, basename_end - basename_begin); |
236 | 1.12k | } |
237 | | |
238 | 6.50k | if (IsTrivialBasename(m_basename)) { |
239 | 5.71k | return true; |
240 | 5.71k | } 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 | 795 | m_context = llvm::StringRef(); |
244 | 795 | m_basename = llvm::StringRef(); |
245 | 795 | m_arguments = llvm::StringRef(); |
246 | 795 | m_qualifiers = llvm::StringRef(); |
247 | 795 | m_return_type = llvm::StringRef(); |
248 | 795 | return false; |
249 | 795 | } |
250 | 6.50k | } |
251 | 662k | return false; |
252 | 669k | } |
253 | | |
254 | 669k | void CPlusPlusLanguage::MethodName::Parse() { |
255 | 669k | if (!m_parsed && m_full) { |
256 | 669k | if (TrySimplifiedParse()) { |
257 | 5.71k | m_parse_error = false; |
258 | 663k | } else { |
259 | 663k | CPlusPlusNameParser parser(m_full.GetStringRef()); |
260 | 663k | if (auto function = parser.ParseAsFunctionDefinition()) { |
261 | 618 | m_basename = function->name.basename; |
262 | 618 | m_context = function->name.context; |
263 | 618 | m_arguments = function->arguments; |
264 | 618 | m_qualifiers = function->qualifiers; |
265 | 618 | m_return_type = function->return_type; |
266 | 618 | m_parse_error = false; |
267 | 662k | } else { |
268 | 662k | m_parse_error = true; |
269 | 662k | } |
270 | 663k | } |
271 | 669k | m_parsed = true; |
272 | 669k | } |
273 | 669k | } |
274 | | |
275 | 539k | llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() { |
276 | 539k | if (!m_parsed) |
277 | 533k | Parse(); |
278 | 539k | return m_basename; |
279 | 539k | } |
280 | | |
281 | 2.66k | llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() { |
282 | 2.66k | if (!m_parsed) |
283 | 1 | Parse(); |
284 | 2.66k | return m_context; |
285 | 2.66k | } |
286 | | |
287 | 54 | llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() { |
288 | 54 | if (!m_parsed) |
289 | 7 | Parse(); |
290 | 54 | return m_arguments; |
291 | 54 | } |
292 | | |
293 | 761 | llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() { |
294 | 761 | if (!m_parsed) |
295 | 0 | Parse(); |
296 | 761 | return m_qualifiers; |
297 | 761 | } |
298 | | |
299 | 759 | llvm::StringRef CPlusPlusLanguage::MethodName::GetReturnType() { |
300 | 759 | if (!m_parsed) |
301 | 0 | Parse(); |
302 | 759 | return m_return_type; |
303 | 759 | } |
304 | | |
305 | 795 | std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() { |
306 | 795 | if (!m_parsed) |
307 | 36 | Parse(); |
308 | 795 | if (m_context.empty()) |
309 | 638 | return std::string(m_basename); |
310 | | |
311 | 157 | std::string res; |
312 | 157 | res += m_context; |
313 | 157 | res += "::"; |
314 | 157 | res += m_basename; |
315 | 157 | return res; |
316 | 795 | } |
317 | | |
318 | | llvm::StringRef |
319 | 65 | CPlusPlusLanguage::MethodName::GetBasenameNoTemplateParameters() { |
320 | 65 | llvm::StringRef basename = GetBasename(); |
321 | 65 | size_t arg_start, arg_end; |
322 | 65 | llvm::StringRef parens("<>", 2); |
323 | 65 | if (ReverseFindMatchingChars(basename, parens, arg_start, arg_end)) |
324 | 63 | return basename.substr(0, arg_start); |
325 | | |
326 | 2 | return basename; |
327 | 65 | } |
328 | | |
329 | 3.09k | bool CPlusPlusLanguage::MethodName::ContainsPath(llvm::StringRef path) { |
330 | 3.09k | if (!m_parsed) |
331 | 3.07k | Parse(); |
332 | | |
333 | | // If we can't parse the incoming name, then just check that it contains path. |
334 | 3.09k | if (m_parse_error) |
335 | 0 | return m_full.GetStringRef().contains(path); |
336 | | |
337 | 3.09k | llvm::StringRef identifier; |
338 | 3.09k | llvm::StringRef context; |
339 | 3.09k | std::string path_str = path.str(); |
340 | 3.09k | bool success = CPlusPlusLanguage::ExtractContextAndIdentifier( |
341 | 3.09k | path_str.c_str(), context, identifier); |
342 | 3.09k | if (!success) |
343 | 70 | 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 | 3.02k | if (GetBasename() != identifier && |
359 | 3.02k | GetBasenameNoTemplateParameters() != identifier65 ) |
360 | 5 | return false; |
361 | | |
362 | | // Incoming path only had an identifier, so we match. |
363 | 3.02k | if (context.empty()) |
364 | 2.59k | return true; |
365 | | // Incoming path has context but this method does not, no match. |
366 | 426 | if (m_context.empty()) |
367 | 7 | return false; |
368 | | |
369 | 419 | llvm::StringRef haystack = m_context; |
370 | 419 | if (!haystack.consume_back(context)) |
371 | 307 | return false; |
372 | 112 | if (haystack.empty() || !isalnum(haystack.back())61 ) |
373 | 97 | return true; |
374 | | |
375 | 15 | return false; |
376 | 112 | } |
377 | | |
378 | 569k | 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 | 569k | Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name); |
383 | | |
384 | 569k | if (scheme == Mangled::eManglingSchemeNone) |
385 | 546k | return false; |
386 | | |
387 | 22.4k | return true; |
388 | 569k | } |
389 | | |
390 | | bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path, |
391 | 3.06k | ConstString demangled) const { |
392 | 3.06k | MethodName demangled_name(demangled); |
393 | 3.06k | return demangled_name.ContainsPath(path); |
394 | 3.06k | } |
395 | | |
396 | | bool CPlusPlusLanguage::ExtractContextAndIdentifier( |
397 | 679k | const char *name, llvm::StringRef &context, llvm::StringRef &identifier) { |
398 | 679k | if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name)) |
399 | 3 | return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context, |
400 | 3 | identifier); |
401 | | |
402 | 679k | CPlusPlusNameParser parser(name); |
403 | 679k | if (auto full_name = parser.ParseAsFullName()) { |
404 | 658k | identifier = full_name->basename; |
405 | 658k | context = full_name->context; |
406 | 658k | return true; |
407 | 658k | } |
408 | 21.3k | return false; |
409 | 679k | } |
410 | | |
411 | | namespace { |
412 | | class NodeAllocator { |
413 | | llvm::BumpPtrAllocator Alloc; |
414 | | |
415 | | public: |
416 | 328 | void reset() { Alloc.Reset(); } |
417 | | |
418 | 2.64k | template <typename T, typename... Args> T *makeNode(Args &&... args) { |
419 | 2.64k | return new (Alloc.Allocate(sizeof(T), alignof(T))) |
420 | 2.64k | T(std::forward<Args>(args)...); |
421 | 2.64k | } Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [31], llvm::itanium_demangle::Node*&>(char const (&) [31], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [12], llvm::itanium_demangle::Node*&>(char const (&) [12], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [9], llvm::itanium_demangle::Node*&>(char const (&) [9], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [14], llvm::itanium_demangle::Node*&>(char const (&) [14], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [19], llvm::itanium_demangle::Node*&>(char const (&) [19], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [27], llvm::itanium_demangle::Node*&>(char const (&) [27], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::CtorVtableSpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::CtorVtableSpecialName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [41], llvm::itanium_demangle::Node*&>(char const (&) [41], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [18], llvm::itanium_demangle::Node*&>(char const (&) [18], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [22], llvm::itanium_demangle::Node*&>(char const (&) [22], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [20], llvm::itanium_demangle::Node*&>(char const (&) [20], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [25], llvm::itanium_demangle::Node*&>(char const (&) [25], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [22]>(char const (&) [22]) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Line | Count | Source | 418 | 688 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 688 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 688 | T(std::forward<Args>(args)...); | 421 | 688 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ModuleName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ModuleName, llvm::itanium_demangle::ModuleName*&, llvm::itanium_demangle::Node*&, bool&>(llvm::itanium_demangle::ModuleName*&, llvm::itanium_demangle::Node*&, bool&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [24], llvm::itanium_demangle::ModuleName*&>(char const (&) [24], llvm::itanium_demangle::ModuleName*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, std::__1::basic_string_view<char, std::__1::char_traits<char> > >(std::__1::basic_string_view<char, std::__1::char_traits<char> >&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ForwardTemplateReference* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ForwardTemplateReference, unsigned long&>(unsigned long&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [5]>(char const (&) [5]) Line | Count | Source | 418 | 88 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 88 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 88 | T(std::forward<Args>(args)...); | 421 | 88 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BinaryExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BinaryExpr, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PrefixExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PrefixExpr, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PostfixExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PostfixExpr, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ArraySubscriptExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ArraySubscriptExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::MemberExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NewExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, bool&, bool, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, bool&, bool&&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::DeleteExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::DeleteExpr, llvm::itanium_demangle::Node*&, bool&, bool, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, bool&, bool&&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::CallExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::CallExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ConversionExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ConditionalExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ConditionalExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::CastExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::CastExpr, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnclosingExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnclosingExpr, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::IntegerLiteral* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::IntegerLiteral, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BoolExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BoolExpr, int>(int&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::FloatLiteralImpl<float>* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FloatLiteralImpl<float>, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::FloatLiteralImpl<double>* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FloatLiteralImpl<double>, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::FloatLiteralImpl<long double>* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FloatLiteralImpl<long double>, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::StringLiteral* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::StringLiteral, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [8]>(char const (&) [8]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::UnnamedTypeName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::UnnamedTypeName, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SyntheticTemplateParamName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SyntheticTemplateParamName, llvm::itanium_demangle::TemplateParamKind&, unsigned int&>(llvm::itanium_demangle::TemplateParamKind&, unsigned int&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TypeTemplateParamDecl* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TypeTemplateParamDecl, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ConstrainedTypeTemplateParamDecl* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ConstrainedTypeTemplateParamDecl, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NoexceptSpec* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NoexceptSpec, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::DynamicExceptionSpec* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::DynamicExceptionSpec, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::FunctionType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FunctionType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Qualifiers&, llvm::itanium_demangle::FunctionRefQual&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Qualifiers&, llvm::itanium_demangle::FunctionRefQual&, llvm::itanium_demangle::Node*&) Line | Count | Source | 418 | 40 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 40 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 40 | T(std::forward<Args>(args)...); | 421 | 40 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ObjCProtoName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ObjCProtoName, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::VendorExtQualType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::VendorExtQualType, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::QualType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::QualType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&) Line | Count | Source | 418 | 16 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 16 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 16 | T(std::forward<Args>(args)...); | 421 | 16 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [12]>(char const (&) [12]) Line | Count | Source | 418 | 8 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 8 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 8 | T(std::forward<Args>(args)...); | 421 | 8 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [14]>(char const (&) [14]) Line | Count | Source | 418 | 120 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 120 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 120 | T(std::forward<Args>(args)...); | 421 | 120 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [15]>(char const (&) [15]) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [13]>(char const (&) [13]) Line | Count | Source | 418 | 120 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 120 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 120 | T(std::forward<Args>(args)...); | 421 | 120 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [10]>(char const (&) [10]) Line | Count | Source | 418 | 4 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 4 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 4 | T(std::forward<Args>(args)...); | 421 | 4 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [19]>(char const (&) [19]) Line | Count | Source | 418 | 4 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 4 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 4 | T(std::forward<Args>(args)...); | 421 | 4 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [9]>(char const (&) [9]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [18]>(char const (&) [18]) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [7]>(char const (&) [7]) Line | Count | Source | 418 | 32 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 32 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 32 | T(std::forward<Args>(args)...); | 421 | 32 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [11]>(char const (&) [11]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TransformedType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TransformedType, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BinaryFPType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BinaryFPType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BitIntType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BitIntType, llvm::itanium_demangle::Node*&, bool&>(llvm::itanium_demangle::Node*&, bool&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PostfixQualifiedType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PixelVectorType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PixelVectorType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::VectorType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::VectorType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, std::nullptr_t>(llvm::itanium_demangle::Node*&, std::nullptr_t&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ArrayType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ArrayType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PointerToMemberType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PointerToMemberType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ElaboratedTypeSpefType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ElaboratedTypeSpefType, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node*&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::PointerType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PointerType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Line | Count | Source | 418 | 240 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 240 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 240 | T(std::forward<Args>(args)...); | 421 | 240 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::ReferenceType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ReferenceType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::ReferenceKind>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::ReferenceKind&&) Line | Count | Source | 418 | 16 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 16 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 16 | T(std::forward<Args>(args)...); | 421 | 16 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PostfixQualifiedType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [9]>(llvm::itanium_demangle::Node*&, char const (&) [9]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PostfixQualifiedType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [11]>(llvm::itanium_demangle::Node*&, char const (&) [11]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NonTypeTemplateParamDecl* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NonTypeTemplateParamDecl, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TemplateTemplateParamDecl* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TemplateTemplateParamDecl, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TemplateParamPackDecl* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TemplateParamPackDecl, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ClosureTypeName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ClosureTypeName, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [16]>(char const (&) [16]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::LambdaExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::LambdaExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnumLiteral* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnumLiteral, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::FunctionParam* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FunctionParam, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::FoldExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FoldExpr, bool&, std::__1::basic_string_view<char, std::__1::char_traits<char> >, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(bool&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BracedExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BracedExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, bool>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, bool&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::BracedRangeExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::BracedRangeExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::InitListExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::InitListExpr, std::nullptr_t, llvm::itanium_demangle::NodeArray>(std::nullptr_t&&, llvm::itanium_demangle::NodeArray&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::PointerToMemberConversionExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::PointerToMemberConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node::Prec&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::Node::Prec&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnclosingExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnclosingExpr, char const (&) [10], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec>(char const (&) [10], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node::Prec&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ExprRequirement* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ExprRequirement, llvm::itanium_demangle::Node*&, bool&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, bool&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TypeRequirement* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TypeRequirement, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NestedRequirement* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NestedRequirement, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::RequiresExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::RequiresExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::NodeArray&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SubobjectExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SubobjectExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::NodeArray, bool&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&, llvm::itanium_demangle::NodeArray&&, bool&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ParameterPackExpansion* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ParameterPackExpansion, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SizeofParamPackExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SizeofParamPackExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnclosingExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnclosingExpr, char const (&) [11], llvm::itanium_demangle::Node*&>(char const (&) [11], llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NodeArrayNode* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NodeArrayNode, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::InitListExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::InitListExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [6]>(char const (&) [6]) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ThrowExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ThrowExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::QualifiedName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::QualifiedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::DtorName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::DtorName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ConversionOperatorType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ConversionOperatorType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::LiteralOperator* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::LiteralOperator, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::GlobalQualifiedName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::GlobalQualifiedName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnclosingExpr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnclosingExpr, char const (&) [9], llvm::itanium_demangle::Node*&>(char const (&) [9], llvm::itanium_demangle::Node*&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameType* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameType, char const (&) [4]>(char const (&) [4]) Line | Count | Source | 418 | 180 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 180 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 180 | T(std::forward<Args>(args)...); | 421 | 180 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialSubstitution* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialSubstitution, llvm::itanium_demangle::SpecialSubKind&>(llvm::itanium_demangle::SpecialSubKind&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::AbiTagAttr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::AbiTagAttr, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&>(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&) Line | Count | Source | 418 | 16 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 16 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 16 | T(std::forward<Args>(args)...); | 421 | 16 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::StructuredBindingName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::StructuredBindingName, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ExpandedSpecialSubstitution* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ExpandedSpecialSubstitution, llvm::itanium_demangle::SpecialSubstitution*>(llvm::itanium_demangle::SpecialSubstitution*&&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::CtorDtorName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::CtorDtorName, llvm::itanium_demangle::Node*&, bool, int&>(llvm::itanium_demangle::Node*&, bool&&, int&) Line | Count | Source | 418 | 56 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 56 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 56 | T(std::forward<Args>(args)...); | 421 | 56 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ModuleEntity* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ModuleEntity, llvm::itanium_demangle::ModuleName*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::ModuleName*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::MemberLikeFriendName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::MemberLikeFriendName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::NestedName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NestedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Line | Count | Source | 418 | 460 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 460 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 460 | T(std::forward<Args>(args)...); | 421 | 460 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::LocalName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::LocalName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::ParameterPack* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::ParameterPack, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::TemplateArgs* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TemplateArgs, llvm::itanium_demangle::NodeArray, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::NodeArray&&, llvm::itanium_demangle::Node*&) Line | Count | Source | 418 | 192 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 192 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 192 | T(std::forward<Args>(args)...); | 421 | 192 | } |
CPlusPlusLanguage.cpp:llvm::itanium_demangle::NameWithTemplateArgs* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::NameWithTemplateArgs, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Line | Count | Source | 418 | 192 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 192 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 192 | T(std::forward<Args>(args)...); | 421 | 192 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TemplateArgumentPack* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TemplateArgumentPack, llvm::itanium_demangle::NodeArray&>(llvm::itanium_demangle::NodeArray&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::TemplateParamQualifiedArg* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::TemplateParamQualifiedArg, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::EnableIfAttr* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::EnableIfAttr, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&) CPlusPlusLanguage.cpp:llvm::itanium_demangle::FunctionEncoding* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::FunctionEncoding, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&, llvm::itanium_demangle::FunctionRefQual&>(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&, llvm::itanium_demangle::FunctionRefQual&) Line | Count | Source | 418 | 172 | template <typename T, typename... Args> T *makeNode(Args &&... args) { | 419 | 172 | return new (Alloc.Allocate(sizeof(T), alignof(T))) | 420 | 172 | T(std::forward<Args>(args)...); | 421 | 172 | } |
Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::DotSuffix* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::DotSuffix, llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> > >(llvm::itanium_demangle::Node*&, std::__1::basic_string_view<char, std::__1::char_traits<char> >&&) Unexecuted instantiation: CPlusPlusLanguage.cpp:llvm::itanium_demangle::SpecialName* (anonymous namespace)::NodeAllocator::makeNode<llvm::itanium_demangle::SpecialName, char const (&) [34], llvm::itanium_demangle::Node*&>(char const (&) [34], llvm::itanium_demangle::Node*&) |
422 | | |
423 | 320 | void *allocateNodeArray(size_t sz) { |
424 | 320 | return Alloc.Allocate(sizeof(llvm::itanium_demangle::Node *) * sz, |
425 | 320 | alignof(llvm::itanium_demangle::Node *)); |
426 | 320 | } |
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: |
437 | 164 | ManglingSubstitutor() : Base(nullptr, nullptr) {} CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::ManglingSubstitutor() Line | Count | Source | 437 | 82 | ManglingSubstitutor() : Base(nullptr, nullptr) {} |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::ManglingSubstitutor() Line | Count | Source | 437 | 82 | ManglingSubstitutor() : Base(nullptr, nullptr) {} |
|
438 | | |
439 | | template <typename... Ts> |
440 | 328 | ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) { |
441 | 328 | this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...); |
442 | 328 | return substituteImpl(Mangled); |
443 | 328 | } CPlusPlusLanguage.cpp:lldb_private::ConstString (anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::substitute<char const (&) [2], char const (&) [2]>(llvm::StringRef, char const (&) [2], char const (&) [2]) Line | Count | Source | 440 | 246 | ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) { | 441 | 246 | this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...); | 442 | 246 | return substituteImpl(Mangled); | 443 | 246 | } |
CPlusPlusLanguage.cpp:lldb_private::ConstString (anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::substitute<>(llvm::StringRef) Line | Count | Source | 440 | 82 | ConstString substitute(llvm::StringRef Mangled, Ts &&... Vals) { | 441 | 82 | this->getDerived().reset(Mangled, std::forward<Ts>(Vals)...); | 442 | 82 | return substituteImpl(Mangled); | 443 | 82 | } |
|
444 | | |
445 | | protected: |
446 | 328 | void reset(llvm::StringRef Mangled) { |
447 | 328 | Base::reset(Mangled.begin(), Mangled.end()); |
448 | 328 | Written = Mangled.begin(); |
449 | 328 | Result.clear(); |
450 | 328 | Substituted = false; |
451 | 328 | } CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::reset(llvm::StringRef) Line | Count | Source | 446 | 246 | void reset(llvm::StringRef Mangled) { | 447 | 246 | Base::reset(Mangled.begin(), Mangled.end()); | 448 | 246 | Written = Mangled.begin(); | 449 | 246 | Result.clear(); | 450 | 246 | Substituted = false; | 451 | 246 | } |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::reset(llvm::StringRef) Line | Count | Source | 446 | 82 | void reset(llvm::StringRef Mangled) { | 447 | 82 | Base::reset(Mangled.begin(), Mangled.end()); | 448 | 82 | Written = Mangled.begin(); | 449 | 82 | Result.clear(); | 450 | 82 | Substituted = false; | 451 | 82 | } |
|
452 | | |
453 | 328 | ConstString substituteImpl(llvm::StringRef Mangled) { |
454 | 328 | Log *log = GetLog(LLDBLog::Language); |
455 | 328 | if (this->parse() == nullptr) { |
456 | 12 | LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled); |
457 | 12 | return ConstString(); |
458 | 12 | } |
459 | 316 | if (!Substituted) |
460 | 298 | return ConstString(); |
461 | | |
462 | | // Append any trailing unmodified input. |
463 | 18 | appendUnchangedInput(); |
464 | 18 | LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result); |
465 | 18 | return ConstString(Result); |
466 | 316 | } CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::substituteImpl(llvm::StringRef) Line | Count | Source | 453 | 246 | ConstString substituteImpl(llvm::StringRef Mangled) { | 454 | 246 | Log *log = GetLog(LLDBLog::Language); | 455 | 246 | if (this->parse() == nullptr) { | 456 | 9 | LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled); | 457 | 9 | return ConstString(); | 458 | 9 | } | 459 | 237 | if (!Substituted) | 460 | 233 | return ConstString(); | 461 | | | 462 | | // Append any trailing unmodified input. | 463 | 4 | appendUnchangedInput(); | 464 | 4 | LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result); | 465 | 4 | return ConstString(Result); | 466 | 237 | } |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::substituteImpl(llvm::StringRef) Line | Count | Source | 453 | 82 | ConstString substituteImpl(llvm::StringRef Mangled) { | 454 | 82 | Log *log = GetLog(LLDBLog::Language); | 455 | 82 | if (this->parse() == nullptr) { | 456 | 3 | LLDB_LOG(log, "Failed to substitute mangling in {0}", Mangled); | 457 | 3 | return ConstString(); | 458 | 3 | } | 459 | 79 | if (!Substituted) | 460 | 65 | return ConstString(); | 461 | | | 462 | | // Append any trailing unmodified input. | 463 | 14 | appendUnchangedInput(); | 464 | 14 | LLDB_LOG(log, "Substituted mangling {0} -> {1}", Mangled, Result); | 465 | 14 | return ConstString(Result); | 466 | 79 | } |
|
467 | | |
468 | 778 | void trySubstitute(llvm::StringRef From, llvm::StringRef To) { |
469 | 778 | if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From)) |
470 | 760 | return; |
471 | | |
472 | | // We found a match. Append unmodified input up to this point. |
473 | 18 | appendUnchangedInput(); |
474 | | |
475 | | // And then perform the replacement. |
476 | 18 | Result += To; |
477 | 18 | Written += From.size(); |
478 | 18 | Substituted = true; |
479 | 18 | } CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::trySubstitute(llvm::StringRef, llvm::StringRef) Line | Count | Source | 468 | 750 | void trySubstitute(llvm::StringRef From, llvm::StringRef To) { | 469 | 750 | if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From)) | 470 | 746 | return; | 471 | | | 472 | | // We found a match. Append unmodified input up to this point. | 473 | 4 | appendUnchangedInput(); | 474 | | | 475 | | // And then perform the replacement. | 476 | 4 | Result += To; | 477 | 4 | Written += From.size(); | 478 | 4 | Substituted = true; | 479 | 4 | } |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::trySubstitute(llvm::StringRef, llvm::StringRef) Line | Count | Source | 468 | 28 | void trySubstitute(llvm::StringRef From, llvm::StringRef To) { | 469 | 28 | if (!llvm::StringRef(currentParserPos(), this->numLeft()).startswith(From)) | 470 | 14 | return; | 471 | | | 472 | | // We found a match. Append unmodified input up to this point. | 473 | 14 | appendUnchangedInput(); | 474 | | | 475 | | // And then perform the replacement. | 476 | 14 | Result += To; | 477 | 14 | Written += From.size(); | 478 | 14 | Substituted = true; | 479 | 14 | } |
|
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 | | |
491 | 850 | const char *currentParserPos() const { return this->First; } CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::currentParserPos() const Line | Count | Source | 491 | 766 | const char *currentParserPos() const { return this->First; } |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::currentParserPos() const Line | Count | Source | 491 | 84 | const char *currentParserPos() const { return this->First; } |
|
492 | | |
493 | 36 | void appendUnchangedInput() { |
494 | 36 | Result += |
495 | 36 | llvm::StringRef(Written, std::distance(Written, currentParserPos())); |
496 | 36 | Written = currentParserPos(); |
497 | 36 | } CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::TypeSubstitutor>::appendUnchangedInput() Line | Count | Source | 493 | 8 | void appendUnchangedInput() { | 494 | 8 | Result += | 495 | 8 | llvm::StringRef(Written, std::distance(Written, currentParserPos())); | 496 | 8 | Written = currentParserPos(); | 497 | 8 | } |
CPlusPlusLanguage.cpp:(anonymous namespace)::ManglingSubstitutor<(anonymous namespace)::CtorDtorSubstitutor>::appendUnchangedInput() Line | Count | Source | 493 | 28 | void appendUnchangedInput() { | 494 | 28 | Result += | 495 | 28 | llvm::StringRef(Written, std::distance(Written, currentParserPos())); | 496 | 28 | Written = currentParserPos(); | 497 | 28 | } |
|
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: |
507 | | void reset(llvm::StringRef Mangled, llvm::StringRef Search, |
508 | 246 | llvm::StringRef Replace) { |
509 | 246 | ManglingSubstitutor::reset(Mangled); |
510 | 246 | this->Search = Search; |
511 | 246 | this->Replace = Replace; |
512 | 246 | } |
513 | | |
514 | 750 | llvm::itanium_demangle::Node *parseType() { |
515 | 750 | trySubstitute(Search, Replace); |
516 | 750 | return ManglingSubstitutor::parseType(); |
517 | 750 | } |
518 | | }; |
519 | | |
520 | | class CtorDtorSubstitutor : public ManglingSubstitutor<CtorDtorSubstitutor> { |
521 | | public: |
522 | | llvm::itanium_demangle::Node * |
523 | 14 | parseCtorDtorName(llvm::itanium_demangle::Node *&SoFar, NameState *State) { |
524 | 14 | trySubstitute("C1", "C2"); |
525 | 14 | trySubstitute("D1", "D2"); |
526 | 14 | return ManglingSubstitutor::parseCtorDtorName(SoFar, State); |
527 | 14 | } |
528 | | }; |
529 | | } // namespace |
530 | | |
531 | | std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings( |
532 | 82 | const ConstString mangled_name) const { |
533 | 82 | 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 | 82 | if (!strncmp(mangled_name.GetCString(), "_ZN", 3) && |
544 | 82 | strncmp(mangled_name.GetCString(), "_ZNK", 4)35 ) { |
545 | 33 | std::string fixed_scratch("_ZNK"); |
546 | 33 | fixed_scratch.append(mangled_name.GetCString() + 3); |
547 | 33 | alternates.push_back(ConstString(fixed_scratch)); |
548 | 33 | } |
549 | | |
550 | | // Maybe we're looking for a static symbol but we thought it was global... |
551 | 82 | if (!strncmp(mangled_name.GetCString(), "_Z", 2) && |
552 | 82 | strncmp(mangled_name.GetCString(), "_ZL", 3)43 ) { |
553 | 43 | std::string fixed_scratch("_ZL"); |
554 | 43 | fixed_scratch.append(mangled_name.GetCString() + 2); |
555 | 43 | alternates.push_back(ConstString(fixed_scratch)); |
556 | 43 | } |
557 | | |
558 | 82 | 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 | 82 | if (ConstString char_fixup = |
564 | 82 | TS.substitute(mangled_name.GetStringRef(), "a", "c")) |
565 | 2 | alternates.push_back(char_fixup); |
566 | | |
567 | | // long long parameter mangling 'x', may actually just be a long 'l' argument |
568 | 82 | if (ConstString long_fixup = |
569 | 82 | TS.substitute(mangled_name.GetStringRef(), "x", "l")) |
570 | 1 | alternates.push_back(long_fixup); |
571 | | |
572 | | // unsigned long long parameter mangling 'y', may actually just be unsigned |
573 | | // long 'm' argument |
574 | 82 | if (ConstString ulong_fixup = |
575 | 82 | TS.substitute(mangled_name.GetStringRef(), "y", "m")) |
576 | 1 | alternates.push_back(ulong_fixup); |
577 | | |
578 | 82 | if (ConstString ctor_fixup = |
579 | 82 | CtorDtorSubstitutor().substitute(mangled_name.GetStringRef())) |
580 | 14 | alternates.push_back(ctor_fixup); |
581 | | |
582 | 82 | return alternates; |
583 | 82 | } |
584 | | |
585 | | ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName( |
586 | 36 | const Mangled mangled, const SymbolContext &sym_ctx) const { |
587 | 36 | ConstString demangled = mangled.GetDemangledName(); |
588 | 36 | if (!demangled) |
589 | 0 | return ConstString(); |
590 | | |
591 | 36 | CPlusPlusLanguage::MethodName cpp_name(demangled); |
592 | 36 | std::string scope_qualified_name = cpp_name.GetScopeQualifiedName(); |
593 | | |
594 | 36 | if (!scope_qualified_name.size()) |
595 | 18 | return ConstString(); |
596 | | |
597 | 18 | if (!sym_ctx.module_sp) |
598 | 0 | return ConstString(); |
599 | | |
600 | 18 | lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile(); |
601 | 18 | if (!sym_file) |
602 | 0 | return ConstString(); |
603 | | |
604 | 18 | std::vector<ConstString> alternates; |
605 | 18 | sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates); |
606 | | |
607 | 18 | std::vector<ConstString> param_and_qual_matches; |
608 | 18 | std::vector<ConstString> param_matches; |
609 | 25 | for (size_t i = 0; i < alternates.size(); i++7 ) { |
610 | 7 | ConstString alternate_mangled_name = alternates[i]; |
611 | 7 | Mangled mangled(alternate_mangled_name); |
612 | 7 | ConstString demangled = mangled.GetDemangledName(); |
613 | | |
614 | 7 | CPlusPlusLanguage::MethodName alternate_cpp_name(demangled); |
615 | 7 | if (!cpp_name.IsValid()) |
616 | 0 | continue; |
617 | | |
618 | 7 | if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) { |
619 | 1 | if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers()) |
620 | 1 | param_and_qual_matches.push_back(alternate_mangled_name); |
621 | 0 | else |
622 | 0 | param_matches.push_back(alternate_mangled_name); |
623 | 1 | } |
624 | 7 | } |
625 | | |
626 | 18 | if (param_and_qual_matches.size()) |
627 | 1 | return param_and_qual_matches[0]; // It is assumed that there will be only |
628 | | // one! |
629 | 17 | else if (param_matches.size()) |
630 | 0 | return param_matches[0]; // Return one of them as a best match |
631 | 17 | else |
632 | 17 | return ConstString(); |
633 | 18 | } |
634 | | |
635 | 686 | static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { |
636 | 686 | if (!cpp_category_sp) |
637 | 0 | return; |
638 | | |
639 | 686 | TypeSummaryImpl::Flags stl_summary_flags; |
640 | 686 | stl_summary_flags.SetCascades(true) |
641 | 686 | .SetSkipPointers(false) |
642 | 686 | .SetSkipReferences(false) |
643 | 686 | .SetDontShowChildren(true) |
644 | 686 | .SetDontShowValue(true) |
645 | 686 | .SetShowMembersOneLiner(false) |
646 | 686 | .SetHideItemNames(false); |
647 | | |
648 | 686 | AddCXXSummary(cpp_category_sp, |
649 | 686 | lldb_private::formatters::LibcxxStringSummaryProviderASCII, |
650 | 686 | "std::string summary provider", "^std::__[[:alnum:]]+::string$", |
651 | 686 | stl_summary_flags, true); |
652 | 686 | AddCXXSummary(cpp_category_sp, |
653 | 686 | lldb_private::formatters::LibcxxStringSummaryProviderASCII, |
654 | 686 | "std::string summary provider", |
655 | 686 | "^std::__[[:alnum:]]+::basic_string<char, " |
656 | 686 | "std::__[[:alnum:]]+::char_traits<char>, " |
657 | 686 | "std::__[[:alnum:]]+::allocator<char> >$", |
658 | 686 | stl_summary_flags, true); |
659 | 686 | AddCXXSummary(cpp_category_sp, |
660 | 686 | lldb_private::formatters::LibcxxStringSummaryProviderASCII, |
661 | 686 | "std::string summary provider", |
662 | 686 | "^std::__[[:alnum:]]+::basic_string<unsigned char, " |
663 | 686 | "std::__[[:alnum:]]+::char_traits<unsigned char>, " |
664 | 686 | "std::__[[:alnum:]]+::allocator<unsigned char> >$", |
665 | 686 | stl_summary_flags, true); |
666 | | |
667 | 686 | AddCXXSummary(cpp_category_sp, |
668 | 686 | lldb_private::formatters::LibcxxStringSummaryProviderUTF16, |
669 | 686 | "std::u16string summary provider", |
670 | 686 | "^std::__[[:alnum:]]+::basic_string<char16_t, " |
671 | 686 | "std::__[[:alnum:]]+::char_traits<char16_t>, " |
672 | 686 | "std::__[[:alnum:]]+::allocator<char16_t> >$", |
673 | 686 | stl_summary_flags, true); |
674 | | |
675 | 686 | AddCXXSummary(cpp_category_sp, |
676 | 686 | lldb_private::formatters::LibcxxStringSummaryProviderUTF32, |
677 | 686 | "std::u32string summary provider", |
678 | 686 | "^std::__[[:alnum:]]+::basic_string<char32_t, " |
679 | 686 | "std::__[[:alnum:]]+::char_traits<char32_t>, " |
680 | 686 | "std::__[[:alnum:]]+::allocator<char32_t> >$", |
681 | 686 | stl_summary_flags, true); |
682 | | |
683 | 686 | AddCXXSummary(cpp_category_sp, |
684 | 686 | lldb_private::formatters::LibcxxWStringSummaryProvider, |
685 | 686 | "std::wstring summary provider", |
686 | 686 | "^std::__[[:alnum:]]+::wstring$", stl_summary_flags, true); |
687 | 686 | AddCXXSummary(cpp_category_sp, |
688 | 686 | lldb_private::formatters::LibcxxWStringSummaryProvider, |
689 | 686 | "std::wstring summary provider", |
690 | 686 | "^std::__[[:alnum:]]+::basic_string<wchar_t, " |
691 | 686 | "std::__[[:alnum:]]+::char_traits<wchar_t>, " |
692 | 686 | "std::__[[:alnum:]]+::allocator<wchar_t> >$", |
693 | 686 | stl_summary_flags, true); |
694 | | |
695 | 686 | AddCXXSummary(cpp_category_sp, |
696 | 686 | lldb_private::formatters::LibcxxStringViewSummaryProviderASCII, |
697 | 686 | "std::string_view summary provider", |
698 | 686 | "^std::__[[:alnum:]]+::string_view$", stl_summary_flags, true); |
699 | 686 | AddCXXSummary(cpp_category_sp, |
700 | 686 | lldb_private::formatters::LibcxxStringViewSummaryProviderASCII, |
701 | 686 | "std::string_view summary provider", |
702 | 686 | "^std::__[[:alnum:]]+::basic_string_view<char, " |
703 | 686 | "std::__[[:alnum:]]+::char_traits<char> >$", |
704 | 686 | stl_summary_flags, true); |
705 | 686 | AddCXXSummary(cpp_category_sp, |
706 | 686 | lldb_private::formatters::LibcxxStringViewSummaryProviderASCII, |
707 | 686 | "std::string_view summary provider", |
708 | 686 | "^std::__[[:alnum:]]+::basic_string_view<unsigned char, " |
709 | 686 | "std::__[[:alnum:]]+::char_traits<unsigned char> >$", |
710 | 686 | stl_summary_flags, true); |
711 | | |
712 | 686 | AddCXXSummary(cpp_category_sp, |
713 | 686 | lldb_private::formatters::LibcxxStringViewSummaryProviderUTF16, |
714 | 686 | "std::u16string_view summary provider", |
715 | 686 | "^std::__[[:alnum:]]+::basic_string_view<char16_t, " |
716 | 686 | "std::__[[:alnum:]]+::char_traits<char16_t> >$", |
717 | 686 | stl_summary_flags, true); |
718 | | |
719 | 686 | AddCXXSummary(cpp_category_sp, |
720 | 686 | lldb_private::formatters::LibcxxStringViewSummaryProviderUTF32, |
721 | 686 | "std::u32string_view summary provider", |
722 | 686 | "^std::__[[:alnum:]]+::basic_string_view<char32_t, " |
723 | 686 | "std::__[[:alnum:]]+::char_traits<char32_t> >$", |
724 | 686 | stl_summary_flags, true); |
725 | | |
726 | 686 | AddCXXSummary(cpp_category_sp, |
727 | 686 | lldb_private::formatters::LibcxxWStringViewSummaryProvider, |
728 | 686 | "std::wstring_view summary provider", |
729 | 686 | "^std::__[[:alnum:]]+::wstring_view$", stl_summary_flags, true); |
730 | 686 | AddCXXSummary(cpp_category_sp, |
731 | 686 | lldb_private::formatters::LibcxxWStringViewSummaryProvider, |
732 | 686 | "std::wstring_view summary provider", |
733 | 686 | "^std::__[[:alnum:]]+::basic_string_view<wchar_t, " |
734 | 686 | "std::__[[:alnum:]]+::char_traits<wchar_t> >$", |
735 | 686 | stl_summary_flags, true); |
736 | | |
737 | 686 | SyntheticChildren::Flags stl_synth_flags; |
738 | 686 | stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( |
739 | 686 | false); |
740 | 686 | SyntheticChildren::Flags stl_deref_flags = stl_synth_flags; |
741 | 686 | stl_deref_flags.SetFrontEndWantsDereference(); |
742 | | |
743 | 686 | AddCXXSynthetic( |
744 | 686 | cpp_category_sp, |
745 | 686 | lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator, |
746 | 686 | "libc++ std::bitset synthetic children", |
747 | 686 | "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_deref_flags, true); |
748 | 686 | AddCXXSynthetic( |
749 | 686 | cpp_category_sp, |
750 | 686 | lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, |
751 | 686 | "libc++ std::vector synthetic children", |
752 | 686 | "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_deref_flags, true); |
753 | 686 | AddCXXSynthetic( |
754 | 686 | cpp_category_sp, |
755 | 686 | lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator, |
756 | 686 | "libc++ std::forward_list synthetic children", |
757 | 686 | "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$", stl_synth_flags, true); |
758 | 686 | AddCXXSynthetic( |
759 | 686 | cpp_category_sp, |
760 | 686 | lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, |
761 | 686 | "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 | 686 | "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" |
765 | 686 | "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$", |
766 | 686 | stl_deref_flags, true); |
767 | 686 | AddCXXSynthetic( |
768 | 686 | cpp_category_sp, |
769 | 686 | lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, |
770 | 686 | "libc++ std::map synthetic children", |
771 | 686 | "^std::__[[:alnum:]]+::map<.+> >(( )?&)?$", stl_synth_flags, true); |
772 | 686 | AddCXXSynthetic( |
773 | 686 | cpp_category_sp, |
774 | 686 | lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, |
775 | 686 | "libc++ std::set synthetic children", |
776 | 686 | "^std::__[[:alnum:]]+::set<.+> >(( )?&)?$", stl_deref_flags, true); |
777 | 686 | AddCXXSynthetic( |
778 | 686 | cpp_category_sp, |
779 | 686 | lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, |
780 | 686 | "libc++ std::multiset synthetic children", |
781 | 686 | "^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$", stl_deref_flags, true); |
782 | 686 | AddCXXSynthetic( |
783 | 686 | cpp_category_sp, |
784 | 686 | lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, |
785 | 686 | "libc++ std::multimap synthetic children", |
786 | 686 | "^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$", stl_synth_flags, true); |
787 | 686 | AddCXXSynthetic( |
788 | 686 | cpp_category_sp, |
789 | 686 | lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator, |
790 | 686 | "libc++ std::unordered containers synthetic children", |
791 | 686 | "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$", |
792 | 686 | stl_synth_flags, true); |
793 | 686 | AddCXXSynthetic( |
794 | 686 | cpp_category_sp, |
795 | 686 | lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator, |
796 | 686 | "libc++ std::initializer_list synthetic children", |
797 | 686 | "^std::initializer_list<.+>(( )?&)?$", stl_synth_flags, true); |
798 | 686 | AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator, |
799 | 686 | "libc++ std::queue synthetic children", |
800 | 686 | "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_synth_flags, |
801 | 686 | true); |
802 | 686 | AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator, |
803 | 686 | "libc++ std::tuple synthetic children", |
804 | 686 | "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_synth_flags, |
805 | 686 | true); |
806 | 686 | AddCXXSynthetic(cpp_category_sp, LibcxxOptionalSyntheticFrontEndCreator, |
807 | 686 | "libc++ std::optional synthetic children", |
808 | 686 | "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$", |
809 | 686 | stl_synth_flags, true); |
810 | 686 | AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator, |
811 | 686 | "libc++ std::variant synthetic children", |
812 | 686 | "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_synth_flags, |
813 | 686 | true); |
814 | 686 | AddCXXSynthetic( |
815 | 686 | cpp_category_sp, |
816 | 686 | lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator, |
817 | 686 | "libc++ std::atomic synthetic children", |
818 | 686 | "^std::__[[:alnum:]]+::atomic<.+>$", stl_synth_flags, true); |
819 | 686 | AddCXXSynthetic( |
820 | 686 | cpp_category_sp, |
821 | 686 | lldb_private::formatters::LibcxxStdSpanSyntheticFrontEndCreator, |
822 | 686 | "libc++ std::span synthetic children", |
823 | 686 | "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_deref_flags, true); |
824 | 686 | AddCXXSynthetic( |
825 | 686 | cpp_category_sp, |
826 | 686 | lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEndCreator, |
827 | 686 | "libc++ std::ranges::ref_view synthetic children", |
828 | 686 | "^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$", stl_deref_flags, |
829 | 686 | true); |
830 | | |
831 | 686 | cpp_category_sp->AddTypeSynthetic( |
832 | 686 | "^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$", eFormatterMatchRegex, |
833 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
834 | 686 | stl_synth_flags, |
835 | 686 | "lldb.formatters.cpp.libcxx.stddeque_SynthProvider"))); |
836 | | |
837 | 686 | AddCXXSynthetic( |
838 | 686 | cpp_category_sp, |
839 | 686 | lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, |
840 | 686 | "shared_ptr synthetic children", |
841 | 686 | "^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$", stl_synth_flags, true); |
842 | | |
843 | 686 | static constexpr const char *const libcxx_std_unique_ptr_regex = |
844 | 686 | "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$"; |
845 | 686 | AddCXXSynthetic( |
846 | 686 | cpp_category_sp, |
847 | 686 | lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEndCreator, |
848 | 686 | "unique_ptr synthetic children", libcxx_std_unique_ptr_regex, |
849 | 686 | stl_synth_flags, true); |
850 | | |
851 | 686 | AddCXXSynthetic( |
852 | 686 | cpp_category_sp, |
853 | 686 | lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, |
854 | 686 | "weak_ptr synthetic children", |
855 | 686 | "^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$", stl_synth_flags, true); |
856 | 686 | AddCXXSummary(cpp_category_sp, |
857 | 686 | lldb_private::formatters::LibcxxFunctionSummaryProvider, |
858 | 686 | "libc++ std::function summary provider", |
859 | 686 | "^std::__[[:alnum:]]+::function<.+>$", stl_summary_flags, true); |
860 | | |
861 | 686 | static constexpr const char *const libcxx_std_coroutine_handle_regex = |
862 | 686 | "^std::__[[:alnum:]]+::coroutine_handle<.+>(( )?&)?$"; |
863 | 686 | AddCXXSynthetic( |
864 | 686 | cpp_category_sp, |
865 | 686 | lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator, |
866 | 686 | "coroutine_handle synthetic children", libcxx_std_coroutine_handle_regex, |
867 | 686 | stl_deref_flags, true); |
868 | | |
869 | 686 | stl_summary_flags.SetDontShowChildren(false); |
870 | 686 | stl_summary_flags.SetSkipPointers(false); |
871 | 686 | AddCXXSummary( |
872 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
873 | 686 | "libc++ std::bitset summary provider", |
874 | 686 | "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_summary_flags, true); |
875 | 686 | AddCXXSummary( |
876 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
877 | 686 | "libc++ std::vector summary provider", |
878 | 686 | "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_summary_flags, true); |
879 | 686 | AddCXXSummary(cpp_category_sp, |
880 | 686 | lldb_private::formatters::LibcxxContainerSummaryProvider, |
881 | 686 | "libc++ std::list summary provider", |
882 | 686 | "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$", |
883 | 686 | stl_summary_flags, true); |
884 | 686 | AddCXXSummary( |
885 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
886 | 686 | "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 | 686 | "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|" |
890 | 686 | "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$", |
891 | 686 | stl_summary_flags, true); |
892 | 686 | AddCXXSummary( |
893 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
894 | 686 | "libc++ std::map summary provider", |
895 | 686 | "^std::__[[:alnum:]]+::map<.+>(( )?&)?$", stl_summary_flags, true); |
896 | 686 | AddCXXSummary( |
897 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
898 | 686 | "libc++ std::deque summary provider", |
899 | 686 | "^std::__[[:alnum:]]+::deque<.+>(( )?&)?$", stl_summary_flags, true); |
900 | 686 | AddCXXSummary( |
901 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
902 | 686 | "libc++ std::queue summary provider", |
903 | 686 | "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_summary_flags, true); |
904 | 686 | AddCXXSummary( |
905 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
906 | 686 | "libc++ std::set summary provider", |
907 | 686 | "^std::__[[:alnum:]]+::set<.+>(( )?&)?$", stl_summary_flags, true); |
908 | 686 | AddCXXSummary( |
909 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
910 | 686 | "libc++ std::multiset summary provider", |
911 | 686 | "^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$", stl_summary_flags, true); |
912 | 686 | AddCXXSummary( |
913 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
914 | 686 | "libc++ std::multimap summary provider", |
915 | 686 | "^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$", stl_summary_flags, true); |
916 | 686 | AddCXXSummary(cpp_category_sp, |
917 | 686 | lldb_private::formatters::LibcxxContainerSummaryProvider, |
918 | 686 | "libc++ std::unordered containers summary provider", |
919 | 686 | "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$", |
920 | 686 | stl_summary_flags, true); |
921 | 686 | AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider, |
922 | 686 | "libc++ std::tuple summary provider", |
923 | 686 | "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_summary_flags, |
924 | 686 | true); |
925 | 686 | AddCXXSummary(cpp_category_sp, |
926 | 686 | lldb_private::formatters::LibCxxAtomicSummaryProvider, |
927 | 686 | "libc++ std::atomic summary provider", |
928 | 686 | "^std::__[[:alnum:]]+::atomic<.+>$", stl_summary_flags, true); |
929 | 686 | AddCXXSummary( |
930 | 686 | cpp_category_sp, lldb_private::formatters::GenericOptionalSummaryProvider, |
931 | 686 | "libc++ std::optional summary provider", |
932 | 686 | "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$", stl_summary_flags, true); |
933 | 686 | AddCXXSummary( |
934 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxVariantSummaryProvider, |
935 | 686 | "libc++ std::variant summary provider", |
936 | 686 | "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_summary_flags, true); |
937 | 686 | AddCXXSummary( |
938 | 686 | cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, |
939 | 686 | "libc++ std::span summary provider", |
940 | 686 | "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_summary_flags, true); |
941 | | |
942 | 686 | stl_summary_flags.SetSkipPointers(true); |
943 | | |
944 | 686 | AddCXXSummary(cpp_category_sp, |
945 | 686 | lldb_private::formatters::LibcxxSmartPointerSummaryProvider, |
946 | 686 | "libc++ std::shared_ptr summary provider", |
947 | 686 | "^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$", |
948 | 686 | stl_summary_flags, true); |
949 | 686 | AddCXXSummary(cpp_category_sp, |
950 | 686 | lldb_private::formatters::LibcxxSmartPointerSummaryProvider, |
951 | 686 | "libc++ std::weak_ptr summary provider", |
952 | 686 | "^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$", |
953 | 686 | stl_summary_flags, true); |
954 | 686 | AddCXXSummary(cpp_category_sp, |
955 | 686 | lldb_private::formatters::LibcxxUniquePointerSummaryProvider, |
956 | 686 | "libc++ std::unique_ptr summary provider", |
957 | 686 | libcxx_std_unique_ptr_regex, stl_summary_flags, true); |
958 | | |
959 | 686 | AddCXXSummary(cpp_category_sp, |
960 | 686 | lldb_private::formatters::StdlibCoroutineHandleSummaryProvider, |
961 | 686 | "libc++ std::coroutine_handle summary provider", |
962 | 686 | libcxx_std_coroutine_handle_regex, stl_summary_flags, true); |
963 | | |
964 | 686 | AddCXXSynthetic( |
965 | 686 | cpp_category_sp, |
966 | 686 | lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, |
967 | 686 | "std::vector iterator synthetic children", |
968 | 686 | "^std::__[[:alnum:]]+::__wrap_iter<.+>$", stl_synth_flags, true); |
969 | | |
970 | 686 | AddCXXSynthetic( |
971 | 686 | cpp_category_sp, |
972 | 686 | lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, |
973 | 686 | "std::map iterator synthetic children", |
974 | 686 | "^std::__[[:alnum:]]+::__map_(const_)?iterator<.+>$", stl_synth_flags, |
975 | 686 | true); |
976 | | |
977 | 686 | AddCXXSynthetic(cpp_category_sp, |
978 | 686 | lldb_private::formatters:: |
979 | 686 | LibCxxUnorderedMapIteratorSyntheticFrontEndCreator, |
980 | 686 | "std::unordered_map iterator synthetic children", |
981 | 686 | "^std::__[[:alnum:]]+::__hash_map_(const_)?iterator<.+>$", |
982 | 686 | stl_synth_flags, true); |
983 | | // Chrono duration typedefs |
984 | 686 | cpp_category_sp->AddTypeSummary( |
985 | 686 | "^std::__[[:alnum:]]+::chrono::nanoseconds", eFormatterMatchRegex, |
986 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
987 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} ns"))); |
988 | 686 | cpp_category_sp->AddTypeSummary( |
989 | 686 | "^std::__[[:alnum:]]+::chrono::microseconds", eFormatterMatchRegex, |
990 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
991 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} µs"))); |
992 | 686 | cpp_category_sp->AddTypeSummary( |
993 | 686 | "^std::__[[:alnum:]]+::chrono::milliseconds", eFormatterMatchRegex, |
994 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
995 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} ms"))); |
996 | 686 | cpp_category_sp->AddTypeSummary( |
997 | 686 | "^std::__[[:alnum:]]+::chrono::seconds", eFormatterMatchRegex, |
998 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
999 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} s"))); |
1000 | 686 | cpp_category_sp->AddTypeSummary( |
1001 | 686 | "^std::__[[:alnum:]]+::chrono::minutes", eFormatterMatchRegex, |
1002 | 686 | TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren | |
1003 | 686 | eTypeOptionHideValue, |
1004 | 686 | "${var.__rep_} min"))); |
1005 | 686 | cpp_category_sp->AddTypeSummary( |
1006 | 686 | "^std::__[[:alnum:]]+::chrono::hours", eFormatterMatchRegex, |
1007 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1008 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} h"))); |
1009 | | |
1010 | 686 | cpp_category_sp->AddTypeSummary( |
1011 | 686 | "^std::__[[:alnum:]]+::chrono::days", eFormatterMatchRegex, |
1012 | 686 | TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren | |
1013 | 686 | eTypeOptionHideValue, |
1014 | 686 | "${var.__rep_} days"))); |
1015 | 686 | cpp_category_sp->AddTypeSummary( |
1016 | 686 | "^std::__[[:alnum:]]+::chrono::weeks", eFormatterMatchRegex, |
1017 | 686 | TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren | |
1018 | 686 | eTypeOptionHideValue, |
1019 | 686 | "${var.__rep_} weeks"))); |
1020 | 686 | cpp_category_sp->AddTypeSummary( |
1021 | 686 | "^std::__[[:alnum:]]+::chrono::months", eFormatterMatchRegex, |
1022 | 686 | TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren | |
1023 | 686 | eTypeOptionHideValue, |
1024 | 686 | "${var.__rep_} months"))); |
1025 | 686 | cpp_category_sp->AddTypeSummary( |
1026 | 686 | "^std::__[[:alnum:]]+::chrono::years", eFormatterMatchRegex, |
1027 | 686 | TypeSummaryImplSP(new StringSummaryFormat(eTypeOptionHideChildren | |
1028 | 686 | eTypeOptionHideValue, |
1029 | 686 | "${var.__rep_} years"))); |
1030 | 686 | cpp_category_sp->AddTypeSummary( |
1031 | 686 | "^std::__[[:alnum:]]+::chrono::seconds", eFormatterMatchRegex, |
1032 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1033 | 686 | eTypeOptionHideChildren | eTypeOptionHideValue, "${var.__rep_} s"))); |
1034 | 686 | } |
1035 | | |
1036 | 686 | static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { |
1037 | 686 | if (!cpp_category_sp) |
1038 | 0 | return; |
1039 | | |
1040 | 686 | TypeSummaryImpl::Flags stl_summary_flags; |
1041 | 686 | stl_summary_flags.SetCascades(true) |
1042 | 686 | .SetSkipPointers(false) |
1043 | 686 | .SetSkipReferences(false) |
1044 | 686 | .SetDontShowChildren(true) |
1045 | 686 | .SetDontShowValue(true) |
1046 | 686 | .SetShowMembersOneLiner(false) |
1047 | 686 | .SetHideItemNames(false); |
1048 | | |
1049 | 686 | lldb::TypeSummaryImplSP std_string_summary_sp( |
1050 | 686 | new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p}")); |
1051 | | |
1052 | 686 | lldb::TypeSummaryImplSP cxx11_string_summary_sp(new CXXFunctionSummaryFormat( |
1053 | 686 | stl_summary_flags, LibStdcppStringSummaryProvider, |
1054 | 686 | "libstdc++ c++11 std::string summary provider")); |
1055 | 686 | lldb::TypeSummaryImplSP cxx11_wstring_summary_sp(new CXXFunctionSummaryFormat( |
1056 | 686 | stl_summary_flags, LibStdcppWStringSummaryProvider, |
1057 | 686 | "libstdc++ c++11 std::wstring summary provider")); |
1058 | | |
1059 | 686 | cpp_category_sp->AddTypeSummary("std::string", eFormatterMatchExact, |
1060 | 686 | std_string_summary_sp); |
1061 | 686 | cpp_category_sp->AddTypeSummary("std::basic_string<char>", |
1062 | 686 | eFormatterMatchExact, std_string_summary_sp); |
1063 | 686 | cpp_category_sp->AddTypeSummary( |
1064 | 686 | "std::basic_string<char,std::char_traits<char>,std::allocator<char> >", |
1065 | 686 | eFormatterMatchExact, std_string_summary_sp); |
1066 | 686 | cpp_category_sp->AddTypeSummary( |
1067 | 686 | "std::basic_string<char, std::char_traits<char>, std::allocator<char> >", |
1068 | 686 | eFormatterMatchExact, std_string_summary_sp); |
1069 | | |
1070 | 686 | cpp_category_sp->AddTypeSummary("std::__cxx11::string", eFormatterMatchExact, |
1071 | 686 | cxx11_string_summary_sp); |
1072 | 686 | cpp_category_sp->AddTypeSummary( |
1073 | 686 | "std::__cxx11::basic_string<char, std::char_traits<char>, " |
1074 | 686 | "std::allocator<char> >", |
1075 | 686 | eFormatterMatchExact, cxx11_string_summary_sp); |
1076 | 686 | cpp_category_sp->AddTypeSummary("std::__cxx11::basic_string<unsigned char, " |
1077 | 686 | "std::char_traits<unsigned char>, " |
1078 | 686 | "std::allocator<unsigned char> >", |
1079 | 686 | eFormatterMatchExact, |
1080 | 686 | cxx11_string_summary_sp); |
1081 | | |
1082 | | // making sure we force-pick the summary for printing wstring (_M_p is a |
1083 | | // wchar_t*) |
1084 | 686 | lldb::TypeSummaryImplSP std_wstring_summary_sp( |
1085 | 686 | new StringSummaryFormat(stl_summary_flags, "${var._M_dataplus._M_p%S}")); |
1086 | | |
1087 | 686 | cpp_category_sp->AddTypeSummary("std::wstring", eFormatterMatchExact, |
1088 | 686 | std_wstring_summary_sp); |
1089 | 686 | cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t>", |
1090 | 686 | eFormatterMatchExact, std_wstring_summary_sp); |
1091 | 686 | cpp_category_sp->AddTypeSummary("std::basic_string<wchar_t,std::char_traits<" |
1092 | 686 | "wchar_t>,std::allocator<wchar_t> >", |
1093 | 686 | eFormatterMatchExact, std_wstring_summary_sp); |
1094 | 686 | cpp_category_sp->AddTypeSummary( |
1095 | 686 | "std::basic_string<wchar_t, std::char_traits<wchar_t>, " |
1096 | 686 | "std::allocator<wchar_t> >", |
1097 | 686 | eFormatterMatchExact, std_wstring_summary_sp); |
1098 | | |
1099 | 686 | cpp_category_sp->AddTypeSummary("std::__cxx11::wstring", eFormatterMatchExact, |
1100 | 686 | cxx11_wstring_summary_sp); |
1101 | 686 | cpp_category_sp->AddTypeSummary( |
1102 | 686 | "std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, " |
1103 | 686 | "std::allocator<wchar_t> >", |
1104 | 686 | eFormatterMatchExact, cxx11_wstring_summary_sp); |
1105 | | |
1106 | 686 | SyntheticChildren::Flags stl_synth_flags; |
1107 | 686 | stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences( |
1108 | 686 | false); |
1109 | 686 | SyntheticChildren::Flags stl_deref_flags = stl_synth_flags; |
1110 | 686 | stl_deref_flags.SetFrontEndWantsDereference(); |
1111 | | |
1112 | 686 | cpp_category_sp->AddTypeSynthetic( |
1113 | 686 | "^std::vector<.+>(( )?&)?$", eFormatterMatchRegex, |
1114 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1115 | 686 | stl_synth_flags, |
1116 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider"))); |
1117 | 686 | cpp_category_sp->AddTypeSynthetic( |
1118 | 686 | "^std::map<.+> >(( )?&)?$", eFormatterMatchRegex, |
1119 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1120 | 686 | stl_synth_flags, |
1121 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider"))); |
1122 | 686 | cpp_category_sp->AddTypeSynthetic( |
1123 | 686 | "^std::deque<.+>(( )?&)?$", eFormatterMatchRegex, |
1124 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1125 | 686 | stl_deref_flags, |
1126 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdDequeSynthProvider"))); |
1127 | 686 | cpp_category_sp->AddTypeSynthetic( |
1128 | 686 | "^std::set<.+> >(( )?&)?$", eFormatterMatchRegex, |
1129 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1130 | 686 | stl_deref_flags, |
1131 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider"))); |
1132 | 686 | cpp_category_sp->AddTypeSynthetic( |
1133 | 686 | "^std::multimap<.+> >(( )?&)?$", eFormatterMatchRegex, |
1134 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1135 | 686 | stl_deref_flags, |
1136 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider"))); |
1137 | 686 | cpp_category_sp->AddTypeSynthetic( |
1138 | 686 | "^std::multiset<.+> >(( )?&)?$", eFormatterMatchRegex, |
1139 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1140 | 686 | stl_deref_flags, |
1141 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdMapLikeSynthProvider"))); |
1142 | 686 | cpp_category_sp->AddTypeSynthetic( |
1143 | 686 | "^std::unordered_(multi)?(map|set)<.+> >$", eFormatterMatchRegex, |
1144 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1145 | 686 | stl_deref_flags, |
1146 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdUnorderedMapSynthProvider"))); |
1147 | 686 | cpp_category_sp->AddTypeSynthetic( |
1148 | 686 | "^std::(__cxx11::)?list<.+>(( )?&)?$", eFormatterMatchRegex, |
1149 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1150 | 686 | stl_deref_flags, |
1151 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider"))); |
1152 | 686 | cpp_category_sp->AddTypeSynthetic( |
1153 | 686 | "^std::(__cxx11::)?forward_list<.+>(( )?&)?$", eFormatterMatchRegex, |
1154 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1155 | 686 | stl_synth_flags, |
1156 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.StdForwardListSynthProvider"))); |
1157 | 686 | cpp_category_sp->AddTypeSynthetic( |
1158 | 686 | "^std::variant<.+>$", eFormatterMatchRegex, |
1159 | 686 | SyntheticChildrenSP(new ScriptedSyntheticChildren( |
1160 | 686 | stl_synth_flags, |
1161 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.VariantSynthProvider"))); |
1162 | | |
1163 | 686 | stl_summary_flags.SetDontShowChildren(false); |
1164 | 686 | stl_summary_flags.SetSkipPointers(false); |
1165 | 686 | cpp_category_sp->AddTypeSummary("^std::bitset<.+>(( )?&)?$", |
1166 | 686 | eFormatterMatchRegex, |
1167 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1168 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1169 | 686 | cpp_category_sp->AddTypeSummary("^std::vector<.+>(( )?&)?$", |
1170 | 686 | eFormatterMatchRegex, |
1171 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1172 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1173 | 686 | cpp_category_sp->AddTypeSummary("^std::map<.+> >(( )?&)?$", |
1174 | 686 | eFormatterMatchRegex, |
1175 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1176 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1177 | 686 | cpp_category_sp->AddTypeSummary("^std::set<.+> >(( )?&)?$", |
1178 | 686 | eFormatterMatchRegex, |
1179 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1180 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1181 | 686 | cpp_category_sp->AddTypeSummary("^std::deque<.+>(( )?&)?$", |
1182 | 686 | eFormatterMatchRegex, |
1183 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1184 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1185 | 686 | cpp_category_sp->AddTypeSummary("^std::multimap<.+> >(( )?&)?$", |
1186 | 686 | eFormatterMatchRegex, |
1187 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1188 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1189 | 686 | cpp_category_sp->AddTypeSummary("^std::multiset<.+> >(( )?&)?$", |
1190 | 686 | eFormatterMatchRegex, |
1191 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1192 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1193 | 686 | cpp_category_sp->AddTypeSummary("^std::unordered_(multi)?(map|set)<.+> >$", |
1194 | 686 | eFormatterMatchRegex, |
1195 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1196 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1197 | 686 | cpp_category_sp->AddTypeSummary("^std::(__cxx11::)?list<.+>(( )?&)?$", |
1198 | 686 | eFormatterMatchRegex, |
1199 | 686 | TypeSummaryImplSP(new StringSummaryFormat( |
1200 | 686 | stl_summary_flags, "size=${svar%#}"))); |
1201 | 686 | cpp_category_sp->AddTypeSummary( |
1202 | 686 | "^std::(__cxx11::)?forward_list<.+>(( )?&)?$", eFormatterMatchRegex, |
1203 | 686 | TypeSummaryImplSP(new ScriptSummaryFormat( |
1204 | 686 | stl_summary_flags, |
1205 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider"))); |
1206 | 686 | cpp_category_sp->AddTypeSummary( |
1207 | 686 | "^std::variant<.+>$", eFormatterMatchRegex, |
1208 | 686 | TypeSummaryImplSP(new ScriptSummaryFormat( |
1209 | 686 | stl_summary_flags, |
1210 | 686 | "lldb.formatters.cpp.gnu_libstdcpp.VariantSummaryProvider"))); |
1211 | | |
1212 | 686 | AddCXXSynthetic( |
1213 | 686 | cpp_category_sp, |
1214 | 686 | lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, |
1215 | 686 | "std::vector iterator synthetic children", |
1216 | 686 | "^__gnu_cxx::__normal_iterator<.+>$", stl_synth_flags, true); |
1217 | | |
1218 | 686 | AddCXXSynthetic( |
1219 | 686 | cpp_category_sp, |
1220 | 686 | lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, |
1221 | 686 | "std::map iterator synthetic children", "^std::_Rb_tree_iterator<.+>$", |
1222 | 686 | stl_synth_flags, true); |
1223 | | |
1224 | 686 | AddCXXSynthetic( |
1225 | 686 | cpp_category_sp, |
1226 | 686 | lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator, |
1227 | 686 | "std::unique_ptr synthetic children", "^std::unique_ptr<.+>(( )?&)?$", |
1228 | 686 | stl_synth_flags, true); |
1229 | 686 | AddCXXSynthetic( |
1230 | 686 | cpp_category_sp, |
1231 | 686 | lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, |
1232 | 686 | "std::shared_ptr synthetic children", "^std::shared_ptr<.+>(( )?&)?$", |
1233 | 686 | stl_synth_flags, true); |
1234 | 686 | AddCXXSynthetic( |
1235 | 686 | cpp_category_sp, |
1236 | 686 | lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator, |
1237 | 686 | "std::weak_ptr synthetic children", "^std::weak_ptr<.+>(( )?&)?$", |
1238 | 686 | stl_synth_flags, true); |
1239 | 686 | AddCXXSynthetic( |
1240 | 686 | cpp_category_sp, |
1241 | 686 | lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator, |
1242 | 686 | "std::tuple synthetic children", "^std::tuple<.+>(( )?&)?$", |
1243 | 686 | stl_synth_flags, true); |
1244 | | |
1245 | 686 | static constexpr const char *const libstdcpp_std_coroutine_handle_regex = |
1246 | 686 | "^std::coroutine_handle<.+>(( )?&)?$"; |
1247 | 686 | AddCXXSynthetic( |
1248 | 686 | cpp_category_sp, |
1249 | 686 | lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator, |
1250 | 686 | "std::coroutine_handle synthetic children", |
1251 | 686 | libstdcpp_std_coroutine_handle_regex, stl_deref_flags, true); |
1252 | | |
1253 | 686 | AddCXXSynthetic( |
1254 | 686 | cpp_category_sp, |
1255 | 686 | lldb_private::formatters::LibStdcppBitsetSyntheticFrontEndCreator, |
1256 | 686 | "std::bitset synthetic child", "^std::bitset<.+>(( )?&)?$", |
1257 | 686 | stl_deref_flags, true); |
1258 | | |
1259 | 686 | AddCXXSynthetic( |
1260 | 686 | cpp_category_sp, |
1261 | 686 | lldb_private::formatters::LibStdcppOptionalSyntheticFrontEndCreator, |
1262 | 686 | "std::optional synthetic child", "^std::optional<.+>(( )?&)?$", |
1263 | 686 | stl_deref_flags, true); |
1264 | | |
1265 | 686 | AddCXXSummary(cpp_category_sp, |
1266 | 686 | lldb_private::formatters::LibStdcppUniquePointerSummaryProvider, |
1267 | 686 | "libstdc++ std::unique_ptr summary provider", |
1268 | 686 | "^std::unique_ptr<.+>(( )?&)?$", stl_summary_flags, true); |
1269 | 686 | AddCXXSummary(cpp_category_sp, |
1270 | 686 | lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, |
1271 | 686 | "libstdc++ std::shared_ptr summary provider", |
1272 | 686 | "^std::shared_ptr<.+>(( )?&)?$", stl_summary_flags, true); |
1273 | 686 | AddCXXSummary(cpp_category_sp, |
1274 | 686 | lldb_private::formatters::LibStdcppSmartPointerSummaryProvider, |
1275 | 686 | "libstdc++ std::weak_ptr summary provider", |
1276 | 686 | "^std::weak_ptr<.+>(( )?&)?$", stl_summary_flags, true); |
1277 | 686 | AddCXXSummary(cpp_category_sp, |
1278 | 686 | lldb_private::formatters::StdlibCoroutineHandleSummaryProvider, |
1279 | 686 | "libstdc++ std::coroutine_handle summary provider", |
1280 | 686 | libstdcpp_std_coroutine_handle_regex, stl_summary_flags, true); |
1281 | 686 | AddCXXSummary(cpp_category_sp, |
1282 | 686 | lldb_private::formatters::GenericOptionalSummaryProvider, |
1283 | 686 | "libstd++ std::optional summary provider", |
1284 | 686 | "^std::optional<.+>(( )?&)?$", stl_summary_flags, true); |
1285 | 686 | } |
1286 | | |
1287 | 686 | static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) { |
1288 | 686 | if (!cpp_category_sp) |
1289 | 0 | return; |
1290 | | |
1291 | 686 | TypeSummaryImpl::Flags string_flags; |
1292 | 686 | string_flags.SetCascades(true) |
1293 | 686 | .SetSkipPointers(true) |
1294 | 686 | .SetSkipReferences(false) |
1295 | 686 | .SetDontShowChildren(true) |
1296 | 686 | .SetDontShowValue(false) |
1297 | 686 | .SetShowMembersOneLiner(false) |
1298 | 686 | .SetHideItemNames(false); |
1299 | | |
1300 | 686 | TypeSummaryImpl::Flags string_array_flags; |
1301 | 686 | string_array_flags.SetCascades(true) |
1302 | 686 | .SetSkipPointers(true) |
1303 | 686 | .SetSkipReferences(false) |
1304 | 686 | .SetDontShowChildren(true) |
1305 | 686 | .SetDontShowValue(true) |
1306 | 686 | .SetShowMembersOneLiner(false) |
1307 | 686 | .SetHideItemNames(false); |
1308 | | |
1309 | 686 | AddCXXSummary(cpp_category_sp, |
1310 | 686 | lldb_private::formatters::Char8StringSummaryProvider, |
1311 | 686 | "char8_t * summary provider", "char8_t *", string_flags); |
1312 | 686 | AddCXXSummary(cpp_category_sp, |
1313 | 686 | lldb_private::formatters::Char8StringSummaryProvider, |
1314 | 686 | "char8_t [] summary provider", "char8_t ?\\[[0-9]+\\]", |
1315 | 686 | string_array_flags, true); |
1316 | | |
1317 | 686 | AddCXXSummary(cpp_category_sp, |
1318 | 686 | lldb_private::formatters::Char16StringSummaryProvider, |
1319 | 686 | "char16_t * summary provider", "char16_t *", string_flags); |
1320 | 686 | AddCXXSummary(cpp_category_sp, |
1321 | 686 | lldb_private::formatters::Char16StringSummaryProvider, |
1322 | 686 | "char16_t [] summary provider", "char16_t ?\\[[0-9]+\\]", |
1323 | 686 | string_array_flags, true); |
1324 | | |
1325 | 686 | AddCXXSummary(cpp_category_sp, |
1326 | 686 | lldb_private::formatters::Char32StringSummaryProvider, |
1327 | 686 | "char32_t * summary provider", "char32_t *", string_flags); |
1328 | 686 | AddCXXSummary(cpp_category_sp, |
1329 | 686 | lldb_private::formatters::Char32StringSummaryProvider, |
1330 | 686 | "char32_t [] summary provider", "char32_t ?\\[[0-9]+\\]", |
1331 | 686 | string_array_flags, true); |
1332 | | |
1333 | 686 | AddCXXSummary(cpp_category_sp, |
1334 | 686 | lldb_private::formatters::WCharStringSummaryProvider, |
1335 | 686 | "wchar_t * summary provider", "wchar_t *", string_flags); |
1336 | 686 | AddCXXSummary(cpp_category_sp, |
1337 | 686 | lldb_private::formatters::WCharStringSummaryProvider, |
1338 | 686 | "wchar_t * summary provider", "wchar_t ?\\[[0-9]+\\]", |
1339 | 686 | string_array_flags, true); |
1340 | | |
1341 | 686 | AddCXXSummary(cpp_category_sp, |
1342 | 686 | lldb_private::formatters::Char16StringSummaryProvider, |
1343 | 686 | "unichar * summary provider", "unichar *", string_flags); |
1344 | | |
1345 | 686 | TypeSummaryImpl::Flags widechar_flags; |
1346 | 686 | widechar_flags.SetDontShowValue(true) |
1347 | 686 | .SetSkipPointers(true) |
1348 | 686 | .SetSkipReferences(false) |
1349 | 686 | .SetCascades(true) |
1350 | 686 | .SetDontShowChildren(true) |
1351 | 686 | .SetHideItemNames(true) |
1352 | 686 | .SetShowMembersOneLiner(false); |
1353 | | |
1354 | 686 | AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider, |
1355 | 686 | "char8_t summary provider", "char8_t", widechar_flags); |
1356 | 686 | AddCXXSummary(cpp_category_sp, |
1357 | 686 | lldb_private::formatters::Char16SummaryProvider, |
1358 | 686 | "char16_t summary provider", "char16_t", widechar_flags); |
1359 | 686 | AddCXXSummary(cpp_category_sp, |
1360 | 686 | lldb_private::formatters::Char32SummaryProvider, |
1361 | 686 | "char32_t summary provider", "char32_t", widechar_flags); |
1362 | 686 | AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider, |
1363 | 686 | "wchar_t summary provider", "wchar_t", widechar_flags); |
1364 | | |
1365 | 686 | AddCXXSummary(cpp_category_sp, |
1366 | 686 | lldb_private::formatters::Char16SummaryProvider, |
1367 | 686 | "unichar summary provider", "unichar", widechar_flags); |
1368 | 686 | } |
1369 | | |
1370 | 98 | std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() { |
1371 | 98 | class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger { |
1372 | 98 | public: |
1373 | 98 | CompilerType AdjustForInclusion(CompilerType &candidate) override { |
1374 | 32 | LanguageType lang_type(candidate.GetMinimumLanguage()); |
1375 | 32 | if (!Language::LanguageIsC(lang_type) && |
1376 | 32 | !Language::LanguageIsCPlusPlus(lang_type)31 ) |
1377 | 24 | return CompilerType(); |
1378 | 8 | if (candidate.IsTypedefType()) |
1379 | 2 | return candidate.GetTypedefedType(); |
1380 | 6 | return candidate; |
1381 | 8 | } |
1382 | 98 | }; |
1383 | | |
1384 | 98 | return std::unique_ptr<TypeScavenger>(new CPlusPlusTypeScavenger()); |
1385 | 98 | } |
1386 | | |
1387 | 686 | lldb::TypeCategoryImplSP CPlusPlusLanguage::GetFormatters() { |
1388 | 686 | static llvm::once_flag g_initialize; |
1389 | 686 | static TypeCategoryImplSP g_category; |
1390 | | |
1391 | 686 | llvm::call_once(g_initialize, [this]() -> void { |
1392 | 686 | DataVisualization::Categories::GetCategory(ConstString(GetPluginName()), |
1393 | 686 | g_category); |
1394 | 686 | if (g_category) { |
1395 | 686 | LoadLibStdcppFormatters(g_category); |
1396 | 686 | LoadLibCxxFormatters(g_category); |
1397 | 686 | LoadSystemFormatters(g_category); |
1398 | 686 | } |
1399 | 686 | }); |
1400 | 686 | return g_category; |
1401 | 686 | } |
1402 | | |
1403 | | HardcodedFormatters::HardcodedSummaryFinder |
1404 | 686 | CPlusPlusLanguage::GetHardcodedSummaries() { |
1405 | 686 | static llvm::once_flag g_initialize; |
1406 | 686 | static ConstString g_vectortypes("VectorTypes"); |
1407 | 686 | static HardcodedFormatters::HardcodedSummaryFinder g_formatters; |
1408 | | |
1409 | 686 | llvm::call_once(g_initialize, []() -> void { |
1410 | 686 | g_formatters.push_back( |
1411 | 686 | [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, |
1412 | 61.0k | FormatManager &) -> TypeSummaryImpl::SharedPointer { |
1413 | 61.0k | static CXXFunctionSummaryFormat::SharedPointer formatter_sp( |
1414 | 61.0k | new CXXFunctionSummaryFormat( |
1415 | 61.0k | TypeSummaryImpl::Flags(), |
1416 | 61.0k | lldb_private::formatters::CXXFunctionPointerSummaryProvider, |
1417 | 61.0k | "Function pointer summary provider")); |
1418 | 61.0k | if (CompilerType CT = valobj.GetCompilerType(); |
1419 | 61.0k | CT.IsFunctionPointerType() || CT.IsMemberFunctionPointerType()60.9k || |
1420 | 61.0k | valobj.GetValueType() == lldb::eValueTypeVTableEntry60.9k ) { |
1421 | 116 | return formatter_sp; |
1422 | 116 | } |
1423 | 60.9k | return nullptr; |
1424 | 61.0k | }); |
1425 | 686 | g_formatters.push_back( |
1426 | 686 | [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, |
1427 | 60.9k | FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { |
1428 | 60.9k | static CXXFunctionSummaryFormat::SharedPointer formatter_sp( |
1429 | 60.9k | new CXXFunctionSummaryFormat( |
1430 | 60.9k | TypeSummaryImpl::Flags() |
1431 | 60.9k | .SetCascades(true) |
1432 | 60.9k | .SetDontShowChildren(true) |
1433 | 60.9k | .SetHideItemNames(true) |
1434 | 60.9k | .SetShowMembersOneLiner(true) |
1435 | 60.9k | .SetSkipPointers(true) |
1436 | 60.9k | .SetSkipReferences(false), |
1437 | 60.9k | lldb_private::formatters::VectorTypeSummaryProvider, |
1438 | 60.9k | "vector_type pointer summary provider")); |
1439 | 60.9k | if (valobj.GetCompilerType().IsVectorType()) { |
1440 | 604 | if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) |
1441 | 604 | return formatter_sp; |
1442 | 604 | } |
1443 | 60.3k | return nullptr; |
1444 | 60.9k | }); |
1445 | 686 | g_formatters.push_back( |
1446 | 686 | [](lldb_private::ValueObject &valobj, lldb::DynamicValueType, |
1447 | 60.3k | FormatManager &fmt_mgr) -> TypeSummaryImpl::SharedPointer { |
1448 | 60.3k | static CXXFunctionSummaryFormat::SharedPointer formatter_sp( |
1449 | 60.3k | new CXXFunctionSummaryFormat( |
1450 | 60.3k | TypeSummaryImpl::Flags() |
1451 | 60.3k | .SetCascades(true) |
1452 | 60.3k | .SetDontShowChildren(true) |
1453 | 60.3k | .SetHideItemNames(true) |
1454 | 60.3k | .SetShowMembersOneLiner(true) |
1455 | 60.3k | .SetSkipPointers(true) |
1456 | 60.3k | .SetSkipReferences(false), |
1457 | 60.3k | lldb_private::formatters::BlockPointerSummaryProvider, |
1458 | 60.3k | "block pointer summary provider")); |
1459 | 60.3k | if (valobj.GetCompilerType().IsBlockPointerType()) { |
1460 | 8 | return formatter_sp; |
1461 | 8 | } |
1462 | 60.3k | return nullptr; |
1463 | 60.3k | }); |
1464 | 686 | }); |
1465 | | |
1466 | 686 | return g_formatters; |
1467 | 686 | } |
1468 | | |
1469 | | HardcodedFormatters::HardcodedSyntheticFinder |
1470 | 686 | CPlusPlusLanguage::GetHardcodedSynthetics() { |
1471 | 686 | static llvm::once_flag g_initialize; |
1472 | 686 | static ConstString g_vectortypes("VectorTypes"); |
1473 | 686 | static HardcodedFormatters::HardcodedSyntheticFinder g_formatters; |
1474 | | |
1475 | 686 | llvm::call_once(g_initialize, []() -> void { |
1476 | 686 | g_formatters.push_back([](lldb_private::ValueObject &valobj, |
1477 | 686 | lldb::DynamicValueType, FormatManager &fmt_mgr) |
1478 | 63.9k | -> SyntheticChildren::SharedPointer { |
1479 | 63.9k | static CXXSyntheticChildren::SharedPointer formatter_sp( |
1480 | 63.9k | new CXXSyntheticChildren( |
1481 | 63.9k | SyntheticChildren::Flags() |
1482 | 63.9k | .SetCascades(true) |
1483 | 63.9k | .SetSkipPointers(true) |
1484 | 63.9k | .SetSkipReferences(true) |
1485 | 63.9k | .SetNonCacheable(true), |
1486 | 63.9k | "vector_type synthetic children", |
1487 | 63.9k | lldb_private::formatters::VectorTypeSyntheticFrontEndCreator)); |
1488 | 63.9k | if (valobj.GetCompilerType().IsVectorType()) { |
1489 | 641 | if (fmt_mgr.GetCategory(g_vectortypes)->IsEnabled()) |
1490 | 641 | return formatter_sp; |
1491 | 641 | } |
1492 | 63.2k | return nullptr; |
1493 | 63.9k | }); |
1494 | 686 | g_formatters.push_back([](lldb_private::ValueObject &valobj, |
1495 | 686 | lldb::DynamicValueType, FormatManager &fmt_mgr) |
1496 | 63.2k | -> SyntheticChildren::SharedPointer { |
1497 | 63.2k | static CXXSyntheticChildren::SharedPointer formatter_sp( |
1498 | 63.2k | new CXXSyntheticChildren( |
1499 | 63.2k | SyntheticChildren::Flags() |
1500 | 63.2k | .SetCascades(true) |
1501 | 63.2k | .SetSkipPointers(true) |
1502 | 63.2k | .SetSkipReferences(true) |
1503 | 63.2k | .SetNonCacheable(true), |
1504 | 63.2k | "block pointer synthetic children", |
1505 | 63.2k | lldb_private::formatters::BlockPointerSyntheticFrontEndCreator)); |
1506 | 63.2k | if (valobj.GetCompilerType().IsBlockPointerType()) { |
1507 | 8 | return formatter_sp; |
1508 | 8 | } |
1509 | 63.2k | return nullptr; |
1510 | 63.2k | }); |
1511 | 686 | }); |
1512 | | |
1513 | 686 | return g_formatters; |
1514 | 686 | } |
1515 | | |
1516 | 8.20k | bool CPlusPlusLanguage::IsNilReference(ValueObject &valobj) { |
1517 | 8.20k | if (!Language::LanguageIsCPlusPlus(valobj.GetObjectRuntimeLanguage()) || |
1518 | 8.20k | !valobj.IsPointerType()) |
1519 | 7.55k | return false; |
1520 | 652 | bool canReadValue = true; |
1521 | 652 | bool isZero = valobj.GetValueAsUnsigned(0, &canReadValue) == 0; |
1522 | 652 | return canReadValue && isZero; |
1523 | 8.20k | } |
1524 | | |
1525 | 10.1k | bool CPlusPlusLanguage::IsSourceFile(llvm::StringRef file_path) const { |
1526 | 10.1k | const auto suffixes = {".cpp", ".cxx", ".c++", ".cc", ".c", |
1527 | 10.1k | ".h", ".hh", ".hpp", ".hxx", ".h++"}; |
1528 | 28.6k | for (auto suffix : suffixes) { |
1529 | 28.6k | if (file_path.ends_with_insensitive(suffix)) |
1530 | 9.18k | return true; |
1531 | 28.6k | } |
1532 | | |
1533 | | // Check if we're in a STL path (where the files usually have no extension |
1534 | | // that we could check for. |
1535 | 920 | return file_path.contains("/usr/include/c++/"); |
1536 | 10.1k | } |
1537 | | |
1538 | | bool CPlusPlusLanguage::GetFunctionDisplayName( |
1539 | | const SymbolContext *sc, const ExecutionContext *exe_ctx, |
1540 | 2.40k | FunctionNameRepresentation representation, Stream &s) { |
1541 | 2.40k | switch (representation) { |
1542 | 2.26k | case FunctionNameRepresentation::eNameWithArgs: { |
1543 | | // Print the function name with arguments in it |
1544 | 2.26k | if (sc->function) { |
1545 | 2.16k | ExecutionContextScope *exe_scope = |
1546 | 2.16k | exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr0 ; |
1547 | 2.16k | const char *cstr = sc->function->GetName().AsCString(nullptr); |
1548 | 2.16k | if (cstr) { |
1549 | 2.16k | const InlineFunctionInfo *inline_info = nullptr; |
1550 | 2.16k | VariableListSP variable_list_sp; |
1551 | 2.16k | bool get_function_vars = true; |
1552 | 2.16k | if (sc->block) { |
1553 | 2.16k | Block *inline_block = sc->block->GetContainingInlinedBlock(); |
1554 | | |
1555 | 2.16k | if (inline_block) { |
1556 | 18 | get_function_vars = false; |
1557 | 18 | inline_info = sc->block->GetInlinedFunctionInfo(); |
1558 | 18 | if (inline_info) |
1559 | 18 | variable_list_sp = inline_block->GetBlockVariableList(true); |
1560 | 18 | } |
1561 | 2.16k | } |
1562 | | |
1563 | 2.16k | if (get_function_vars) { |
1564 | 2.14k | variable_list_sp = |
1565 | 2.14k | sc->function->GetBlock(true).GetBlockVariableList(true); |
1566 | 2.14k | } |
1567 | | |
1568 | 2.16k | if (inline_info) { |
1569 | 18 | s.PutCString(cstr); |
1570 | 18 | s.PutCString(" [inlined] "); |
1571 | 18 | cstr = inline_info->GetName().GetCString(); |
1572 | 18 | } |
1573 | | |
1574 | 2.16k | VariableList args; |
1575 | 2.16k | if (variable_list_sp) |
1576 | 2.16k | variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument, |
1577 | 2.16k | args); |
1578 | 2.16k | if (args.GetSize() > 0) { |
1579 | 1.17k | if (!PrettyPrintFunctionNameWithArgs(s, cstr, exe_scope, args)) |
1580 | 460 | return false; |
1581 | 1.17k | } else { |
1582 | 982 | s.PutCString(cstr); |
1583 | 982 | } |
1584 | 1.70k | return true; |
1585 | 2.16k | } |
1586 | 2.16k | } else if (105 sc->symbol105 ) { |
1587 | 105 | const char *cstr = sc->symbol->GetName().AsCString(nullptr); |
1588 | 105 | if (cstr) { |
1589 | 105 | s.PutCString(cstr); |
1590 | 105 | return true; |
1591 | 105 | } |
1592 | 105 | } |
1593 | 2.26k | } break0 ; |
1594 | 137 | default: |
1595 | 137 | return false; |
1596 | 2.40k | } |
1597 | | |
1598 | 0 | return false; |
1599 | 2.40k | } |