Coverage Report

Created: 2023-11-11 10:31

/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
}