Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Demangle/ItaniumDemangle.h
Line
Count
Source (jump to first uncovered line)
1
//===------------------------- ItaniumDemangle.h ----------------*- C++ -*-===//
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
// Generic itanium demangler library. This file has two byte-per-byte identical
10
// copies in the source tree, one in libcxxabi, and the other in llvm.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef DEMANGLE_ITANIUMDEMANGLE_H
15
#define DEMANGLE_ITANIUMDEMANGLE_H
16
17
// FIXME: (possibly) incomplete list of features that clang mangles that this
18
// file does not yet support:
19
//   - C++ modules TS
20
21
#include "DemangleConfig.h"
22
#include "StringView.h"
23
#include "Utility.h"
24
#include <cassert>
25
#include <cctype>
26
#include <cstdio>
27
#include <cstdlib>
28
#include <cstring>
29
#include <numeric>
30
#include <utility>
31
32
#define FOR_EACH_NODE_KIND(X) \
33
0
    X(NodeArrayNode) \
34
0
    X(DotSuffix) \
35
0
    X(VendorExtQualType) \
36
2
    X(QualType) \
37
2
    
X1
(ConversionOperatorType) \
38
1
    
X0
(PostfixQualifiedType) \
39
0
    X(ElaboratedTypeSpefType) \
40
1.02k
    X(NameType) \
41
1.02k
    
X0
(AbiTagAttr) \
42
0
    X(EnableIfAttr) \
43
0
    X(ObjCProtoName) \
44
6
    X(PointerType) \
45
16
    X(ReferenceType) \
46
16
    
X0
(PointerToMemberType) \
47
14
    X(ArrayType) \
48
14
    
X0
(FunctionType) \
49
0
    X(NoexceptSpec) \
50
0
    X(DynamicExceptionSpec) \
51
190
    X(FunctionEncoding) \
52
190
    
X0
(LiteralOperator) \
53
0
    X(SpecialName) \
54
0
    X(CtorVtableSpecialName) \
55
0
    X(QualifiedName) \
56
301
    X(NestedName) \
57
301
    
X3
(LocalName) \
58
3
    
X0
(VectorType) \
59
0
    X(PixelVectorType) \
60
0
    X(ParameterPack) \
61
0
    X(TemplateArgumentPack) \
62
0
    X(ParameterPackExpansion) \
63
234
    X(TemplateArgs) \
64
234
    
X0
(ForwardTemplateReference) \
65
195
    X(NameWithTemplateArgs) \
66
195
    
X0
(GlobalQualifiedName) \
67
0
    X(StdQualifiedName) \
68
0
    X(ExpandedSpecialSubstitution) \
69
31
    X(SpecialSubstitution) \
70
31
    
X9
(CtorDtorName) \
71
9
    
X0
(DtorName) \
72
0
    X(UnnamedTypeName) \
73
0
    X(ClosureTypeName) \
74
0
    X(StructuredBindingName) \
75
0
    X(BinaryExpr) \
76
0
    X(ArraySubscriptExpr) \
77
0
    X(PostfixExpr) \
78
0
    X(ConditionalExpr) \
79
0
    X(MemberExpr) \
80
0
    X(EnclosingExpr) \
81
0
    X(CastExpr) \
82
0
    X(SizeofParamPackExpr) \
83
0
    X(CallExpr) \
84
0
    X(NewExpr) \
85
0
    X(DeleteExpr) \
86
0
    X(PrefixExpr) \
87
0
    X(FunctionParam) \
88
0
    X(ConversionExpr) \
89
0
    X(InitListExpr) \
90
0
    X(FoldExpr) \
91
0
    X(ThrowExpr) \
92
0
    X(UUIDOfExpr) \
93
0
    X(BoolExpr) \
94
0
    X(IntegerCastExpr) \
95
0
    X(IntegerLiteral) \
96
0
    X(FloatLiteral) \
97
0
    X(DoubleLiteral) \
98
0
    X(LongDoubleLiteral) \
99
0
    X(BracedExpr) \
100
0
    X(BracedRangeExpr)
101
0
102
0
DEMANGLE_NAMESPACE_BEGIN
103
0
104
0
// Base class of all AST nodes. The AST is built by the parser, then is
105
0
// traversed by the printLeft/Right functions to produce a demangled string.
106
0
class Node {
107
0
public:
108
0
  enum Kind : unsigned char {
109
0
#define ENUMERATOR(NodeKind) K ## NodeKind,
110
0
    FOR_EACH_NODE_KIND(ENUMERATOR)
111
0
#undef ENUMERATOR
112
0
  };
113
0
114
0
  /// Three-way bool to track a cached value. Unknown is possible if this node
115
0
  /// has an unexpanded parameter pack below it that may affect this cache.
116
0
  enum class Cache : unsigned char { Yes, No, Unknown, };
117
0
118
0
private:
119
0
  Kind K;
120
0
121
0
  // FIXME: Make these protected.
122
0
public:
123
0
  /// Tracks if this node has a component on its right side, in which case we
124
0
  /// need to call printRight.
125
0
  Cache RHSComponentCache;
126
0
127
0
  /// Track if this node is a (possibly qualified) array type. This can affect
128
0
  /// how we format the output string.
129
0
  Cache ArrayCache;
130
0
131
0
  /// Track if this node is a (possibly qualified) function type. This can
132
0
  /// affect how we format the output string.
133
0
  Cache FunctionCache;
134
0
135
0
public:
136
0
  Node(Kind K_, Cache RHSComponentCache_ = Cache::No,
137
0
       Cache ArrayCache_ = Cache::No, Cache FunctionCache_ = Cache::No)
138
0
      : K(K_), RHSComponentCache(RHSComponentCache_), ArrayCache(ArrayCache_),
139
9.07k
        FunctionCache(FunctionCache_) {}
140
141
  /// Visit the most-derived object corresponding to this object.
142
  template<typename Fn> void visit(Fn F) const;
143
144
  // The following function is provided by all derived classes:
145
  //
146
  // Call F with arguments that, when passed to the constructor of this node,
147
  // would construct an equivalent node.
148
  //template<typename Fn> void match(Fn F) const;
149
150
3
  bool hasRHSComponent(OutputStream &S) const {
151
3
    if (RHSComponentCache != Cache::Unknown)
152
3
      return RHSComponentCache == Cache::Yes;
153
0
    return hasRHSComponentSlow(S);
154
0
  }
155
156
121
  bool hasArray(OutputStream &S) const {
157
121
    if (ArrayCache != Cache::Unknown)
158
109
      return ArrayCache == Cache::Yes;
159
12
    return hasArraySlow(S);
160
12
  }
161
162
60
  bool hasFunction(OutputStream &S) const {
163
60
    if (FunctionCache != Cache::Unknown)
164
56
      return FunctionCache == Cache::Yes;
165
4
    return hasFunctionSlow(S);
166
4
  }
167
168
482
  Kind getKind() const { return K; }
169
170
0
  virtual bool hasRHSComponentSlow(OutputStream &) const { return false; }
171
0
  virtual bool hasArraySlow(OutputStream &) const { return false; }
172
0
  virtual bool hasFunctionSlow(OutputStream &) const { return false; }
173
174
  // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
175
  // get at a node that actually represents some concrete syntax.
176
2
  virtual const Node *getSyntaxNode(OutputStream &) const {
177
2
    return this;
178
2
  }
179
180
10.4k
  void print(OutputStream &S) const {
181
10.4k
    printLeft(S);
182
10.4k
    if (RHSComponentCache != Cache::No)
183
1.95k
      printRight(S);
184
10.4k
  }
185
186
  // Print the "left" side of this Node into OutputStream.
187
  virtual void printLeft(OutputStream &) const = 0;
188
189
  // Print the "right". This distinction is necessary to represent C++ types
190
  // that appear on the RHS of their subtype, such as arrays or functions.
191
  // Since most types don't have such a component, provide a default
192
  // implementation.
193
8
  virtual void printRight(OutputStream &) const {}
194
195
0
  virtual StringView getBaseName() const { return StringView(); }
196
197
  // Silence compiler warnings, this dtor will never be called.
198
0
  virtual ~Node() = default;
199
200
#ifndef NDEBUG
201
  DEMANGLE_DUMP_METHOD void dump() const;
202
#endif
203
};
204
205
class NodeArray {
206
  Node **Elements;
207
  size_t NumElements;
208
209
public:
210
136
  NodeArray() : Elements(nullptr), NumElements(0) {}
211
  NodeArray(Node **Elements_, size_t NumElements_)
212
2.34k
      : Elements(Elements_), NumElements(NumElements_) {}
213
214
0
  bool empty() const { return NumElements == 0; }
215
890
  size_t size() const { return NumElements; }
216
217
882
  Node **begin() const { return Elements; }
218
882
  Node **end() const { return Elements + NumElements; }
219
220
15
  Node *operator[](size_t Idx) const { return Elements[Idx]; }
221
222
2.00k
  void printWithComma(OutputStream &S) const {
223
2.00k
    bool FirstElement = true;
224
5.51k
    for (size_t Idx = 0; Idx != NumElements; 
++Idx3.51k
) {
225
3.51k
      size_t BeforeComma = S.getCurrentPosition();
226
3.51k
      if (!FirstElement)
227
1.58k
        S += ", ";
228
3.51k
      size_t AfterComma = S.getCurrentPosition();
229
3.51k
      Elements[Idx]->print(S);
230
3.51k
231
3.51k
      // Elements[Idx] is an empty parameter pack expansion, we should erase the
232
3.51k
      // comma we just printed.
233
3.51k
      if (AfterComma == S.getCurrentPosition()) {
234
0
        S.setCurrentPosition(BeforeComma);
235
0
        continue;
236
0
      }
237
3.51k
238
3.51k
      FirstElement = false;
239
3.51k
    }
240
2.00k
  }
241
};
242
243
struct NodeArrayNode : Node {
244
  NodeArray Array;
245
0
  NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
246
247
0
  template<typename Fn> void match(Fn F) const { F(Array); }
248
249
0
  void printLeft(OutputStream &S) const override {
250
0
    Array.printWithComma(S);
251
0
  }
252
};
253
254
class DotSuffix final : public Node {
255
  const Node *Prefix;
256
  const StringView Suffix;
257
258
public:
259
  DotSuffix(const Node *Prefix_, StringView Suffix_)
260
0
      : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
261
262
0
  template<typename Fn> void match(Fn F) const { F(Prefix, Suffix); }
263
264
0
  void printLeft(OutputStream &s) const override {
265
0
    Prefix->print(s);
266
0
    s += " (";
267
0
    s += Suffix;
268
0
    s += ")";
269
0
  }
270
};
271
272
class VendorExtQualType final : public Node {
273
  const Node *Ty;
274
  StringView Ext;
275
276
public:
277
  VendorExtQualType(const Node *Ty_, StringView Ext_)
278
0
      : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_) {}
279
280
0
  template<typename Fn> void match(Fn F) const { F(Ty, Ext); }
281
282
0
  void printLeft(OutputStream &S) const override {
283
0
    Ty->print(S);
284
0
    S += " ";
285
0
    S += Ext;
286
0
  }
287
};
288
289
enum FunctionRefQual : unsigned char {
290
  FrefQualNone,
291
  FrefQualLValue,
292
  FrefQualRValue,
293
};
294
295
enum Qualifiers {
296
  QualNone = 0,
297
  QualConst = 0x1,
298
  QualVolatile = 0x2,
299
  QualRestrict = 0x4,
300
};
301
302
41
inline Qualifiers operator|=(Qualifiers &Q1, Qualifiers Q2) {
303
41
  return Q1 = static_cast<Qualifiers>(Q1 | Q2);
304
41
}
305
306
class QualType : public Node {
307
protected:
308
  const Qualifiers Quals;
309
  const Node *Child;
310
311
26
  void printQuals(OutputStream &S) const {
312
26
    if (Quals & QualConst)
313
26
      S += " const";
314
26
    if (Quals & QualVolatile)
315
0
      S += " volatile";
316
26
    if (Quals & QualRestrict)
317
0
      S += " restrict";
318
26
  }
319
320
public:
321
  QualType(const Node *Child_, Qualifiers Quals_)
322
      : Node(KQualType, Child_->RHSComponentCache,
323
             Child_->ArrayCache, Child_->FunctionCache),
324
26
        Quals(Quals_), Child(Child_) {}
325
326
2
  template<typename Fn> void match(Fn F) const { F(Child, Quals); }
327
328
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
329
0
    return Child->hasRHSComponent(S);
330
0
  }
331
0
  bool hasArraySlow(OutputStream &S) const override {
332
0
    return Child->hasArray(S);
333
0
  }
334
0
  bool hasFunctionSlow(OutputStream &S) const override {
335
0
    return Child->hasFunction(S);
336
0
  }
337
338
26
  void printLeft(OutputStream &S) const override {
339
26
    Child->printLeft(S);
340
26
    printQuals(S);
341
26
  }
342
343
0
  void printRight(OutputStream &S) const override { Child->printRight(S); }
344
};
345
346
class ConversionOperatorType final : public Node {
347
  const Node *Ty;
348
349
public:
350
  ConversionOperatorType(const Node *Ty_)
351
8
      : Node(KConversionOperatorType), Ty(Ty_) {}
352
353
1
  template<typename Fn> void match(Fn F) const { F(Ty); }
354
355
1
  void printLeft(OutputStream &S) const override {
356
1
    S += "operator ";
357
1
    Ty->print(S);
358
1
  }
359
};
360
361
class PostfixQualifiedType final : public Node {
362
  const Node *Ty;
363
  const StringView Postfix;
364
365
public:
366
  PostfixQualifiedType(Node *Ty_, StringView Postfix_)
367
0
      : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
368
369
0
  template<typename Fn> void match(Fn F) const { F(Ty, Postfix); }
370
371
0
  void printLeft(OutputStream &s) const override {
372
0
    Ty->printLeft(s);
373
0
    s += Postfix;
374
0
  }
375
};
376
377
class NameType final : public Node {
378
  const StringView Name;
379
380
public:
381
4.74k
  NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
382
383
1.02k
  template<typename Fn> void match(Fn F) const { F(Name); }
384
385
0
  StringView getName() const { return Name; }
386
7
  StringView getBaseName() const override { return Name; }
387
388
5.57k
  void printLeft(OutputStream &s) const override { s += Name; }
389
};
390
391
class ElaboratedTypeSpefType : public Node {
392
  StringView Kind;
393
  Node *Child;
394
public:
395
  ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
396
0
      : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
397
398
0
  template<typename Fn> void match(Fn F) const { F(Kind, Child); }
399
400
0
  void printLeft(OutputStream &S) const override {
401
0
    S += Kind;
402
0
    S += ' ';
403
0
    Child->print(S);
404
0
  }
405
};
406
407
struct AbiTagAttr : Node {
408
  Node *Base;
409
  StringView Tag;
410
411
  AbiTagAttr(Node* Base_, StringView Tag_)
412
      : Node(KAbiTagAttr, Base_->RHSComponentCache,
413
             Base_->ArrayCache, Base_->FunctionCache),
414
6
        Base(Base_), Tag(Tag_) {}
415
416
0
  template<typename Fn> void match(Fn F) const { F(Base, Tag); }
417
418
3
  void printLeft(OutputStream &S) const override {
419
3
    Base->printLeft(S);
420
3
    S += "[abi:";
421
3
    S += Tag;
422
3
    S += "]";
423
3
  }
424
};
425
426
class EnableIfAttr : public Node {
427
  NodeArray Conditions;
428
public:
429
  EnableIfAttr(NodeArray Conditions_)
430
1
      : Node(KEnableIfAttr), Conditions(Conditions_) {}
431
432
0
  template<typename Fn> void match(Fn F) const { F(Conditions); }
433
434
0
  void printLeft(OutputStream &S) const override {
435
0
    S += " [enable_if:";
436
0
    Conditions.printWithComma(S);
437
0
    S += ']';
438
0
  }
439
};
440
441
class ObjCProtoName : public Node {
442
  const Node *Ty;
443
  StringView Protocol;
444
445
  friend class PointerType;
446
447
public:
448
  ObjCProtoName(const Node *Ty_, StringView Protocol_)
449
0
      : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
450
451
0
  template<typename Fn> void match(Fn F) const { F(Ty, Protocol); }
452
453
0
  bool isObjCObject() const {
454
0
    return Ty->getKind() == KNameType &&
455
0
           static_cast<const NameType *>(Ty)->getName() == "objc_object";
456
0
  }
457
458
0
  void printLeft(OutputStream &S) const override {
459
0
    Ty->print(S);
460
0
    S += "<";
461
0
    S += Protocol;
462
0
    S += ">";
463
0
  }
464
};
465
466
class PointerType final : public Node {
467
  const Node *Pointee;
468
469
public:
470
  PointerType(const Node *Pointee_)
471
      : Node(KPointerType, Pointee_->RHSComponentCache),
472
50
        Pointee(Pointee_) {}
473
474
6
  template<typename Fn> void match(Fn F) const { F(Pointee); }
475
476
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
477
0
    return Pointee->hasRHSComponent(S);
478
0
  }
479
480
49
  void printLeft(OutputStream &s) const override {
481
49
    // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
482
49
    if (Pointee->getKind() != KObjCProtoName ||
483
49
        
!static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()0
) {
484
49
      Pointee->printLeft(s);
485
49
      if (Pointee->hasArray(s))
486
1
        s += " ";
487
49
      if (Pointee->hasArray(s) || 
Pointee->hasFunction(s)48
)
488
5
        s += "(";
489
49
      s += "*";
490
49
    } else {
491
0
      const auto *objcProto = static_cast<const ObjCProtoName *>(Pointee);
492
0
      s += "id<";
493
0
      s += objcProto->Protocol;
494
0
      s += ">";
495
0
    }
496
49
  }
497
498
7
  void printRight(OutputStream &s) const override {
499
7
    if (Pointee->getKind() != KObjCProtoName ||
500
7
        
!static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()0
) {
501
7
      if (Pointee->hasArray(s) || 
Pointee->hasFunction(s)6
)
502
5
        s += ")";
503
7
      Pointee->printRight(s);
504
7
    }
505
7
  }
506
};
507
508
enum class ReferenceKind {
509
  LValue,
510
  RValue,
511
};
512
513
// Represents either a LValue or an RValue reference type.
514
class ReferenceType : public Node {
515
  const Node *Pointee;
516
  ReferenceKind RK;
517
518
  mutable bool Printing = false;
519
520
  // Dig through any refs to refs, collapsing the ReferenceTypes as we go. The
521
  // rule here is rvalue ref to rvalue ref collapses to a rvalue ref, and any
522
  // other combination collapses to a lvalue ref.
523
2
  std::pair<ReferenceKind, const Node *> collapse(OutputStream &S) const {
524
2
    auto SoFar = std::make_pair(RK, Pointee);
525
2
    for (;;) {
526
2
      const Node *SN = SoFar.second->getSyntaxNode(S);
527
2
      if (SN->getKind() != KReferenceType)
528
2
        break;
529
0
      auto *RT = static_cast<const ReferenceType *>(SN);
530
0
      SoFar.second = RT->Pointee;
531
0
      SoFar.first = std::min(SoFar.first, RT->RK);
532
0
    }
533
2
    return SoFar;
534
2
  }
535
536
public:
537
  ReferenceType(const Node *Pointee_, ReferenceKind RK_)
538
      : Node(KReferenceType, Pointee_->RHSComponentCache),
539
14
        Pointee(Pointee_), RK(RK_) {}
540
541
16
  template<typename Fn> void match(Fn F) const { F(Pointee, RK); }
542
543
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
544
0
    return Pointee->hasRHSComponent(S);
545
0
  }
546
547
2
  void printLeft(OutputStream &s) const override {
548
2
    if (Printing)
549
0
      return;
550
2
    SwapAndRestore<bool> SavePrinting(Printing, true);
551
2
    std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
552
2
    Collapsed.second->printLeft(s);
553
2
    if (Collapsed.second->hasArray(s))
554
0
      s += " ";
555
2
    if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
556
0
      s += "(";
557
2
558
2
    s += (Collapsed.first == ReferenceKind::LValue ? "&" : 
"&&"0
);
559
2
  }
560
0
  void printRight(OutputStream &s) const override {
561
0
    if (Printing)
562
0
      return;
563
0
    SwapAndRestore<bool> SavePrinting(Printing, true);
564
0
    std::pair<ReferenceKind, const Node *> Collapsed = collapse(s);
565
0
    if (Collapsed.second->hasArray(s) || Collapsed.second->hasFunction(s))
566
0
      s += ")";
567
0
    Collapsed.second->printRight(s);
568
0
  }
569
};
570
571
class PointerToMemberType final : public Node {
572
  const Node *ClassType;
573
  const Node *MemberType;
574
575
public:
576
  PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
577
      : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
578
0
        ClassType(ClassType_), MemberType(MemberType_) {}
579
580
0
  template<typename Fn> void match(Fn F) const { F(ClassType, MemberType); }
581
582
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
583
0
    return MemberType->hasRHSComponent(S);
584
0
  }
585
586
0
  void printLeft(OutputStream &s) const override {
587
0
    MemberType->printLeft(s);
588
0
    if (MemberType->hasArray(s) || MemberType->hasFunction(s))
589
0
      s += "(";
590
0
    else
591
0
      s += " ";
592
0
    ClassType->print(s);
593
0
    s += "::*";
594
0
  }
595
596
0
  void printRight(OutputStream &s) const override {
597
0
    if (MemberType->hasArray(s) || MemberType->hasFunction(s))
598
0
      s += ")";
599
0
    MemberType->printRight(s);
600
0
  }
601
};
602
603
class NodeOrString {
604
  const void *First;
605
  const void *Second;
606
607
public:
608
1.65k
  /* implicit */ NodeOrString(StringView Str) {
609
1.65k
    const char *FirstChar = Str.begin();
610
1.65k
    const char *SecondChar = Str.end();
611
1.65k
    if (SecondChar == nullptr) {
612
0
      assert(FirstChar == SecondChar);
613
0
      ++FirstChar, ++SecondChar;
614
0
    }
615
1.65k
    First = static_cast<const void *>(FirstChar);
616
1.65k
    Second = static_cast<const void *>(SecondChar);
617
1.65k
  }
618
619
  /* implicit */ NodeOrString(Node *N)
620
0
      : First(static_cast<const void *>(N)), Second(nullptr) {}
621
18
  NodeOrString() : First(nullptr), Second(nullptr) {}
622
623
2.81k
  bool isString() const { return Second && 
First2.79k
; }
624
2.81k
  bool isNode() const { return First && 
!Second2.79k
; }
625
0
  bool isEmpty() const { return !First && !Second; }
626
627
2.79k
  StringView asString() const {
628
2.79k
    assert(isString());
629
2.79k
    return StringView(static_cast<const char *>(First),
630
2.79k
                      static_cast<const char *>(Second));
631
2.79k
  }
632
633
0
  const Node *asNode() const {
634
0
    assert(isNode());
635
0
    return static_cast<const Node *>(First);
636
0
  }
637
};
638
639
class ArrayType final : public Node {
640
  const Node *Base;
641
  NodeOrString Dimension;
642
643
public:
644
  ArrayType(const Node *Base_, NodeOrString Dimension_)
645
      : Node(KArrayType,
646
             /*RHSComponentCache=*/Cache::Yes,
647
             /*ArrayCache=*/Cache::Yes),
648
9
        Base(Base_), Dimension(Dimension_) {}
649
650
14
  template<typename Fn> void match(Fn F) const { F(Base, Dimension); }
651
652
0
  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
653
0
  bool hasArraySlow(OutputStream &) const override { return true; }
654
655
1
  void printLeft(OutputStream &S) const override { Base->printLeft(S); }
656
657
1
  void printRight(OutputStream &S) const override {
658
1
    if (S.back() != ']')
659
1
      S += " ";
660
1
    S += "[";
661
1
    if (Dimension.isString())
662
0
      S += Dimension.asString();
663
1
    else if (Dimension.isNode())
664
0
      Dimension.asNode()->print(S);
665
1
    S += "]";
666
1
    Base->printRight(S);
667
1
  }
668
};
669
670
class FunctionType final : public Node {
671
  const Node *Ret;
672
  NodeArray Params;
673
  Qualifiers CVQuals;
674
  FunctionRefQual RefQual;
675
  const Node *ExceptionSpec;
676
677
public:
678
  FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
679
               FunctionRefQual RefQual_, const Node *ExceptionSpec_)
680
      : Node(KFunctionType,
681
             /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
682
             /*FunctionCache=*/Cache::Yes),
683
        Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
684
4
        ExceptionSpec(ExceptionSpec_) {}
685
686
0
  template<typename Fn> void match(Fn F) const {
687
0
    F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
688
0
  }
689
690
0
  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
691
0
  bool hasFunctionSlow(OutputStream &) const override { return true; }
692
693
  // Handle C++'s ... quirky decl grammar by using the left & right
694
  // distinction. Consider:
695
  //   int (*f(float))(char) {}
696
  // f is a function that takes a float and returns a pointer to a function
697
  // that takes a char and returns an int. If we're trying to print f, start
698
  // by printing out the return types's left, then print our parameters, then
699
  // finally print right of the return type.
700
4
  void printLeft(OutputStream &S) const override {
701
4
    Ret->printLeft(S);
702
4
    S += " ";
703
4
  }
704
705
4
  void printRight(OutputStream &S) const override {
706
4
    S += "(";
707
4
    Params.printWithComma(S);
708
4
    S += ")";
709
4
    Ret->printRight(S);
710
4
711
4
    if (CVQuals & QualConst)
712
0
      S += " const";
713
4
    if (CVQuals & QualVolatile)
714
0
      S += " volatile";
715
4
    if (CVQuals & QualRestrict)
716
0
      S += " restrict";
717
4
718
4
    if (RefQual == FrefQualLValue)
719
0
      S += " &";
720
4
    else if (RefQual == FrefQualRValue)
721
0
      S += " &&";
722
4
723
4
    if (ExceptionSpec != nullptr) {
724
0
      S += ' ';
725
0
      ExceptionSpec->print(S);
726
0
    }
727
4
  }
728
};
729
730
class NoexceptSpec : public Node {
731
  const Node *E;
732
public:
733
0
  NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
734
735
0
  template<typename Fn> void match(Fn F) const { F(E); }
736
737
0
  void printLeft(OutputStream &S) const override {
738
0
    S += "noexcept(";
739
0
    E->print(S);
740
0
    S += ")";
741
0
  }
742
};
743
744
class DynamicExceptionSpec : public Node {
745
  NodeArray Types;
746
public:
747
  DynamicExceptionSpec(NodeArray Types_)
748
0
      : Node(KDynamicExceptionSpec), Types(Types_) {}
749
750
0
  template<typename Fn> void match(Fn F) const { F(Types); }
751
752
0
  void printLeft(OutputStream &S) const override {
753
0
    S += "throw(";
754
0
    Types.printWithComma(S);
755
0
    S += ')';
756
0
  }
757
};
758
759
class FunctionEncoding final : public Node {
760
  const Node *Ret;
761
  const Node *Name;
762
  NodeArray Params;
763
  const Node *Attrs;
764
  Qualifiers CVQuals;
765
  FunctionRefQual RefQual;
766
767
public:
768
  FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_,
769
                   const Node *Attrs_, Qualifiers CVQuals_,
770
                   FunctionRefQual RefQual_)
771
      : Node(KFunctionEncoding,
772
             /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
773
             /*FunctionCache=*/Cache::Yes),
774
        Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
775
2.07k
        CVQuals(CVQuals_), RefQual(RefQual_) {}
776
777
190
  template<typename Fn> void match(Fn F) const {
778
190
    F(Ret, Name, Params, Attrs, CVQuals, RefQual);
779
190
  }
780
781
2
  Qualifiers getCVQuals() const { return CVQuals; }
782
1
  FunctionRefQual getRefQual() const { return RefQual; }
783
20
  NodeArray getParams() const { return Params; }
784
20
  const Node *getReturnType() const { return Ret; }
785
786
0
  bool hasRHSComponentSlow(OutputStream &) const override { return true; }
787
0
  bool hasFunctionSlow(OutputStream &) const override { return true; }
788
789
50
  const Node *getName() const { return Name; }
790
791
1.94k
  void printLeft(OutputStream &S) const override {
792
1.94k
    if (Ret) {
793
3
      Ret->printLeft(S);
794
3
      if (!Ret->hasRHSComponent(S))
795
3
        S += " ";
796
3
    }
797
1.94k
    Name->print(S);
798
1.94k
  }
799
800
1.94k
  void printRight(OutputStream &S) const override {
801
1.94k
    S += "(";
802
1.94k
    Params.printWithComma(S);
803
1.94k
    S += ")";
804
1.94k
    if (Ret)
805
3
      Ret->printRight(S);
806
1.94k
807
1.94k
    if (CVQuals & QualConst)
808
1
      S += " const";
809
1.94k
    if (CVQuals & QualVolatile)
810
0
      S += " volatile";
811
1.94k
    if (CVQuals & QualRestrict)
812
0
      S += " restrict";
813
1.94k
814
1.94k
    if (RefQual == FrefQualLValue)
815
0
      S += " &";
816
1.94k
    else if (RefQual == FrefQualRValue)
817
0
      S += " &&";
818
1.94k
819
1.94k
    if (Attrs != nullptr)
820
0
      Attrs->print(S);
821
1.94k
  }
822
};
823
824
class LiteralOperator : public Node {
825
  const Node *OpName;
826
827
public:
828
  LiteralOperator(const Node *OpName_)
829
0
      : Node(KLiteralOperator), OpName(OpName_) {}
830
831
0
  template<typename Fn> void match(Fn F) const { F(OpName); }
832
833
0
  void printLeft(OutputStream &S) const override {
834
0
    S += "operator\"\" ";
835
0
    OpName->print(S);
836
0
  }
837
};
838
839
class SpecialName final : public Node {
840
  const StringView Special;
841
  const Node *Child;
842
843
public:
844
  SpecialName(StringView Special_, const Node *Child_)
845
6
      : Node(KSpecialName), Special(Special_), Child(Child_) {}
846
847
0
  template<typename Fn> void match(Fn F) const { F(Special, Child); }
848
849
5
  void printLeft(OutputStream &S) const override {
850
5
    S += Special;
851
5
    Child->print(S);
852
5
  }
853
};
854
855
class CtorVtableSpecialName final : public Node {
856
  const Node *FirstType;
857
  const Node *SecondType;
858
859
public:
860
  CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
861
      : Node(KCtorVtableSpecialName),
862
0
        FirstType(FirstType_), SecondType(SecondType_) {}
863
864
0
  template<typename Fn> void match(Fn F) const { F(FirstType, SecondType); }
865
866
0
  void printLeft(OutputStream &S) const override {
867
0
    S += "construction vtable for ";
868
0
    FirstType->print(S);
869
0
    S += "-in-";
870
0
    SecondType->print(S);
871
0
  }
872
};
873
874
struct NestedName : Node {
875
  Node *Qual;
876
  Node *Name;
877
878
  NestedName(Node *Qual_, Node *Name_)
879
202
      : Node(KNestedName), Qual(Qual_), Name(Name_) {}
880
881
301
  template<typename Fn> void match(Fn F) const { F(Qual, Name); }
882
883
0
  StringView getBaseName() const override { return Name->getBaseName(); }
884
885
35
  void printLeft(OutputStream &S) const override {
886
35
    Qual->print(S);
887
35
    S += "::";
888
35
    Name->print(S);
889
35
  }
890
};
891
892
struct LocalName : Node {
893
  Node *Encoding;
894
  Node *Entity;
895
896
  LocalName(Node *Encoding_, Node *Entity_)
897
7
      : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
898
899
3
  template<typename Fn> void match(Fn F) const { F(Encoding, Entity); }
900
901
1
  void printLeft(OutputStream &S) const override {
902
1
    Encoding->print(S);
903
1
    S += "::";
904
1
    Entity->print(S);
905
1
  }
906
};
907
908
class QualifiedName final : public Node {
909
  // qualifier::name
910
  const Node *Qualifier;
911
  const Node *Name;
912
913
public:
914
  QualifiedName(const Node *Qualifier_, const Node *Name_)
915
0
      : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
916
917
0
  template<typename Fn> void match(Fn F) const { F(Qualifier, Name); }
918
919
0
  StringView getBaseName() const override { return Name->getBaseName(); }
920
921
0
  void printLeft(OutputStream &S) const override {
922
0
    Qualifier->print(S);
923
0
    S += "::";
924
0
    Name->print(S);
925
0
  }
926
};
927
928
class VectorType final : public Node {
929
  const Node *BaseType;
930
  const NodeOrString Dimension;
931
932
public:
933
  VectorType(const Node *BaseType_, NodeOrString Dimension_)
934
      : Node(KVectorType), BaseType(BaseType_),
935
1.64k
        Dimension(Dimension_) {}
936
937
0
  template<typename Fn> void match(Fn F) const { F(BaseType, Dimension); }
938
939
2.78k
  void printLeft(OutputStream &S) const override {
940
2.78k
    BaseType->print(S);
941
2.78k
    S += " vector[";
942
2.78k
    if (Dimension.isNode())
943
0
      Dimension.asNode()->print(S);
944
2.78k
    else if (Dimension.isString())
945
2.78k
      S += Dimension.asString();
946
2.78k
    S += "]";
947
2.78k
  }
948
};
949
950
class PixelVectorType final : public Node {
951
  const NodeOrString Dimension;
952
953
public:
954
  PixelVectorType(NodeOrString Dimension_)
955
0
      : Node(KPixelVectorType), Dimension(Dimension_) {}
956
957
0
  template<typename Fn> void match(Fn F) const { F(Dimension); }
958
959
0
  void printLeft(OutputStream &S) const override {
960
0
    // FIXME: This should demangle as "vector pixel".
961
0
    S += "pixel vector[";
962
0
    S += Dimension.asString();
963
0
    S += "]";
964
0
  }
965
};
966
967
/// An unexpanded parameter pack (either in the expression or type context). If
968
/// this AST is correct, this node will have a ParameterPackExpansion node above
969
/// it.
970
///
971
/// This node is created when some <template-args> are found that apply to an
972
/// <encoding>, and is stored in the TemplateParams table. In order for this to
973
/// appear in the final AST, it has to referenced via a <template-param> (ie,
974
/// T_).
975
class ParameterPack final : public Node {
976
  NodeArray Data;
977
978
  // Setup OutputStream for a pack expansion unless we're already expanding one.
979
15
  void initializePackExpansion(OutputStream &S) const {
980
15
    if (S.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
981
2
      S.CurrentPackMax = static_cast<unsigned>(Data.size());
982
2
      S.CurrentPackIndex = 0;
983
2
    }
984
15
  }
985
986
public:
987
3
  ParameterPack(NodeArray Data_) : Node(KParameterPack), Data(Data_) {
988
3
    ArrayCache = FunctionCache = RHSComponentCache = Cache::Unknown;
989
8
    if (
std::all_of(Data.begin(), Data.end(), [](Node* P) 3
{
990
8
          return P->ArrayCache == Cache::No;
991
8
        }))
992
2
      ArrayCache = Cache::No;
993
7
    if (
std::all_of(Data.begin(), Data.end(), [](Node* P) 3
{
994
7
          return P->FunctionCache == Cache::No;
995
7
        }))
996
2
      FunctionCache = Cache::No;
997
7
    if (
std::all_of(Data.begin(), Data.end(), [](Node* P) 3
{
998
7
          return P->RHSComponentCache == Cache::No;
999
7
        }))
1000
2
      RHSComponentCache = Cache::No;
1001
3
  }
1002
1003
0
  template<typename Fn> void match(Fn F) const { F(Data); }
1004
1005
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
1006
0
    initializePackExpansion(S);
1007
0
    size_t Idx = S.CurrentPackIndex;
1008
0
    return Idx < Data.size() && Data[Idx]->hasRHSComponent(S);
1009
0
  }
1010
6
  bool hasArraySlow(OutputStream &S) const override {
1011
6
    initializePackExpansion(S);
1012
6
    size_t Idx = S.CurrentPackIndex;
1013
6
    return Idx < Data.size() && Data[Idx]->hasArray(S);
1014
6
  }
1015
2
  bool hasFunctionSlow(OutputStream &S) const override {
1016
2
    initializePackExpansion(S);
1017
2
    size_t Idx = S.CurrentPackIndex;
1018
2
    return Idx < Data.size() && Data[Idx]->hasFunction(S);
1019
2
  }
1020
0
  const Node *getSyntaxNode(OutputStream &S) const override {
1021
0
    initializePackExpansion(S);
1022
0
    size_t Idx = S.CurrentPackIndex;
1023
0
    return Idx < Data.size() ? Data[Idx]->getSyntaxNode(S) : this;
1024
0
  }
1025
1026
5
  void printLeft(OutputStream &S) const override {
1027
5
    initializePackExpansion(S);
1028
5
    size_t Idx = S.CurrentPackIndex;
1029
5
    if (Idx < Data.size())
1030
5
      Data[Idx]->printLeft(S);
1031
5
  }
1032
2
  void printRight(OutputStream &S) const override {
1033
2
    initializePackExpansion(S);
1034
2
    size_t Idx = S.CurrentPackIndex;
1035
2
    if (Idx < Data.size())
1036
2
      Data[Idx]->printRight(S);
1037
2
  }
1038
};
1039
1040
/// A variadic template argument. This node represents an occurrence of
1041
/// J<something>E in some <template-args>. It isn't itself unexpanded, unless
1042
/// one of it's Elements is. The parser inserts a ParameterPack into the
1043
/// TemplateParams table if the <template-args> this pack belongs to apply to an
1044
/// <encoding>.
1045
class TemplateArgumentPack final : public Node {
1046
  NodeArray Elements;
1047
public:
1048
  TemplateArgumentPack(NodeArray Elements_)
1049
4
      : Node(KTemplateArgumentPack), Elements(Elements_) {}
1050
1051
0
  template<typename Fn> void match(Fn F) const { F(Elements); }
1052
1053
3
  NodeArray getElements() const { return Elements; }
1054
1055
2
  void printLeft(OutputStream &S) const override {
1056
2
    Elements.printWithComma(S);
1057
2
  }
1058
};
1059
1060
/// A pack expansion. Below this node, there are some unexpanded ParameterPacks
1061
/// which each have Child->ParameterPackSize elements.
1062
class ParameterPackExpansion final : public Node {
1063
  const Node *Child;
1064
1065
public:
1066
  ParameterPackExpansion(const Node *Child_)
1067
2
      : Node(KParameterPackExpansion), Child(Child_) {}
1068
1069
0
  template<typename Fn> void match(Fn F) const { F(Child); }
1070
1071
0
  const Node *getChild() const { return Child; }
1072
1073
2
  void printLeft(OutputStream &S) const override {
1074
2
    constexpr unsigned Max = std::numeric_limits<unsigned>::max();
1075
2
    SwapAndRestore<unsigned> SavePackIdx(S.CurrentPackIndex, Max);
1076
2
    SwapAndRestore<unsigned> SavePackMax(S.CurrentPackMax, Max);
1077
2
    size_t StreamPos = S.getCurrentPosition();
1078
2
1079
2
    // Print the first element in the pack. If Child contains a ParameterPack,
1080
2
    // it will set up S.CurrentPackMax and print the first element.
1081
2
    Child->print(S);
1082
2
1083
2
    // No ParameterPack was found in Child. This can occur if we've found a pack
1084
2
    // expansion on a <function-param>.
1085
2
    if (S.CurrentPackMax == Max) {
1086
0
      S += "...";
1087
0
      return;
1088
0
    }
1089
2
1090
2
    // We found a ParameterPack, but it has no elements. Erase whatever we may
1091
2
    // of printed.
1092
2
    if (S.CurrentPackMax == 0) {
1093
0
      S.setCurrentPosition(StreamPos);
1094
0
      return;
1095
0
    }
1096
2
1097
2
    // Else, iterate through the rest of the elements in the pack.
1098
5
    
for (unsigned I = 1, E = S.CurrentPackMax; 2
I < E;
++I3
) {
1099
3
      S += ", ";
1100
3
      S.CurrentPackIndex = I;
1101
3
      Child->print(S);
1102
3
    }
1103
2
  }
1104
};
1105
1106
class TemplateArgs final : public Node {
1107
  NodeArray Params;
1108
1109
public:
1110
87
  TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
1111
1112
234
  template<typename Fn> void match(Fn F) const { F(Params); }
1113
1114
0
  NodeArray getParams() { return Params; }
1115
1116
26
  void printLeft(OutputStream &S) const override {
1117
26
    S += "<";
1118
26
    Params.printWithComma(S);
1119
26
    if (S.back() == '>')
1120
3
      S += " ";
1121
26
    S += ">";
1122
26
  }
1123
};
1124
1125
/// A forward-reference to a template argument that was not known at the point
1126
/// where the template parameter name was parsed in a mangling.
1127
///
1128
/// This is created when demangling the name of a specialization of a
1129
/// conversion function template:
1130
///
1131
/// \code
1132
/// struct A {
1133
///   template<typename T> operator T*();
1134
/// };
1135
/// \endcode
1136
///
1137
/// When demangling a specialization of the conversion function template, we
1138
/// encounter the name of the template (including the \c T) before we reach
1139
/// the template argument list, so we cannot substitute the parameter name
1140
/// for the corresponding argument while parsing. Instead, we create a
1141
/// \c ForwardTemplateReference node that is resolved after we parse the
1142
/// template arguments.
1143
struct ForwardTemplateReference : Node {
1144
  size_t Index;
1145
  Node *Ref = nullptr;
1146
1147
  // If we're currently printing this node. It is possible (though invalid) for
1148
  // a forward template reference to refer to itself via a substitution. This
1149
  // creates a cyclic AST, which will stack overflow printing. To fix this, bail
1150
  // out if more than one print* function is active.
1151
  mutable bool Printing = false;
1152
1153
  ForwardTemplateReference(size_t Index_)
1154
      : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown,
1155
             Cache::Unknown),
1156
8
        Index(Index_) {}
1157
1158
  // We don't provide a matcher for these, because the value of the node is
1159
  // not determined by its construction parameters, and it generally needs
1160
  // special handling.
1161
  template<typename Fn> void match(Fn F) const = delete;
1162
1163
0
  bool hasRHSComponentSlow(OutputStream &S) const override {
1164
0
    if (Printing)
1165
0
      return false;
1166
0
    SwapAndRestore<bool> SavePrinting(Printing, true);
1167
0
    return Ref->hasRHSComponent(S);
1168
0
  }
1169
6
  bool hasArraySlow(OutputStream &S) const override {
1170
6
    if (Printing)
1171
0
      return false;
1172
6
    SwapAndRestore<bool> SavePrinting(Printing, true);
1173
6
    return Ref->hasArray(S);
1174
6
  }
1175
2
  bool hasFunctionSlow(OutputStream &S) const override {
1176
2
    if (Printing)
1177
0
      return false;
1178
2
    SwapAndRestore<bool> SavePrinting(Printing, true);
1179
2
    return Ref->hasFunction(S);
1180
2
  }
1181
0
  const Node *getSyntaxNode(OutputStream &S) const override {
1182
0
    if (Printing)
1183
0
      return this;
1184
0
    SwapAndRestore<bool> SavePrinting(Printing, true);
1185
0
    return Ref->getSyntaxNode(S);
1186
0
  }
1187
1188
2
  void printLeft(OutputStream &S) const override {
1189
2
    if (Printing)
1190
0
      return;
1191
2
    SwapAndRestore<bool> SavePrinting(Printing, true);
1192
2
    Ref->printLeft(S);
1193
2
  }
1194
2
  void printRight(OutputStream &S) const override {
1195
2
    if (Printing)
1196
0
      return;
1197
2
    SwapAndRestore<bool> SavePrinting(Printing, true);
1198
2
    Ref->printRight(S);
1199
2
  }
1200
};
1201
1202
struct NameWithTemplateArgs : Node {
1203
  // name<template_args>
1204
  Node *Name;
1205
  Node *TemplateArgs;
1206
1207
  NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
1208
111
      : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
1209
1210
195
  template<typename Fn> void match(Fn F) const { F(Name, TemplateArgs); }
1211
1212
11
  StringView getBaseName() const override { return Name->getBaseName(); }
1213
1214
26
  void printLeft(OutputStream &S) const override {
1215
26
    Name->print(S);
1216
26
    TemplateArgs->print(S);
1217
26
  }
1218
};
1219
1220
class GlobalQualifiedName final : public Node {
1221
  Node *Child;
1222
1223
public:
1224
  GlobalQualifiedName(Node* Child_)
1225
0
      : Node(KGlobalQualifiedName), Child(Child_) {}
1226
1227
0
  template<typename Fn> void match(Fn F) const { F(Child); }
1228
1229
0
  StringView getBaseName() const override { return Child->getBaseName(); }
1230
1231
0
  void printLeft(OutputStream &S) const override {
1232
0
    S += "::";
1233
0
    Child->print(S);
1234
0
  }
1235
};
1236
1237
struct StdQualifiedName : Node {
1238
  Node *Child;
1239
1240
6
  StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
1241
1242
0
  template<typename Fn> void match(Fn F) const { F(Child); }
1243
1244
0
  StringView getBaseName() const override { return Child->getBaseName(); }
1245
1246
5
  void printLeft(OutputStream &S) const override {
1247
5
    S += "std::";
1248
5
    Child->print(S);
1249
5
  }
1250
};
1251
1252
enum class SpecialSubKind {
1253
  allocator,
1254
  basic_string,
1255
  string,
1256
  istream,
1257
  ostream,
1258
  iostream,
1259
};
1260
1261
class ExpandedSpecialSubstitution final : public Node {
1262
  SpecialSubKind SSK;
1263
1264
public:
1265
  ExpandedSpecialSubstitution(SpecialSubKind SSK_)
1266
1
      : Node(KExpandedSpecialSubstitution), SSK(SSK_) {}
1267
1268
0
  template<typename Fn> void match(Fn F) const { F(SSK); }
1269
1270
1
  StringView getBaseName() const override {
1271
1
    switch (SSK) {
1272
1
    case SpecialSubKind::allocator:
1273
0
      return StringView("allocator");
1274
1
    case SpecialSubKind::basic_string:
1275
0
      return StringView("basic_string");
1276
1
    case SpecialSubKind::string:
1277
1
      return StringView("basic_string");
1278
1
    case SpecialSubKind::istream:
1279
0
      return StringView("basic_istream");
1280
1
    case SpecialSubKind::ostream:
1281
0
      return StringView("basic_ostream");
1282
1
    case SpecialSubKind::iostream:
1283
0
      return StringView("basic_iostream");
1284
0
    }
1285
0
    DEMANGLE_UNREACHABLE;
1286
0
  }
1287
1288
1
  void printLeft(OutputStream &S) const override {
1289
1
    switch (SSK) {
1290
1
    case SpecialSubKind::allocator:
1291
0
      S += "std::allocator";
1292
0
      break;
1293
1
    case SpecialSubKind::basic_string:
1294
0
      S += "std::basic_string";
1295
0
      break;
1296
1
    case SpecialSubKind::string:
1297
1
      S += "std::basic_string<char, std::char_traits<char>, "
1298
1
           "std::allocator<char> >";
1299
1
      break;
1300
1
    case SpecialSubKind::istream:
1301
0
      S += "std::basic_istream<char, std::char_traits<char> >";
1302
0
      break;
1303
1
    case SpecialSubKind::ostream:
1304
0
      S += "std::basic_ostream<char, std::char_traits<char> >";
1305
0
      break;
1306
1
    case SpecialSubKind::iostream:
1307
0
      S += "std::basic_iostream<char, std::char_traits<char> >";
1308
0
      break;
1309
1
    }
1310
1
  }
1311
};
1312
1313
class SpecialSubstitution final : public Node {
1314
public:
1315
  SpecialSubKind SSK;
1316
1317
  SpecialSubstitution(SpecialSubKind SSK_)
1318
21
      : Node(KSpecialSubstitution), SSK(SSK_) {}
1319
1320
31
  template<typename Fn> void match(Fn F) const { F(SSK); }
1321
1322
8
  StringView getBaseName() const override {
1323
8
    switch (SSK) {
1324
8
    case SpecialSubKind::allocator:
1325
8
      return StringView("allocator");
1326
8
    case SpecialSubKind::basic_string:
1327
0
      return StringView("basic_string");
1328
8
    case SpecialSubKind::string:
1329
0
      return StringView("string");
1330
8
    case SpecialSubKind::istream:
1331
0
      return StringView("istream");
1332
8
    case SpecialSubKind::ostream:
1333
0
      return StringView("ostream");
1334
8
    case SpecialSubKind::iostream:
1335
0
      return StringView("iostream");
1336
0
    }
1337
0
    DEMANGLE_UNREACHABLE;
1338
0
  }
1339
1340
10
  void printLeft(OutputStream &S) const override {
1341
10
    switch (SSK) {
1342
10
    case SpecialSubKind::allocator:
1343
9
      S += "std::allocator";
1344
9
      break;
1345
10
    case SpecialSubKind::basic_string:
1346
0
      S += "std::basic_string";
1347
0
      break;
1348
10
    case SpecialSubKind::string:
1349
1
      S += "std::string";
1350
1
      break;
1351
10
    case SpecialSubKind::istream:
1352
0
      S += "std::istream";
1353
0
      break;
1354
10
    case SpecialSubKind::ostream:
1355
0
      S += "std::ostream";
1356
0
      break;
1357
10
    case SpecialSubKind::iostream:
1358
0
      S += "std::iostream";
1359
0
      break;
1360
10
    }
1361
10
  }
1362
};
1363
1364
class CtorDtorName final : public Node {
1365
  const Node *Basename;
1366
  const bool IsDtor;
1367
  const int Variant;
1368
1369
public:
1370
  CtorDtorName(const Node *Basename_, bool IsDtor_, int Variant_)
1371
      : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
1372
31
        Variant(Variant_) {}
1373
1374
9
  template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
1375
1376
16
  void printLeft(OutputStream &S) const override {
1377
16
    if (IsDtor)
1378
1
      S += "~";
1379
16
    S += Basename->getBaseName();
1380
16
  }
1381
};
1382
1383
class DtorName : public Node {
1384
  const Node *Base;
1385
1386
public:
1387
0
  DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
1388
1389
0
  template<typename Fn> void match(Fn F) const { F(Base); }
1390
1391
0
  void printLeft(OutputStream &S) const override {
1392
0
    S += "~";
1393
0
    Base->printLeft(S);
1394
0
  }
1395
};
1396
1397
class UnnamedTypeName : public Node {
1398
  const StringView Count;
1399
1400
public:
1401
0
  UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
1402
1403
0
  template<typename Fn> void match(Fn F) const { F(Count); }
1404
1405
0
  void printLeft(OutputStream &S) const override {
1406
0
    S += "'unnamed";
1407
0
    S += Count;
1408
0
    S += "\'";
1409
0
  }
1410
};
1411
1412
class ClosureTypeName : public Node {
1413
  NodeArray Params;
1414
  StringView Count;
1415
1416
public:
1417
  ClosureTypeName(NodeArray Params_, StringView Count_)
1418
2
      : Node(KClosureTypeName), Params(Params_), Count(Count_) {}
1419
1420
0
  template<typename Fn> void match(Fn F) const { F(Params, Count); }
1421
1422
2
  void printLeft(OutputStream &S) const override {
1423
2
    S += "\'lambda";
1424
2
    S += Count;
1425
2
    S += "\'(";
1426
2
    Params.printWithComma(S);
1427
2
    S += ")";
1428
2
  }
1429
};
1430
1431
class StructuredBindingName : public Node {
1432
  NodeArray Bindings;
1433
public:
1434
  StructuredBindingName(NodeArray Bindings_)
1435
1
      : Node(KStructuredBindingName), Bindings(Bindings_) {}
1436
1437
0
  template<typename Fn> void match(Fn F) const { F(Bindings); }
1438
1439
0
  void printLeft(OutputStream &S) const override {
1440
0
    S += '[';
1441
0
    Bindings.printWithComma(S);
1442
0
    S += ']';
1443
0
  }
1444
};
1445
1446
// -- Expression Nodes --
1447
1448
class BinaryExpr : public Node {
1449
  const Node *LHS;
1450
  const StringView InfixOperator;
1451
  const Node *RHS;
1452
1453
public:
1454
  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
1455
2
      : Node(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
1456
2
  }
1457
1458
0
  template<typename Fn> void match(Fn F) const { F(LHS, InfixOperator, RHS); }
1459
1460
0
  void printLeft(OutputStream &S) const override {
1461
0
    // might be a template argument expression, then we need to disambiguate
1462
0
    // with parens.
1463
0
    if (InfixOperator == ">")
1464
0
      S += "(";
1465
0
1466
0
    S += "(";
1467
0
    LHS->print(S);
1468
0
    S += ") ";
1469
0
    S += InfixOperator;
1470
0
    S += " (";
1471
0
    RHS->print(S);
1472
0
    S += ")";
1473
0
1474
0
    if (InfixOperator == ">")
1475
0
      S += ")";
1476
0
  }
1477
};
1478
1479
class ArraySubscriptExpr : public Node {
1480
  const Node *Op1;
1481
  const Node *Op2;
1482
1483
public:
1484
  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
1485
0
      : Node(KArraySubscriptExpr), Op1(Op1_), Op2(Op2_) {}
1486
1487
0
  template<typename Fn> void match(Fn F) const { F(Op1, Op2); }
1488
1489
0
  void printLeft(OutputStream &S) const override {
1490
0
    S += "(";
1491
0
    Op1->print(S);
1492
0
    S += ")[";
1493
0
    Op2->print(S);
1494
0
    S += "]";
1495
0
  }
1496
};
1497
1498
class PostfixExpr : public Node {
1499
  const Node *Child;
1500
  const StringView Operator;
1501
1502
public:
1503
  PostfixExpr(const Node *Child_, StringView Operator_)
1504
0
      : Node(KPostfixExpr), Child(Child_), Operator(Operator_) {}
1505
1506
0
  template<typename Fn> void match(Fn F) const { F(Child, Operator); }
1507
1508
0
  void printLeft(OutputStream &S) const override {
1509
0
    S += "(";
1510
0
    Child->print(S);
1511
0
    S += ")";
1512
0
    S += Operator;
1513
0
  }
1514
};
1515
1516
class ConditionalExpr : public Node {
1517
  const Node *Cond;
1518
  const Node *Then;
1519
  const Node *Else;
1520
1521
public:
1522
  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
1523
0
      : Node(KConditionalExpr), Cond(Cond_), Then(Then_), Else(Else_) {}
1524
1525
0
  template<typename Fn> void match(Fn F) const { F(Cond, Then, Else); }
1526
1527
0
  void printLeft(OutputStream &S) const override {
1528
0
    S += "(";
1529
0
    Cond->print(S);
1530
0
    S += ") ? (";
1531
0
    Then->print(S);
1532
0
    S += ") : (";
1533
0
    Else->print(S);
1534
0
    S += ")";
1535
0
  }
1536
};
1537
1538
class MemberExpr : public Node {
1539
  const Node *LHS;
1540
  const StringView Kind;
1541
  const Node *RHS;
1542
1543
public:
1544
  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
1545
0
      : Node(KMemberExpr), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
1546
1547
0
  template<typename Fn> void match(Fn F) const { F(LHS, Kind, RHS); }
1548
1549
0
  void printLeft(OutputStream &S) const override {
1550
0
    LHS->print(S);
1551
0
    S += Kind;
1552
0
    RHS->print(S);
1553
0
  }
1554
};
1555
1556
class EnclosingExpr : public Node {
1557
  const StringView Prefix;
1558
  const Node *Infix;
1559
  const StringView Postfix;
1560
1561
public:
1562
  EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
1563
      : Node(KEnclosingExpr), Prefix(Prefix_), Infix(Infix_),
1564
0
        Postfix(Postfix_) {}
1565
1566
0
  template<typename Fn> void match(Fn F) const { F(Prefix, Infix, Postfix); }
1567
1568
0
  void printLeft(OutputStream &S) const override {
1569
0
    S += Prefix;
1570
0
    Infix->print(S);
1571
0
    S += Postfix;
1572
0
  }
1573
};
1574
1575
class CastExpr : public Node {
1576
  // cast_kind<to>(from)
1577
  const StringView CastKind;
1578
  const Node *To;
1579
  const Node *From;
1580
1581
public:
1582
  CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
1583
0
      : Node(KCastExpr), CastKind(CastKind_), To(To_), From(From_) {}
1584
1585
0
  template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
1586
1587
0
  void printLeft(OutputStream &S) const override {
1588
0
    S += CastKind;
1589
0
    S += "<";
1590
0
    To->printLeft(S);
1591
0
    S += ">(";
1592
0
    From->printLeft(S);
1593
0
    S += ")";
1594
0
  }
1595
};
1596
1597
class SizeofParamPackExpr : public Node {
1598
  const Node *Pack;
1599
1600
public:
1601
  SizeofParamPackExpr(const Node *Pack_)
1602
0
      : Node(KSizeofParamPackExpr), Pack(Pack_) {}
1603
1604
0
  template<typename Fn> void match(Fn F) const { F(Pack); }
1605
1606
0
  void printLeft(OutputStream &S) const override {
1607
0
    S += "sizeof...(";
1608
0
    ParameterPackExpansion PPE(Pack);
1609
0
    PPE.printLeft(S);
1610
0
    S += ")";
1611
0
  }
1612
};
1613
1614
class CallExpr : public Node {
1615
  const Node *Callee;
1616
  NodeArray Args;
1617
1618
public:
1619
  CallExpr(const Node *Callee_, NodeArray Args_)
1620
0
      : Node(KCallExpr), Callee(Callee_), Args(Args_) {}
1621
1622
0
  template<typename Fn> void match(Fn F) const { F(Callee, Args); }
1623
1624
0
  void printLeft(OutputStream &S) const override {
1625
0
    Callee->print(S);
1626
0
    S += "(";
1627
0
    Args.printWithComma(S);
1628
0
    S += ")";
1629
0
  }
1630
};
1631
1632
class NewExpr : public Node {
1633
  // new (expr_list) type(init_list)
1634
  NodeArray ExprList;
1635
  Node *Type;
1636
  NodeArray InitList;
1637
  bool IsGlobal; // ::operator new ?
1638
  bool IsArray;  // new[] ?
1639
public:
1640
  NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
1641
          bool IsArray_)
1642
      : Node(KNewExpr), ExprList(ExprList_), Type(Type_), InitList(InitList_),
1643
0
        IsGlobal(IsGlobal_), IsArray(IsArray_) {}
1644
1645
0
  template<typename Fn> void match(Fn F) const {
1646
0
    F(ExprList, Type, InitList, IsGlobal, IsArray);
1647
0
  }
1648
1649
0
  void printLeft(OutputStream &S) const override {
1650
0
    if (IsGlobal)
1651
0
      S += "::operator ";
1652
0
    S += "new";
1653
0
    if (IsArray)
1654
0
      S += "[]";
1655
0
    S += ' ';
1656
0
    if (!ExprList.empty()) {
1657
0
      S += "(";
1658
0
      ExprList.printWithComma(S);
1659
0
      S += ")";
1660
0
    }
1661
0
    Type->print(S);
1662
0
    if (!InitList.empty()) {
1663
0
      S += "(";
1664
0
      InitList.printWithComma(S);
1665
0
      S += ")";
1666
0
    }
1667
0
1668
0
  }
1669
};
1670
1671
class DeleteExpr : public Node {
1672
  Node *Op;
1673
  bool IsGlobal;
1674
  bool IsArray;
1675
1676
public:
1677
  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
1678
0
      : Node(KDeleteExpr), Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
1679
1680
0
  template<typename Fn> void match(Fn F) const { F(Op, IsGlobal, IsArray); }
1681
1682
0
  void printLeft(OutputStream &S) const override {
1683
0
    if (IsGlobal)
1684
0
      S += "::";
1685
0
    S += "delete";
1686
0
    if (IsArray)
1687
0
      S += "[] ";
1688
0
    Op->print(S);
1689
0
  }
1690
};
1691
1692
class PrefixExpr : public Node {
1693
  StringView Prefix;
1694
  Node *Child;
1695
1696
public:
1697
  PrefixExpr(StringView Prefix_, Node *Child_)
1698
0
      : Node(KPrefixExpr), Prefix(Prefix_), Child(Child_) {}
1699
1700
0
  template<typename Fn> void match(Fn F) const { F(Prefix, Child); }
1701
1702
0
  void printLeft(OutputStream &S) const override {
1703
0
    S += Prefix;
1704
0
    S += "(";
1705
0
    Child->print(S);
1706
0
    S += ")";
1707
0
  }
1708
};
1709
1710
class FunctionParam : public Node {
1711
  StringView Number;
1712
1713
public:
1714
2
  FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
1715
1716
0
  template<typename Fn> void match(Fn F) const { F(Number); }
1717
1718
0
  void printLeft(OutputStream &S) const override {
1719
0
    S += "fp";
1720
0
    S += Number;
1721
0
  }
1722
};
1723
1724
class ConversionExpr : public Node {
1725
  const Node *Type;
1726
  NodeArray Expressions;
1727
1728
public:
1729
  ConversionExpr(const Node *Type_, NodeArray Expressions_)
1730
0
      : Node(KConversionExpr), Type(Type_), Expressions(Expressions_) {}
1731
1732
0
  template<typename Fn> void match(Fn F) const { F(Type, Expressions); }
1733
1734
0
  void printLeft(OutputStream &S) const override {
1735
0
    S += "(";
1736
0
    Type->print(S);
1737
0
    S += ")(";
1738
0
    Expressions.printWithComma(S);
1739
0
    S += ")";
1740
0
  }
1741
};
1742
1743
class InitListExpr : public Node {
1744
  const Node *Ty;
1745
  NodeArray Inits;
1746
public:
1747
  InitListExpr(const Node *Ty_, NodeArray Inits_)
1748
0
      : Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
1749
1750
0
  template<typename Fn> void match(Fn F) const { F(Ty, Inits); }
1751
1752
0
  void printLeft(OutputStream &S) const override {
1753
0
    if (Ty)
1754
0
      Ty->print(S);
1755
0
    S += '{';
1756
0
    Inits.printWithComma(S);
1757
0
    S += '}';
1758
0
  }
1759
};
1760
1761
class BracedExpr : public Node {
1762
  const Node *Elem;
1763
  const Node *Init;
1764
  bool IsArray;
1765
public:
1766
  BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
1767
0
      : Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
1768
1769
0
  template<typename Fn> void match(Fn F) const { F(Elem, Init, IsArray); }
1770
1771
0
  void printLeft(OutputStream &S) const override {
1772
0
    if (IsArray) {
1773
0
      S += '[';
1774
0
      Elem->print(S);
1775
0
      S += ']';
1776
0
    } else {
1777
0
      S += '.';
1778
0
      Elem->print(S);
1779
0
    }
1780
0
    if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
1781
0
      S += " = ";
1782
0
    Init->print(S);
1783
0
  }
1784
};
1785
1786
class BracedRangeExpr : public Node {
1787
  const Node *First;
1788
  const Node *Last;
1789
  const Node *Init;
1790
public:
1791
  BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
1792
0
      : Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
1793
1794
0
  template<typename Fn> void match(Fn F) const { F(First, Last, Init); }
1795
1796
0
  void printLeft(OutputStream &S) const override {
1797
0
    S += '[';
1798
0
    First->print(S);
1799
0
    S += " ... ";
1800
0
    Last->print(S);
1801
0
    S += ']';
1802
0
    if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
1803
0
      S += " = ";
1804
0
    Init->print(S);
1805
0
  }
1806
};
1807
1808
class FoldExpr : public Node {
1809
  const Node *Pack, *Init;
1810
  StringView OperatorName;
1811
  bool IsLeftFold;
1812
1813
public:
1814
  FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
1815
           const Node *Init_)
1816
      : Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
1817
0
        IsLeftFold(IsLeftFold_) {}
1818
1819
0
  template<typename Fn> void match(Fn F) const {
1820
0
    F(IsLeftFold, OperatorName, Pack, Init);
1821
0
  }
1822
1823
0
  void printLeft(OutputStream &S) const override {
1824
0
    auto PrintPack = [&] {
1825
0
      S += '(';
1826
0
      ParameterPackExpansion(Pack).print(S);
1827
0
      S += ')';
1828
0
    };
1829
0
1830
0
    S += '(';
1831
0
1832
0
    if (IsLeftFold) {
1833
0
      // init op ... op pack
1834
0
      if (Init != nullptr) {
1835
0
        Init->print(S);
1836
0
        S += ' ';
1837
0
        S += OperatorName;
1838
0
        S += ' ';
1839
0
      }
1840
0
      // ... op pack
1841
0
      S += "... ";
1842
0
      S += OperatorName;
1843
0
      S += ' ';
1844
0
      PrintPack();
1845
0
    } else { // !IsLeftFold
1846
0
      // pack op ...
1847
0
      PrintPack();
1848
0
      S += ' ';
1849
0
      S += OperatorName;
1850
0
      S += " ...";
1851
0
      // pack op ... op init
1852
0
      if (Init != nullptr) {
1853
0
        S += ' ';
1854
0
        S += OperatorName;
1855
0
        S += ' ';
1856
0
        Init->print(S);
1857
0
      }
1858
0
    }
1859
0
    S += ')';
1860
0
  }
1861
};
1862
1863
class ThrowExpr : public Node {
1864
  const Node *Op;
1865
1866
public:
1867
0
  ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}
1868
1869
0
  template<typename Fn> void match(Fn F) const { F(Op); }
1870
1871
0
  void printLeft(OutputStream &S) const override {
1872
0
    S += "throw ";
1873
0
    Op->print(S);
1874
0
  }
1875
};
1876
1877
// MSVC __uuidof extension, generated by clang in -fms-extensions mode.
1878
class UUIDOfExpr : public Node {
1879
  Node *Operand;
1880
public:
1881
0
  UUIDOfExpr(Node *Operand_) : Node(KUUIDOfExpr), Operand(Operand_) {}
1882
1883
0
  template<typename Fn> void match(Fn F) const { F(Operand); }
1884
1885
0
  void printLeft(OutputStream &S) const override {
1886
0
    S << "__uuidof(";
1887
0
    Operand->print(S);
1888
0
    S << ")";
1889
0
  }
1890
};
1891
1892
class BoolExpr : public Node {
1893
  bool Value;
1894
1895
public:
1896
0
  BoolExpr(bool Value_) : Node(KBoolExpr), Value(Value_) {}
1897
1898
0
  template<typename Fn> void match(Fn F) const { F(Value); }
1899
1900
0
  void printLeft(OutputStream &S) const override {
1901
0
    S += Value ? StringView("true") : StringView("false");
1902
0
  }
1903
};
1904
1905
class IntegerCastExpr : public Node {
1906
  // ty(integer)
1907
  const Node *Ty;
1908
  StringView Integer;
1909
1910
public:
1911
  IntegerCastExpr(const Node *Ty_, StringView Integer_)
1912
0
      : Node(KIntegerCastExpr), Ty(Ty_), Integer(Integer_) {}
1913
1914
0
  template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
1915
1916
0
  void printLeft(OutputStream &S) const override {
1917
0
    S += "(";
1918
0
    Ty->print(S);
1919
0
    S += ")";
1920
0
    S += Integer;
1921
0
  }
1922
};
1923
1924
class IntegerLiteral : public Node {
1925
  StringView Type;
1926
  StringView Value;
1927
1928
public:
1929
  IntegerLiteral(StringView Type_, StringView Value_)
1930
2
      : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
1931
1932
0
  template<typename Fn> void match(Fn F) const { F(Type, Value); }
1933
1934
0
  void printLeft(OutputStream &S) const override {
1935
0
    if (Type.size() > 3) {
1936
0
      S += "(";
1937
0
      S += Type;
1938
0
      S += ")";
1939
0
    }
1940
0
1941
0
    if (Value[0] == 'n') {
1942
0
      S += "-";
1943
0
      S += Value.dropFront(1);
1944
0
    } else
1945
0
      S += Value;
1946
0
1947
0
    if (Type.size() <= 3)
1948
0
      S += Type;
1949
0
  }
1950
};
1951
1952
template <class Float> struct FloatData;
1953
1954
namespace float_literal_impl {
1955
0
constexpr Node::Kind getFloatLiteralKind(float *) {
1956
0
  return Node::KFloatLiteral;
1957
0
}
1958
0
constexpr Node::Kind getFloatLiteralKind(double *) {
1959
0
  return Node::KDoubleLiteral;
1960
0
}
1961
0
constexpr Node::Kind getFloatLiteralKind(long double *) {
1962
0
  return Node::KLongDoubleLiteral;
1963
0
}
1964
}
1965
1966
template <class Float> class FloatLiteralImpl : public Node {
1967
  const StringView Contents;
1968
1969
  static constexpr Kind KindForClass =
1970
      float_literal_impl::getFloatLiteralKind((Float *)nullptr);
1971
1972
public:
1973
  FloatLiteralImpl(StringView Contents_)
1974
0
      : Node(KindForClass), Contents(Contents_) {}
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<float>::FloatLiteralImpl(llvm::itanium_demangle::StringView)
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<double>::FloatLiteralImpl(llvm::itanium_demangle::StringView)
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<long double>::FloatLiteralImpl(llvm::itanium_demangle::StringView)
1975
1976
0
  template<typename Fn> void match(Fn F) const { F(Contents); }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:void llvm::itanium_demangle::FloatLiteralImpl<float>::match<(anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<float> > >((anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<float> >) const
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:void llvm::itanium_demangle::FloatLiteralImpl<double>::match<(anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<double> > >((anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<double> >) const
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:void llvm::itanium_demangle::FloatLiteralImpl<long double>::match<(anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<long double> > >((anonymous namespace)::ProfileSpecificNode<llvm::itanium_demangle::FloatLiteralImpl<long double> >) const
1977
1978
0
  void printLeft(OutputStream &s) const override {
1979
0
    const char *first = Contents.begin();
1980
0
    const char *last = Contents.end() + 1;
1981
0
1982
0
    const size_t N = FloatData<Float>::mangled_size;
1983
0
    if (static_cast<std::size_t>(last - first) > N) {
1984
0
      last = first + N;
1985
0
      union {
1986
0
        Float value;
1987
0
        char buf[sizeof(Float)];
1988
0
      };
1989
0
      const char *t = first;
1990
0
      char *e = buf;
1991
0
      for (; t != last; ++t, ++e) {
1992
0
        unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
1993
0
                                  : static_cast<unsigned>(*t - 'a' + 10);
1994
0
        ++t;
1995
0
        unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0')
1996
0
                                  : static_cast<unsigned>(*t - 'a' + 10);
1997
0
        *e = static_cast<char>((d1 << 4) + d0);
1998
0
      }
1999
0
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
2000
0
      std::reverse(buf, e);
2001
0
#endif
2002
0
      char num[FloatData<Float>::max_demangled_size] = {0};
2003
0
      int n = snprintf(num, sizeof(num), FloatData<Float>::spec, value);
2004
0
      s += StringView(num, num + n);
2005
0
    }
2006
0
  }
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<float>::printLeft(llvm::itanium_demangle::OutputStream&) const
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<double>::printLeft(llvm::itanium_demangle::OutputStream&) const
Unexecuted instantiation: llvm::itanium_demangle::FloatLiteralImpl<long double>::printLeft(llvm::itanium_demangle::OutputStream&) const
2007
};
2008
2009
using FloatLiteral = FloatLiteralImpl<float>;
2010
using DoubleLiteral = FloatLiteralImpl<double>;
2011
using LongDoubleLiteral = FloatLiteralImpl<long double>;
2012
2013
/// Visit the node. Calls \c F(P), where \c P is the node cast to the
2014
/// appropriate derived class.
2015
template<typename Fn>
2016
2.02k
void Node::visit(Fn F) const {
2017
2.02k
  switch (K) {
2018
2.02k
#define CASE(X) case K ## X: return F(static_cast<const X*>(this));
2019
2.02k
    
FOR_EACH_NODE_KIND0
(CASE)
2020
2.02k
#undef CASE
2021
2.02k
  }
2022
2.02k
  assert(0 && "unknown mangling node kind");
2023
0
}
2024
2025
/// Determine the kind of a node from its type.
2026
template<typename NodeT> struct NodeKind;
2027
#define SPECIALIZATION(X) \
2028
  template<> struct NodeKind<X> { \
2029
    static constexpr Node::Kind Kind = Node::K##X; \
2030
0
    static constexpr const char *name() { return #X; } \
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NodeArrayNode>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::DotSuffix>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::VendorExtQualType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::QualType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ConversionOperatorType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PostfixQualifiedType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ElaboratedTypeSpefType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NameType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::AbiTagAttr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::EnableIfAttr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ObjCProtoName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PointerType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ReferenceType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PointerToMemberType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ArrayType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FunctionType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NoexceptSpec>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::DynamicExceptionSpec>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FunctionEncoding>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::LiteralOperator>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::SpecialName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::CtorVtableSpecialName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::QualifiedName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NestedName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::LocalName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::VectorType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PixelVectorType>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ParameterPack>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::TemplateArgumentPack>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ParameterPackExpansion>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::TemplateArgs>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ForwardTemplateReference>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NameWithTemplateArgs>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::GlobalQualifiedName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::StdQualifiedName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ExpandedSpecialSubstitution>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::SpecialSubstitution>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::CtorDtorName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::DtorName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::UnnamedTypeName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ClosureTypeName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::StructuredBindingName>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::BinaryExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ArraySubscriptExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PostfixExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ConditionalExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::MemberExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::EnclosingExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::CastExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::SizeofParamPackExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::CallExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::NewExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::DeleteExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::PrefixExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FunctionParam>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ConversionExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::InitListExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FoldExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::ThrowExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::UUIDOfExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::BoolExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::IntegerCastExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::IntegerLiteral>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FloatLiteralImpl<float> >::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FloatLiteralImpl<double> >::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::FloatLiteralImpl<long double> >::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::BracedExpr>::name()
Unexecuted instantiation: llvm::itanium_demangle::NodeKind<llvm::itanium_demangle::BracedRangeExpr>::name()
2031
  };
2032
FOR_EACH_NODE_KIND(SPECIALIZATION)
2033
#undef SPECIALIZATION
2034
2035
#undef FOR_EACH_NODE_KIND
2036
2037
template <class T, size_t N>
2038
class PODSmallVector {
2039
  static_assert(std::is_pod<T>::value,
2040
                "T is required to be a plain old data type");
2041
2042
  T* First;
2043
  T* Last;
2044
  T* Cap;
2045
  T Inline[N];
2046
2047
8.48k
  bool isInline() const { return First == Inline; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::isInline() const
Line
Count
Source
2047
2.06k
  bool isInline() const { return First == Inline; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::isInline() const
Line
Count
Source
2047
2.30k
  bool isInline() const { return First == Inline; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::isInline() const
Line
Count
Source
2047
4.12k
  bool isInline() const { return First == Inline; }
2048
2049
0
  void clearInline() {
2050
0
    First = Inline;
2051
0
    Last = Inline;
2052
0
    Cap = Inline + N;
2053
0
  }
2054
2055
0
  void reserve(size_t NewCap) {
2056
0
    size_t S = size();
2057
0
    if (isInline()) {
2058
0
      auto* Tmp = static_cast<T*>(std::malloc(NewCap * sizeof(T)));
2059
0
      if (Tmp == nullptr)
2060
0
        std::terminate();
2061
0
      std::copy(First, Last, Tmp);
2062
0
      First = Tmp;
2063
0
    } else {
2064
0
      First = static_cast<T*>(std::realloc(First, NewCap * sizeof(T)));
2065
0
      if (First == nullptr)
2066
0
        std::terminate();
2067
0
    }
2068
0
    Last = First + S;
2069
0
    Cap = First + NewCap;
2070
0
  }
Unexecuted instantiation: llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::reserve(unsigned long)
Unexecuted instantiation: llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::reserve(unsigned long)
Unexecuted instantiation: llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::reserve(unsigned long)
2071
2072
public:
2073
8.30k
  PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::PODSmallVector()
Line
Count
Source
2073
4.12k
  PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::PODSmallVector()
Line
Count
Source
2073
2.12k
  PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::PODSmallVector()
Line
Count
Source
2073
2.06k
  PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {}
2074
2075
  PODSmallVector(const PODSmallVector&) = delete;
2076
  PODSmallVector& operator=(const PODSmallVector&) = delete;
2077
2078
61
  PODSmallVector(PODSmallVector&& Other) : PODSmallVector() {
2079
61
    if (Other.isInline()) {
2080
61
      std::copy(Other.begin(), Other.end(), First);
2081
61
      Last = First + Other.size();
2082
61
      Other.clear();
2083
61
      return;
2084
61
    }
2085
0
2086
0
    First = Other.First;
2087
0
    Last = Other.Last;
2088
0
    Cap = Other.Cap;
2089
0
    Other.clearInline();
2090
0
  }
2091
2092
61
  PODSmallVector& operator=(PODSmallVector&& Other) {
2093
61
    if (Other.isInline()) {
2094
61
      if (!isInline()) {
2095
0
        std::free(First);
2096
0
        clearInline();
2097
0
      }
2098
61
      std::copy(Other.begin(), Other.end(), First);
2099
61
      Last = First + Other.size();
2100
61
      Other.clear();
2101
61
      return *this;
2102
61
    }
2103
0
2104
0
    if (isInline()) {
2105
0
      First = Other.First;
2106
0
      Last = Other.Last;
2107
0
      Cap = Other.Cap;
2108
0
      Other.clearInline();
2109
0
      return *this;
2110
0
    }
2111
0
2112
0
    std::swap(First, Other.First);
2113
0
    std::swap(Last, Other.Last);
2114
0
    std::swap(Cap, Other.Cap);
2115
0
    Other.clear();
2116
0
    return *this;
2117
0
  }
2118
2119
7.01k
  void push_back(const T& Elem) {
2120
7.01k
    if (Last == Cap)
2121
0
      reserve(size() * 2);
2122
7.01k
    *Last++ = Elem;
2123
7.01k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::push_back(llvm::itanium_demangle::ForwardTemplateReference* const&)
Line
Count
Source
2119
8
  void push_back(const T& Elem) {
2120
8
    if (Last == Cap)
2121
0
      reserve(size() * 2);
2122
8
    *Last++ = Elem;
2123
8
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::push_back(llvm::itanium_demangle::Node* const&)
Line
Count
Source
2119
61
  void push_back(const T& Elem) {
2120
61
    if (Last == Cap)
2121
0
      reserve(size() * 2);
2122
61
    *Last++ = Elem;
2123
61
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::push_back(llvm::itanium_demangle::Node* const&)
Line
Count
Source
2119
6.94k
  void push_back(const T& Elem) {
2120
6.94k
    if (Last == Cap)
2121
0
      reserve(size() * 2);
2122
6.94k
    *Last++ = Elem;
2123
6.94k
  }
2124
2125
276
  void pop_back() {
2126
276
    assert(Last != First && "Popping empty vector!");
2127
276
    --Last;
2128
276
  }
2129
2130
4.62k
  void dropBack(size_t Index) {
2131
4.62k
    assert(Index <= size() && "dropBack() can't expand!");
2132
4.62k
    Last = First + Index;
2133
4.62k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::dropBack(unsigned long)
Line
Count
Source
2130
2.34k
  void dropBack(size_t Index) {
2131
2.34k
    assert(Index <= size() && "dropBack() can't expand!");
2132
2.34k
    Last = First + Index;
2133
2.34k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::dropBack(unsigned long)
Line
Count
Source
2130
2.27k
  void dropBack(size_t Index) {
2131
2.27k
    assert(Index <= size() && "dropBack() can't expand!");
2132
2.27k
    Last = First + Index;
2133
2.27k
  }
2134
2135
3.73k
  T* begin() { return First; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::begin()
Line
Count
Source
2135
3.57k
  T* begin() { return First; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::begin()
Line
Count
Source
2135
136
  T* begin() { return First; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::begin()
Line
Count
Source
2135
16
  T* begin() { return First; }
2136
2.46k
  T* end() { return Last; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::end()
Line
Count
Source
2136
2.34k
  T* end() { return Last; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::end()
Line
Count
Source
2136
122
  T* end() { return Last; }
2137
2138
1.48k
  bool empty() const { return First == Last; }
2139
7.08k
  size_t size() const { return static_cast<size_t>(Last - First); }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::size() const
Line
Count
Source
2139
2.37k
  size_t size() const { return static_cast<size_t>(Last - First); }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::size() const
Line
Count
Source
2139
4.57k
  size_t size() const { return static_cast<size_t>(Last - First); }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::size() const
Line
Count
Source
2139
137
  size_t size() const { return static_cast<size_t>(Last - First); }
2140
  T& back() {
2141
    assert(Last != First && "Calling back() on empty vector!");
2142
    return *(Last - 1);
2143
  }
2144
1.26k
  T& operator[](size_t Index) {
2145
1.26k
    assert(Index < size() && "Invalid access!");
2146
1.26k
    return *(begin() + Index);
2147
1.26k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::operator[](unsigned long)
Line
Count
Source
2144
14
  T& operator[](size_t Index) {
2145
14
    assert(Index < size() && "Invalid access!");
2146
14
    return *(begin() + Index);
2147
14
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::operator[](unsigned long)
Line
Count
Source
2144
1.23k
  T& operator[](size_t Index) {
2145
1.23k
    assert(Index < size() && "Invalid access!");
2146
1.23k
    return *(begin() + Index);
2147
1.23k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::operator[](unsigned long)
Line
Count
Source
2144
16
  T& operator[](size_t Index) {
2145
16
    assert(Index < size() && "Invalid access!");
2146
16
    return *(begin() + Index);
2147
16
  }
2148
1.63k
  void clear() { Last = First; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::clear()
Line
Count
Source
2148
657
  void clear() { Last = First; }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::clear()
Line
Count
Source
2148
974
  void clear() { Last = First; }
2149
2150
8.30k
  ~PODSmallVector() {
2151
8.30k
    if (!isInline())
2152
0
      std::free(First);
2153
8.30k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::ForwardTemplateReference*, 4ul>::~PODSmallVector()
Line
Count
Source
2150
2.06k
  ~PODSmallVector() {
2151
2.06k
    if (!isInline())
2152
0
      std::free(First);
2153
2.06k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>::~PODSmallVector()
Line
Count
Source
2150
2.12k
  ~PODSmallVector() {
2151
2.12k
    if (!isInline())
2152
0
      std::free(First);
2153
2.12k
  }
llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 32ul>::~PODSmallVector()
Line
Count
Source
2150
4.12k
  ~PODSmallVector() {
2151
4.12k
    if (!isInline())
2152
0
      std::free(First);
2153
4.12k
  }
2154
};
2155
2156
template <typename Derived, typename Alloc> struct AbstractManglingParser {
2157
  const char *First;
2158
  const char *Last;
2159
2160
  // Name stack, this is used by the parser to hold temporary names that were
2161
  // parsed. The parser collapses multiple names into new nodes to construct
2162
  // the AST. Once the parser is finished, names.size() == 1.
2163
  PODSmallVector<Node *, 32> Names;
2164
2165
  // Substitution table. Itanium supports name substitutions as a means of
2166
  // compression. The string "S42_" refers to the 44nd entry (base-36) in this
2167
  // table.
2168
  PODSmallVector<Node *, 32> Subs;
2169
2170
  // Template parameter table. Like the above, but referenced like "T42_".
2171
  // This has a smaller size compared to Subs and Names because it can be
2172
  // stored on the stack.
2173
  PODSmallVector<Node *, 8> TemplateParams;
2174
2175
  // Set of unresolved forward <template-param> references. These can occur in a
2176
  // conversion operator's type, and are resolved in the enclosing <encoding>.
2177
  PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
2178
2179
  bool TryToParseTemplateArgs = true;
2180
  bool PermitForwardTemplateReferences = false;
2181
  bool ParsingLambdaParams = false;
2182
2183
  Alloc ASTAllocator;
2184
2185
  AbstractManglingParser(const char *First_, const char *Last_)
2186
2.05k
      : First(First_), Last(Last_) {}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::AbstractManglingParser(char const*, char const*)
Line
Count
Source
2186
40
      : First(First_), Last(Last_) {}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::AbstractManglingParser(char const*, char const*)
Line
Count
Source
2186
2.01k
      : First(First_), Last(Last_) {}
2187
2188
26.3k
  Derived &getDerived() { return static_cast<Derived &>(*this); }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::getDerived()
Line
Count
Source
2188
5.62k
  Derived &getDerived() { return static_cast<Derived &>(*this); }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::getDerived()
Line
Count
Source
2188
20.7k
  Derived &getDerived() { return static_cast<Derived &>(*this); }
2189
2190
487
  void reset(const char *First_, const char *Last_) {
2191
487
    First = First_;
2192
487
    Last = Last_;
2193
487
    Names.clear();
2194
487
    Subs.clear();
2195
487
    TemplateParams.clear();
2196
487
    ParsingLambdaParams = false;
2197
487
    TryToParseTemplateArgs = true;
2198
487
    PermitForwardTemplateReferences = false;
2199
487
    ASTAllocator.reset();
2200
487
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::reset(char const*, char const*)
Line
Count
Source
2190
448
  void reset(const char *First_, const char *Last_) {
2191
448
    First = First_;
2192
448
    Last = Last_;
2193
448
    Names.clear();
2194
448
    Subs.clear();
2195
448
    TemplateParams.clear();
2196
448
    ParsingLambdaParams = false;
2197
448
    TryToParseTemplateArgs = true;
2198
448
    PermitForwardTemplateReferences = false;
2199
448
    ASTAllocator.reset();
2200
448
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::reset(char const*, char const*)
Line
Count
Source
2190
39
  void reset(const char *First_, const char *Last_) {
2191
39
    First = First_;
2192
39
    Last = Last_;
2193
39
    Names.clear();
2194
39
    Subs.clear();
2195
39
    TemplateParams.clear();
2196
39
    ParsingLambdaParams = false;
2197
39
    TryToParseTemplateArgs = true;
2198
39
    PermitForwardTemplateReferences = false;
2199
39
    ASTAllocator.reset();
2200
39
  }
2201
2202
10.6k
  template <class T, class... Args> Node *make(Args &&... args) {
2203
10.6k
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
10.6k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [4]>(char const (&&&) [4])
Line
Count
Source
2202
158
  template <class T, class... Args> Node *make(Args &&... args) {
2203
158
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
158
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::IntegerLiteral, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::BoolExpr, int>(int&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<float>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<double>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<long double>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::IntegerCastExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FunctionParam, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FoldExpr, bool&, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(bool&&&, llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::BinaryExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PrefixExpr, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [10], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [10], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [11], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [11], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CallExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::DeleteExpr, llvm::itanium_demangle::Node*&, bool&, bool>(llvm::itanium_demangle::Node*&&&, bool&&&, bool&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [13], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [13], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [22]>(char const (&&&) [22])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::QualifiedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::DtorName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ConversionOperatorType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
7
  template <class T, class... Args> Node *make(Args &&... args) {
2203
7
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
7
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [16]>(char const (&&&) [16])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::LiteralOperator, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::GlobalQualifiedName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, char const (&) [3], llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, char const (&&&) [3], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, char const (&) [2], llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, char const (&&&) [2], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ArraySubscriptExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::BracedExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, bool>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&, bool&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<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: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::InitListExpr, std::nullptr_t, llvm::itanium_demangle::NodeArray>(std::nullptr_t&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PostfixExpr, llvm::itanium_demangle::Node*&, char const (&) [3]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [3])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, bool&, bool&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&&, bool&&&, bool&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray, bool&, bool&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&, bool&&&, bool&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [11], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [11], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ConditionalExpr, 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: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [17], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [17], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [12], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [9], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [9], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SizeofParamPackExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [12], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::TemplateArgumentPack, llvm::itanium_demangle::NodeArray&>(llvm::itanium_demangle::NodeArray&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NodeArrayNode, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::InitListExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ThrowExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::UUIDOfExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NoexceptSpec, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::DynamicExceptionSpec, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<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*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ObjCProtoName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::VendorExtQualType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::QualType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Qualifiers&&&)
Line
Count
Source
2202
4
  template <class T, class... Args> Node *make(Args &&... args) {
2203
4
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
4
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [5]>(char const (&&&) [5])
Line
Count
Source
2202
122
  template <class T, class... Args> Node *make(Args &&... args) {
2203
122
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
122
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [8]>(char const (&&&) [8])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [12]>(char const (&&&) [12])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [14]>(char const (&&&) [14])
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [6]>(char const (&&&) [6])
Line
Count
Source
2202
26
  template <class T, class... Args> Node *make(Args &&... args) {
2203
26
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
26
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [15]>(char const (&&&) [15])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [13]>(char const (&&&) [13])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [10]>(char const (&&&) [10])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [19]>(char const (&&&) [19])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [9]>(char const (&&&) [9])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [18]>(char const (&&&) [18])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [7]>(char const (&&&) [7])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [11]>(char const (&&&) [11])
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameType, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
820
  template <class T, class... Args> Node *make(Args &&... args) {
2203
820
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
820
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PixelVectorType, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ParameterPackExpansion, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ArrayType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeOrString&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeOrString&&&)
Line
Count
Source
2202
17
  template <class T, class... Args> Node *make(Args &&... args) {
2203
17
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
17
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PointerToMemberType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ElaboratedTypeSpefType, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ForwardTemplateReference, unsigned long&>(unsigned long&&&)
Line
Count
Source
2202
7
  template <class T, class... Args> Node *make(Args &&... args) {
2203
7
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
7
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ParameterPack, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::TemplateArgs, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Line
Count
Source
2202
211
  template <class T, class... Args> Node *make(Args &&... args) {
2203
211
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
211
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NameWithTemplateArgs, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
211
  template <class T, class... Args> Node *make(Args &&... args) {
2203
211
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
211
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PointerType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
10
  template <class T, class... Args> Node *make(Args &&... args) {
2203
10
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
10
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ReferenceType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::ReferenceKind>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::ReferenceKind&&)
Line
Count
Source
2202
27
  template <class T, class... Args> Node *make(Args &&... args) {
2203
27
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
27
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [9]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [9])
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [11]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [11])
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialSubstitution, llvm::itanium_demangle::SpecialSubKind>(llvm::itanium_demangle::SpecialSubKind&&)
Line
Count
Source
2202
39
  template <class T, class... Args> Node *make(Args &&... args) {
2203
39
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
39
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::AbiTagAttr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::NestedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
325
  template <class T, class... Args> Node *make(Args &&... args) {
2203
325
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
325
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ExpandedSpecialSubstitution, llvm::itanium_demangle::SpecialSubKind&>(llvm::itanium_demangle::SpecialSubKind&&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CtorDtorName, llvm::itanium_demangle::Node*&, bool, int&>(llvm::itanium_demangle::Node*&&&, bool&&, int&&&)
Line
Count
Source
2202
12
  template <class T, class... Args> Node *make(Args &&... args) {
2203
12
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
12
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::UnnamedTypeName, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::ClosureTypeName, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::StructuredBindingName, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::LocalName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
5
  template <class T, class... Args> Node *make(Args &&... args) {
2203
5
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
5
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::StdQualifiedName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
44
  template <class T, class... Args> Node *make(Args &&... args) {
2203
44
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
44
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [12], llvm::itanium_demangle::Node*&>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [9], llvm::itanium_demangle::Node*&>(char const (&&&) [9], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [14], llvm::itanium_demangle::Node*&>(char const (&&&) [14], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [19], llvm::itanium_demangle::Node*&>(char const (&&&) [19], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [27], llvm::itanium_demangle::Node*&>(char const (&&&) [27], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::CtorVtableSpecialName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [34], llvm::itanium_demangle::Node*&>(char const (&&&) [34], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [41], llvm::itanium_demangle::Node*&>(char const (&&&) [41], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [18], llvm::itanium_demangle::Node*&>(char const (&&&) [18], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [22], llvm::itanium_demangle::Node*&>(char const (&&&) [22], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [20], llvm::itanium_demangle::Node*&>(char const (&&&) [20], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [25], llvm::itanium_demangle::Node*&>(char const (&&&) [25], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::EnableIfAttr, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::FunctionEncoding, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray, 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::Qualifiers&&&, llvm::itanium_demangle::FunctionRefQual&&&)
Line
Count
Source
2202
238
  template <class T, class... Args> Node *make(Args &&... args) {
2203
238
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
238
  }
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::make<llvm::itanium_demangle::DotSuffix, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [12], llvm::itanium_demangle::Node*&>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
3
  template <class T, class... Args> Node *make(Args &&... args) {
2203
3
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
3
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [9], llvm::itanium_demangle::Node*&>(char const (&&&) [9], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [14], llvm::itanium_demangle::Node*&>(char const (&&&) [14], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [19], llvm::itanium_demangle::Node*&>(char const (&&&) [19], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [27], llvm::itanium_demangle::Node*&>(char const (&&&) [27], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CtorVtableSpecialName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [41], llvm::itanium_demangle::Node*&>(char const (&&&) [41], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [18], llvm::itanium_demangle::Node*&>(char const (&&&) [18], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [22], llvm::itanium_demangle::Node*&>(char const (&&&) [22], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [20], llvm::itanium_demangle::Node*&>(char const (&&&) [20], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [25], llvm::itanium_demangle::Node*&>(char const (&&&) [25], llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [4]>(char const (&&&) [4])
Line
Count
Source
2202
270
  template <class T, class... Args> Node *make(Args &&... args) {
2203
270
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
270
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NestedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
57
  template <class T, class... Args> Node *make(Args &&... args) {
2203
57
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
57
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [5]>(char const (&&&) [5])
Line
Count
Source
2202
96
  template <class T, class... Args> Node *make(Args &&... args) {
2203
96
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
96
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ForwardTemplateReference, unsigned long&>(unsigned long&&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::IntegerLiteral, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::BoolExpr, int>(int&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<float>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<double>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FloatLiteralImpl<long double>, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::IntegerCastExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FunctionParam, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FoldExpr, bool&, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(bool&&&, llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::BinaryExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PrefixExpr, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [11], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [11], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CallExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::DeleteExpr, llvm::itanium_demangle::Node*&, bool&, bool>(llvm::itanium_demangle::Node*&&&, bool&&&, bool&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [13], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [13], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [22]>(char const (&&&) [22])
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
2.05k
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2.05k
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2.05k
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::QualifiedName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::DtorName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [11]>(char const (&&&) [11])
Line
Count
Source
2202
5
  template <class T, class... Args> Node *make(Args &&... args) {
2203
5
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
5
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [10]>(char const (&&&) [10])
Line
Count
Source
2202
84
  template <class T, class... Args> Node *make(Args &&... args) {
2203
84
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
84
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ConversionOperatorType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [18]>(char const (&&&) [18])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [16]>(char const (&&&) [16])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::LiteralOperator, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [12]>(char const (&&&) [12])
Line
Count
Source
2202
94
  template <class T, class... Args> Node *make(Args &&... args) {
2203
94
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
94
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [15]>(char const (&&&) [15])
Line
Count
Source
2202
179
  template <class T, class... Args> Node *make(Args &&... args) {
2203
179
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
179
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [13]>(char const (&&&) [13])
Line
Count
Source
2202
297
  template <class T, class... Args> Node *make(Args &&... args) {
2203
297
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
297
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::GlobalQualifiedName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, char const (&) [3], llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, char const (&&&) [3], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::MemberExpr, llvm::itanium_demangle::Node*&, char const (&) [2], llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, char const (&&&) [2], llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ArraySubscriptExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::BracedExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, bool>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&, bool&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<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: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::InitListExpr, std::nullptr_t, llvm::itanium_demangle::NodeArray>(std::nullptr_t&&, llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PostfixExpr, llvm::itanium_demangle::Node*&, char const (&) [3]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [3])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, bool&, bool&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&&, bool&&&, bool&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NewExpr, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray, bool&, bool&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&, bool&&&, bool&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [11], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [11], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ConditionalExpr, 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: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [17], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [17], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CastExpr, char const (&) [12], llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ParameterPackExpansion, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [9], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [9], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SizeofParamPackExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [12], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [12], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NodeArrayNode, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::InitListExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeArray&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [6]>(char const (&&&) [6])
Line
Count
Source
2202
518
  template <class T, class... Args> Node *make(Args &&... args) {
2203
518
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
518
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ThrowExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::UUIDOfExpr, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::EnclosingExpr, char const (&) [10], llvm::itanium_demangle::Node*&, char const (&) [2]>(char const (&&&) [10], llvm::itanium_demangle::Node*&&&, char const (&&&) [2])
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ExpandedSpecialSubstitution, llvm::itanium_demangle::SpecialSubKind&>(llvm::itanium_demangle::SpecialSubKind&&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::CtorDtorName, llvm::itanium_demangle::Node*&, bool, int&>(llvm::itanium_demangle::Node*&&&, bool&&, int&&&)
Line
Count
Source
2202
23
  template <class T, class... Args> Node *make(Args &&... args) {
2203
23
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
23
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::AbiTagAttr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
6
  template <class T, class... Args> Node *make(Args &&... args) {
2203
6
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
6
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::UnnamedTypeName, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ClosureTypeName, llvm::itanium_demangle::NodeArray&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::NodeArray&&&, llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::StructuredBindingName, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::LocalName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
5
  template <class T, class... Args> Node *make(Args &&... args) {
2203
5
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
5
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialSubstitution, llvm::itanium_demangle::SpecialSubKind>(llvm::itanium_demangle::SpecialSubKind&&)
Line
Count
Source
2202
11
  template <class T, class... Args> Node *make(Args &&... args) {
2203
11
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
11
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ParameterPack, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Line
Count
Source
2202
3
  template <class T, class... Args> Node *make(Args &&... args) {
2203
3
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
3
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::TemplateArgs, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Line
Count
Source
2202
34
  template <class T, class... Args> Node *make(Args &&... args) {
2203
34
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
34
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameWithTemplateArgs, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
34
  template <class T, class... Args> Node *make(Args &&... args) {
2203
34
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
34
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::StdQualifiedName, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
6
  template <class T, class... Args> Node *make(Args &&... args) {
2203
6
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
6
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::TemplateArgumentPack, llvm::itanium_demangle::NodeArray&>(llvm::itanium_demangle::NodeArray&&&)
Line
Count
Source
2202
4
  template <class T, class... Args> Node *make(Args &&... args) {
2203
4
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
4
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::EnableIfAttr, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::FunctionEncoding, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray, 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::Qualifiers&&&, llvm::itanium_demangle::FunctionRefQual&&&)
Line
Count
Source
2202
1.98k
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1.98k
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1.98k
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::DotSuffix, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::SpecialName, char const (&) [34], llvm::itanium_demangle::Node*&>(char const (&&&) [34], llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
3
  template <class T, class... Args> Node *make(Args &&... args) {
2203
3
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
3
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NoexceptSpec, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::DynamicExceptionSpec, llvm::itanium_demangle::NodeArray>(llvm::itanium_demangle::NodeArray&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<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
2202
4
  template <class T, class... Args> Node *make(Args &&... args) {
2203
4
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
4
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ObjCProtoName, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::VendorExtQualType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::QualType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Qualifiers&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Qualifiers&&&)
Line
Count
Source
2202
24
  template <class T, class... Args> Node *make(Args &&... args) {
2203
24
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
24
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [8]>(char const (&&&) [8])
Line
Count
Source
2202
8
  template <class T, class... Args> Node *make(Args &&... args) {
2203
8
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
8
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [14]>(char const (&&&) [14])
Line
Count
Source
2202
337
  template <class T, class... Args> Node *make(Args &&... args) {
2203
337
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
337
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [19]>(char const (&&&) [19])
Line
Count
Source
2202
308
  template <class T, class... Args> Node *make(Args &&... args) {
2203
308
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
308
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [9]>(char const (&&&) [9])
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [7]>(char const (&&&) [7])
Line
Count
Source
2202
214
  template <class T, class... Args> Node *make(Args &&... args) {
2203
214
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
214
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PixelVectorType, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::StringView&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&&)
Line
Count
Source
2202
1.64k
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1.64k
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1.64k
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::VectorType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::StringView>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::StringView&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ArrayType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeOrString&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::NodeOrString&&&)
Line
Count
Source
2202
1
  template <class T, class... Args> Node *make(Args &&... args) {
2203
1
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
1
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PointerToMemberType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::Node*&&&)
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ElaboratedTypeSpefType, llvm::itanium_demangle::StringView&, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::StringView&&&, llvm::itanium_demangle::Node*&&&)
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PointerType, llvm::itanium_demangle::Node*&>(llvm::itanium_demangle::Node*&&&)
Line
Count
Source
2202
46
  template <class T, class... Args> Node *make(Args &&... args) {
2203
46
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
46
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ReferenceType, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::ReferenceKind>(llvm::itanium_demangle::Node*&&&, llvm::itanium_demangle::ReferenceKind&&)
Line
Count
Source
2202
2
  template <class T, class... Args> Node *make(Args &&... args) {
2203
2
    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2204
2
  }
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [9]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [9])
Unexecuted instantiation: ItaniumDemangle.cpp:llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::PostfixQualifiedType, llvm::itanium_demangle::Node*&, char const (&) [11]>(llvm::itanium_demangle::Node*&&&, char const (&&&) [11])
2205
2206
2.34k
  template <class It> NodeArray makeNodeArray(It begin, It end) {
2207
2.34k
    size_t sz = static_cast<size_t>(end - begin);
2208
2.34k
    void *mem = ASTAllocator.allocateNodeArray(sz);
2209
2.34k
    Node **data = new (mem) Node *[sz];
2210
2.34k
    std::copy(begin, end, data);
2211
2.34k
    return NodeArray(data, sz);
2212
2.34k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::NodeArray llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::makeNodeArray<llvm::itanium_demangle::Node**>(llvm::itanium_demangle::Node**, llvm::itanium_demangle::Node**)
Line
Count
Source
2206
395
  template <class It> NodeArray makeNodeArray(It begin, It end) {
2207
395
    size_t sz = static_cast<size_t>(end - begin);
2208
395
    void *mem = ASTAllocator.allocateNodeArray(sz);
2209
395
    Node **data = new (mem) Node *[sz];
2210
395
    std::copy(begin, end, data);
2211
395
    return NodeArray(data, sz);
2212
395
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::NodeArray llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::makeNodeArray<llvm::itanium_demangle::Node**>(llvm::itanium_demangle::Node**, llvm::itanium_demangle::Node**)
Line
Count
Source
2206
1.94k
  template <class It> NodeArray makeNodeArray(It begin, It end) {
2207
1.94k
    size_t sz = static_cast<size_t>(end - begin);
2208
1.94k
    void *mem = ASTAllocator.allocateNodeArray(sz);
2209
1.94k
    Node **data = new (mem) Node *[sz];
2210
1.94k
    std::copy(begin, end, data);
2211
1.94k
    return NodeArray(data, sz);
2212
1.94k
  }
2213
2214
2.34k
  NodeArray popTrailingNodeArray(size_t FromPosition) {
2215
2.34k
    assert(FromPosition <= Names.size());
2216
2.34k
    NodeArray res =
2217
2.34k
        makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
2218
2.34k
    Names.dropBack(FromPosition);
2219
2.34k
    return res;
2220
2.34k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::popTrailingNodeArray(unsigned long)
Line
Count
Source
2214
395
  NodeArray popTrailingNodeArray(size_t FromPosition) {
2215
395
    assert(FromPosition <= Names.size());
2216
395
    NodeArray res =
2217
395
        makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
2218
395
    Names.dropBack(FromPosition);
2219
395
    return res;
2220
395
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::popTrailingNodeArray(unsigned long)
Line
Count
Source
2214
1.94k
  NodeArray popTrailingNodeArray(size_t FromPosition) {
2215
1.94k
    assert(FromPosition <= Names.size());
2216
1.94k
    NodeArray res =
2217
1.94k
        makeNodeArray(Names.begin() + (long)FromPosition, Names.end());
2218
1.94k
    Names.dropBack(FromPosition);
2219
1.94k
    return res;
2220
1.94k
  }
2221
2222
12.5k
  bool consumeIf(StringView S) {
2223
12.5k
    if (StringView(First, Last).startsWith(S)) {
2224
4.05k
      First += S.size();
2225
4.05k
      return true;
2226
4.05k
    }
2227
8.46k
    return false;
2228
8.46k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::consumeIf(llvm::itanium_demangle::StringView)
Line
Count
Source
2222
2.56k
  bool consumeIf(StringView S) {
2223
2.56k
    if (StringView(First, Last).startsWith(S)) {
2224
356
      First += S.size();
2225
356
      return true;
2226
356
    }
2227
2.20k
    return false;
2228
2.20k
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::consumeIf(llvm::itanium_demangle::StringView)
Line
Count
Source
2222
9.95k
  bool consumeIf(StringView S) {
2223
9.95k
    if (StringView(First, Last).startsWith(S)) {
2224
3.69k
      First += S.size();
2225
3.69k
      return true;
2226
3.69k
    }
2227
6.25k
    return false;
2228
6.25k
  }
2229
2230
19.0k
  bool consumeIf(char C) {
2231
19.0k
    if (First != Last && 
*First == C18.9k
) {
2232
7.31k
      ++First;
2233
7.31k
      return true;
2234
7.31k
    }
2235
11.7k
    return false;
2236
11.7k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::consumeIf(char)
Line
Count
Source
2230
6.18k
  bool consumeIf(char C) {
2231
6.18k
    if (First != Last && 
*First == C6.06k
) {
2232
1.23k
      ++First;
2233
1.23k
      return true;
2234
1.23k
    }
2235
4.95k
    return false;
2236
4.95k
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::consumeIf(char)
Line
Count
Source
2230
12.9k
  bool consumeIf(char C) {
2231
12.9k
    if (First != Last && 
*First == C12.8k
) {
2232
6.07k
      ++First;
2233
6.07k
      return true;
2234
6.07k
    }
2235
6.82k
    return false;
2236
6.82k
  }
2237
2238
3.52k
  char consume() { return First != Last ? *First++ : 
'\0'0
; }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::consume()
Line
Count
Source
2238
897
  char consume() { return First != Last ? *First++ : 
'\0'0
; }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::consume()
Line
Count
Source
2238
2.62k
  char consume() { return First != Last ? *First++ : 
'\0'0
; }
2239
2240
76.4k
  char look(unsigned Lookahead = 0) {
2241
76.4k
    if (static_cast<size_t>(Last - First) <= Lookahead)
2242
3.38k
      return '\0';
2243
73.0k
    return First[Lookahead];
2244
73.0k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::look(unsigned int)
Line
Count
Source
2240
15.9k
  char look(unsigned Lookahead = 0) {
2241
15.9k
    if (static_cast<size_t>(Last - First) <= Lookahead)
2242
414
      return '\0';
2243
15.5k
    return First[Lookahead];
2244
15.5k
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::look(unsigned int)
Line
Count
Source
2240
60.5k
  char look(unsigned Lookahead = 0) {
2241
60.5k
    if (static_cast<size_t>(Last - First) <= Lookahead)
2242
2.96k
      return '\0';
2243
57.5k
    return First[Lookahead];
2244
57.5k
  }
2245
2246
16.7k
  size_t numLeft() const { return static_cast<size_t>(Last - First); }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::numLeft() const
Line
Count
Source
2246
1.71k
  size_t numLeft() const { return static_cast<size_t>(Last - First); }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::numLeft() const
Line
Count
Source
2246
15.0k
  size_t numLeft() const { return static_cast<size_t>(Last - First); }
2247
2248
  StringView parseNumber(bool AllowNegative = false);
2249
  Qualifiers parseCVQualifiers();
2250
  bool parsePositiveInteger(size_t *Out);
2251
  StringView parseBareSourceName();
2252
2253
  bool parseSeqId(size_t *Out);
2254
  Node *parseSubstitution();
2255
  Node *parseTemplateParam();
2256
  Node *parseTemplateArgs(bool TagTemplates = false);
2257
  Node *parseTemplateArg();
2258
2259
  /// Parse the <expr> production.
2260
  Node *parseExpr();
2261
  Node *parsePrefixExpr(StringView Kind);
2262
  Node *parseBinaryExpr(StringView Kind);
2263
  Node *parseIntegerLiteral(StringView Lit);
2264
  Node *parseExprPrimary();
2265
  template <class Float> Node *parseFloatingLiteral();
2266
  Node *parseFunctionParam();
2267
  Node *parseNewExpr();
2268
  Node *parseConversionExpr();
2269
  Node *parseBracedExpr();
2270
  Node *parseFoldExpr();
2271
2272
  /// Parse the <type> production.
2273
  Node *parseType();
2274
  Node *parseFunctionType();
2275
  Node *parseVectorType();
2276
  Node *parseDecltype();
2277
  Node *parseArrayType();
2278
  Node *parsePointerToMemberType();
2279
  Node *parseClassEnumType();
2280
  Node *parseQualifiedType();
2281
2282
  Node *parseEncoding();
2283
  bool parseCallOffset();
2284
  Node *parseSpecialName();
2285
2286
  /// Holds some extra information about a <name> that is being parsed. This
2287
  /// information is only pertinent if the <name> refers to an <encoding>.
2288
  struct NameState {
2289
    bool CtorDtorConversion = false;
2290
    bool EndsWithTemplateArgs = false;
2291
    Qualifiers CVQualifiers = QualNone;
2292
    FunctionRefQual ReferenceQualifier = FrefQualNone;
2293
    size_t ForwardTemplateRefsBegin;
2294
2295
    NameState(AbstractManglingParser *Enclosing)
2296
2.29k
        : ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState::NameState(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>*)
Line
Count
Source
2296
259
        : ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState::NameState(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>*)
Line
Count
Source
2296
2.03k
        : ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {}
2297
  };
2298
2299
2.27k
  bool resolveForwardTemplateRefs(NameState &State) {
2300
2.27k
    size_t I = State.ForwardTemplateRefsBegin;
2301
2.27k
    size_t E = ForwardTemplateRefs.size();
2302
2.28k
    for (; I < E; 
++I8
) {
2303
8
      size_t Idx = ForwardTemplateRefs[I]->Index;
2304
8
      if (Idx >= TemplateParams.size())
2305
0
        return true;
2306
8
      ForwardTemplateRefs[I]->Ref = TemplateParams[Idx];
2307
8
    }
2308
2.27k
    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
2309
2.27k
    return false;
2310
2.27k
  }
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::resolveForwardTemplateRefs(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState&)
Line
Count
Source
2299
244
  bool resolveForwardTemplateRefs(NameState &State) {
2300
244
    size_t I = State.ForwardTemplateRefsBegin;
2301
244
    size_t E = ForwardTemplateRefs.size();
2302
251
    for (; I < E; 
++I7
) {
2303
7
      size_t Idx = ForwardTemplateRefs[I]->Index;
2304
7
      if (Idx >= TemplateParams.size())
2305
0
        return true;
2306
7
      ForwardTemplateRefs[I]->Ref = TemplateParams[Idx];
2307
7
    }
2308
244
    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
2309
244
    return false;
2310
244
  }
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::resolveForwardTemplateRefs(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState&)
Line
Count
Source
2299
2.03k
  bool resolveForwardTemplateRefs(NameState &State) {
2300
2.03k
    size_t I = State.ForwardTemplateRefsBegin;
2301
2.03k
    size_t E = ForwardTemplateRefs.size();
2302
2.03k
    for (; I < E; 
++I1
) {
2303
1
      size_t Idx = ForwardTemplateRefs[I]->Index;
2304
1
      if (Idx >= TemplateParams.size())
2305
0
        return true;
2306
1
      ForwardTemplateRefs[I]->Ref = TemplateParams[Idx];
2307
1
    }
2308
2.03k
    ForwardTemplateRefs.dropBack(State.ForwardTemplateRefsBegin);
2309
2.03k
    return false;
2310
2.03k
  }
2311
2312
  /// Parse the <name> production>
2313
  Node *parseName(NameState *State = nullptr);
2314
  Node *parseLocalName(NameState *State);
2315
  Node *parseOperatorName(NameState *State);
2316
  Node *parseUnqualifiedName(NameState *State);
2317
  Node *parseUnnamedTypeName(NameState *State);
2318
  Node *parseSourceName(NameState *State);
2319
  Node *parseUnscopedName(NameState *State);
2320
  Node *parseNestedName(NameState *State);
2321
  Node *parseCtorDtorName(Node *&SoFar, NameState *State);
2322
2323
  Node *parseAbiTags(Node *N);
2324
2325
  /// Parse the <unresolved-name> production.
2326
  Node *parseUnresolvedName();
2327
  Node *parseSimpleId();
2328
  Node *parseBaseUnresolvedName();
2329
  Node *parseUnresolvedType();
2330
  Node *parseDestructorName();
2331
2332
  /// Top-level entry point into the parser.
2333
  Node *parse();
2334
};
2335
2336
const char* parse_discriminator(const char* first, const char* last);
2337
2338
// <name> ::= <nested-name> // N
2339
//        ::= <local-name> # See Scope Encoding below  // Z
2340
//        ::= <unscoped-template-name> <template-args>
2341
//        ::= <unscoped-name>
2342
//
2343
// <unscoped-template-name> ::= <unscoped-name>
2344
//                          ::= <substitution>
2345
template <typename Derived, typename Alloc>
2346
2.72k
Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) {
2347
2.72k
  consumeIf('L'); // extension
2348
2.72k
2349
2.72k
  if (look() == 'N')
2350
281
    return getDerived().parseNestedName(State);
2351
2.44k
  if (look() == 'Z')
2352
18
    return getDerived().parseLocalName(State);
2353
2.42k
2354
2.42k
  //        ::= <unscoped-template-name> <template-args>
2355
2.42k
  if (look() == 'S' && 
look(1) != 't'50
) {
2356
0
    Node *S = getDerived().parseSubstitution();
2357
0
    if (S == nullptr)
2358
0
      return nullptr;
2359
0
    if (look() != 'I')
2360
0
      return nullptr;
2361
0
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2362
0
    if (TA == nullptr)
2363
0
      return nullptr;
2364
0
    if (State) State->EndsWithTemplateArgs = true;
2365
0
    return make<NameWithTemplateArgs>(S, TA);
2366
0
  }
2367
2.42k
2368
2.42k
  Node *N = getDerived().parseUnscopedName(State);
2369
2.42k
  if (N == nullptr)
2370
12
    return nullptr;
2371
2.41k
  //        ::= <unscoped-template-name> <template-args>
2372
2.41k
  if (look() == 'I') {
2373
77
    Subs.push_back(N);
2374
77
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2375
77
    if (TA == nullptr)
2376
0
      return nullptr;
2377
77
    if (State) 
State->EndsWithTemplateArgs = true8
;
2378
77
    return make<NameWithTemplateArgs>(N, TA);
2379
77
  }
2380
2.33k
  //        ::= <unscoped-name>
2381
2.33k
  return N;
2382
2.33k
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2346
662
Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) {
2347
662
  consumeIf('L'); // extension
2348
662
2349
662
  if (look() == 'N')
2350
228
    return getDerived().parseNestedName(State);
2351
434
  if (look() == 'Z')
2352
13
    return getDerived().parseLocalName(State);
2353
421
2354
421
  //        ::= <unscoped-template-name> <template-args>
2355
421
  if (look() == 'S' && 
look(1) != 't'44
) {
2356
0
    Node *S = getDerived().parseSubstitution();
2357
0
    if (S == nullptr)
2358
0
      return nullptr;
2359
0
    if (look() != 'I')
2360
0
      return nullptr;
2361
0
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2362
0
    if (TA == nullptr)
2363
0
      return nullptr;
2364
0
    if (State) State->EndsWithTemplateArgs = true;
2365
0
    return make<NameWithTemplateArgs>(S, TA);
2366
0
  }
2367
421
2368
421
  Node *N = getDerived().parseUnscopedName(State);
2369
421
  if (N == nullptr)
2370
10
    return nullptr;
2371
411
  //        ::= <unscoped-template-name> <template-args>
2372
411
  if (look() == 'I') {
2373
72
    Subs.push_back(N);
2374
72
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2375
72
    if (TA == nullptr)
2376
0
      return nullptr;
2377
72
    if (State) 
State->EndsWithTemplateArgs = true4
;
2378
72
    return make<NameWithTemplateArgs>(N, TA);
2379
72
  }
2380
339
  //        ::= <unscoped-name>
2381
339
  return N;
2382
339
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2346
2.06k
Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) {
2347
2.06k
  consumeIf('L'); // extension
2348
2.06k
2349
2.06k
  if (look() == 'N')
2350
53
    return getDerived().parseNestedName(State);
2351
2.01k
  if (look() == 'Z')
2352
5
    return getDerived().parseLocalName(State);
2353
2.00k
2354
2.00k
  //        ::= <unscoped-template-name> <template-args>
2355
2.00k
  if (look() == 'S' && 
look(1) != 't'6
) {
2356
0
    Node *S = getDerived().parseSubstitution();
2357
0
    if (S == nullptr)
2358
0
      return nullptr;
2359
0
    if (look() != 'I')
2360
0
      return nullptr;
2361
0
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2362
0
    if (TA == nullptr)
2363
0
      return nullptr;
2364
0
    if (State) State->EndsWithTemplateArgs = true;
2365
0
    return make<NameWithTemplateArgs>(S, TA);
2366
0
  }
2367
2.00k
2368
2.00k
  Node *N = getDerived().parseUnscopedName(State);
2369
2.00k
  if (N == nullptr)
2370
2
    return nullptr;
2371
2.00k
  //        ::= <unscoped-template-name> <template-args>
2372
2.00k
  if (look() == 'I') {
2373
5
    Subs.push_back(N);
2374
5
    Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2375
5
    if (TA == nullptr)
2376
0
      return nullptr;
2377
5
    if (State) 
State->EndsWithTemplateArgs = true4
;
2378
5
    return make<NameWithTemplateArgs>(N, TA);
2379
5
  }
2380
2.00k
  //        ::= <unscoped-name>
2381
2.00k
  return N;
2382
2.00k
}
2383
2384
// <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2385
//              := Z <function encoding> E s [<discriminator>]
2386
//              := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
2387
template <typename Derived, typename Alloc>
2388
18
Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
2389
18
  if (!consumeIf('Z'))
2390
0
    return nullptr;
2391
18
  Node *Encoding = getDerived().parseEncoding();
2392
18
  if (Encoding == nullptr || 
!consumeIf('E')10
)
2393
8
    return nullptr;
2394
10
2395
10
  if (consumeIf('s')) {
2396
0
    First = parse_discriminator(First, Last);
2397
0
    auto *StringLitName = make<NameType>("string literal");
2398
0
    if (!StringLitName)
2399
0
      return nullptr;
2400
0
    return make<LocalName>(Encoding, StringLitName);
2401
0
  }
2402
10
2403
10
  if (consumeIf('d')) {
2404
1
    parseNumber(true);
2405
1
    if (!consumeIf('_'))
2406
0
      return nullptr;
2407
1
    Node *N = getDerived().parseName(State);
2408
1
    if (N == nullptr)
2409
0
      return nullptr;
2410
1
    return make<LocalName>(Encoding, N);
2411
1
  }
2412
9
2413
9
  Node *Entity = getDerived().parseName(State);
2414
9
  if (Entity == nullptr)
2415
0
    return nullptr;
2416
9
  First = parse_discriminator(First, Last);
2417
9
  return make<LocalName>(Encoding, Entity);
2418
9
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseLocalName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2388
13
Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
2389
13
  if (!consumeIf('Z'))
2390
0
    return nullptr;
2391
13
  Node *Encoding = getDerived().parseEncoding();
2392
13
  if (Encoding == nullptr || 
!consumeIf('E')5
)
2393
8
    return nullptr;
2394
5
2395
5
  if (consumeIf('s')) {
2396
0
    First = parse_discriminator(First, Last);
2397
0
    auto *StringLitName = make<NameType>("string literal");
2398
0
    if (!StringLitName)
2399
0
      return nullptr;
2400
0
    return make<LocalName>(Encoding, StringLitName);
2401
0
  }
2402
5
2403
5
  if (consumeIf('d')) {
2404
0
    parseNumber(true);
2405
0
    if (!consumeIf('_'))
2406
0
      return nullptr;
2407
0
    Node *N = getDerived().parseName(State);
2408
0
    if (N == nullptr)
2409
0
      return nullptr;
2410
0
    return make<LocalName>(Encoding, N);
2411
0
  }
2412
5
2413
5
  Node *Entity = getDerived().parseName(State);
2414
5
  if (Entity == nullptr)
2415
0
    return nullptr;
2416
5
  First = parse_discriminator(First, Last);
2417
5
  return make<LocalName>(Encoding, Entity);
2418
5
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseLocalName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2388
5
Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
2389
5
  if (!consumeIf('Z'))
2390
0
    return nullptr;
2391
5
  Node *Encoding = getDerived().parseEncoding();
2392
5
  if (Encoding == nullptr || !consumeIf('E'))
2393
0
    return nullptr;
2394
5
2395
5
  if (consumeIf('s')) {
2396
0
    First = parse_discriminator(First, Last);
2397
0
    auto *StringLitName = make<NameType>("string literal");
2398
0
    if (!StringLitName)
2399
0
      return nullptr;
2400
0
    return make<LocalName>(Encoding, StringLitName);
2401
0
  }
2402
5
2403
5
  if (consumeIf('d')) {
2404
1
    parseNumber(true);
2405
1
    if (!consumeIf('_'))
2406
0
      return nullptr;
2407
1
    Node *N = getDerived().parseName(State);
2408
1
    if (N == nullptr)
2409
0
      return nullptr;
2410
1
    return make<LocalName>(Encoding, N);
2411
1
  }
2412
4
2413
4
  Node *Entity = getDerived().parseName(State);
2414
4
  if (Entity == nullptr)
2415
0
    return nullptr;
2416
4
  First = parse_discriminator(First, Last);
2417
4
  return make<LocalName>(Encoding, Entity);
2418
4
}
2419
2420
// <unscoped-name> ::= <unqualified-name>
2421
//                 ::= St <unqualified-name>   # ::std::
2422
// extension       ::= StL<unqualified-name>
2423
template <typename Derived, typename Alloc>
2424
Node *
2425
2.42k
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State) {
2426
2.42k
  if (consumeIf("StL") || consumeIf("St")) {
2427
50
    Node *R = getDerived().parseUnqualifiedName(State);
2428
50
    if (R == nullptr)
2429
0
      return nullptr;
2430
50
    return make<StdQualifiedName>(R);
2431
50
  }
2432
2.37k
  return getDerived().parseUnqualifiedName(State);
2433
2.37k
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseUnscopedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2425
421
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State) {
2426
421
  if (consumeIf("StL") || consumeIf("St")) {
2427
44
    Node *R = getDerived().parseUnqualifiedName(State);
2428
44
    if (R == nullptr)
2429
0
      return nullptr;
2430
44
    return make<StdQualifiedName>(R);
2431
44
  }
2432
377
  return getDerived().parseUnqualifiedName(State);
2433
377
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseUnscopedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2425
2.00k
AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State) {
2426
2.00k
  if (consumeIf("StL") || consumeIf("St")) {
2427
6
    Node *R = getDerived().parseUnqualifiedName(State);
2428
6
    if (R == nullptr)
2429
0
      return nullptr;
2430
6
    return make<StdQualifiedName>(R);
2431
6
  }
2432
2.00k
  return getDerived().parseUnqualifiedName(State);
2433
2.00k
}
2434
2435
// <unqualified-name> ::= <operator-name> [abi-tags]
2436
//                    ::= <ctor-dtor-name>
2437
//                    ::= <source-name>
2438
//                    ::= <unnamed-type-name>
2439
//                    ::= DC <source-name>+ E      # structured binding declaration
2440
template <typename Derived, typename Alloc>
2441
Node *
2442
2.91k
AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(NameState *State) {
2443
2.91k
  // <ctor-dtor-name>s are special-cased in parseNestedName().
2444
2.91k
  Node *Result;
2445
2.91k
  if (look() == 'U')
2446
2
    Result = getDerived().parseUnnamedTypeName(State);
2447
2.91k
  else if (look() >= '1' && 
look() <= '9'2.90k
)
2448
2.87k
    Result = getDerived().parseSourceName(State);
2449
42
  else if (consumeIf("DC")) {
2450
1
    size_t BindingsBegin = Names.size();
2451
3
    do {
2452
3
      Node *Binding = getDerived().parseSourceName(State);
2453
3
      if (Binding == nullptr)
2454
0
        return nullptr;
2455
3
      Names.push_back(Binding);
2456
3
    } while (!consumeIf('E'));
2457
1
    Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2458
1
  } else
2459
41
    Result = getDerived().parseOperatorName(State);
2460
2.91k
  if (Result != nullptr)
2461
2.90k
    Result = getDerived().parseAbiTags(Result);
2462
2.91k
  return Result;
2463
2.91k
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseUnqualifiedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2442
838
AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(NameState *State) {
2443
838
  // <ctor-dtor-name>s are special-cased in parseNestedName().
2444
838
  Node *Result;
2445
838
  if (look() == 'U')
2446
0
    Result = getDerived().parseUnnamedTypeName(State);
2447
838
  else if (look() >= '1' && 
look() <= '9'829
)
2448
820
    Result = getDerived().parseSourceName(State);
2449
18
  else if (consumeIf("DC")) {
2450
0
    size_t BindingsBegin = Names.size();
2451
0
    do {
2452
0
      Node *Binding = getDerived().parseSourceName(State);
2453
0
      if (Binding == nullptr)
2454
0
        return nullptr;
2455
0
      Names.push_back(Binding);
2456
0
    } while (!consumeIf('E'));
2457
0
    Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2458
0
  } else
2459
18
    Result = getDerived().parseOperatorName(State);
2460
838
  if (Result != nullptr)
2461
826
    Result = getDerived().parseAbiTags(Result);
2462
838
  return Result;
2463
838
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseUnqualifiedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2442
2.07k
AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(NameState *State) {
2443
2.07k
  // <ctor-dtor-name>s are special-cased in parseNestedName().
2444
2.07k
  Node *Result;
2445
2.07k
  if (look() == 'U')
2446
2
    Result = getDerived().parseUnnamedTypeName(State);
2447
2.07k
  else if (look() >= '1' && 
look() <= '9'2.07k
)
2448
2.05k
    Result = getDerived().parseSourceName(State);
2449
24
  else if (consumeIf("DC")) {
2450
1
    size_t BindingsBegin = Names.size();
2451
3
    do {
2452
3
      Node *Binding = getDerived().parseSourceName(State);
2453
3
      if (Binding == nullptr)
2454
0
        return nullptr;
2455
3
      Names.push_back(Binding);
2456
3
    } while (!consumeIf('E'));
2457
1
    Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2458
1
  } else
2459
23
    Result = getDerived().parseOperatorName(State);
2460
2.07k
  if (Result != nullptr)
2461
2.07k
    Result = getDerived().parseAbiTags(Result);
2462
2.07k
  return Result;
2463
2.07k
}
2464
2465
// <unnamed-type-name> ::= Ut [<nonnegative number>] _
2466
//                     ::= <closure-type-name>
2467
//
2468
// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
2469
//
2470
// <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
2471
template <typename Derived, typename Alloc>
2472
Node *
2473
2
AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *) {
2474
2
  if (consumeIf("Ut")) {
2475
0
    StringView Count = parseNumber();
2476
0
    if (!consumeIf('_'))
2477
0
      return nullptr;
2478
0
    return make<UnnamedTypeName>(Count);
2479
0
  }
2480
2
  if (consumeIf("Ul")) {
2481
2
    NodeArray Params;
2482
2
    SwapAndRestore<bool> SwapParams(ParsingLambdaParams, true);
2483
2
    if (!consumeIf("vE")) {
2484
0
      size_t ParamsBegin = Names.size();
2485
0
      do {
2486
0
        Node *P = getDerived().parseType();
2487
0
        if (P == nullptr)
2488
0
          return nullptr;
2489
0
        Names.push_back(P);
2490
0
      } while (!consumeIf('E'));
2491
0
      Params = popTrailingNodeArray(ParamsBegin);
2492
0
    }
2493
2
    StringView Count = parseNumber();
2494
2
    if (!consumeIf('_'))
2495
0
      return nullptr;
2496
2
    return make<ClosureTypeName>(Params, Count);
2497
2
  }
2498
0
  if (consumeIf("Ub")) {
2499
0
    (void)parseNumber();
2500
0
    if (!consumeIf('_'))
2501
0
      return nullptr;
2502
0
    return make<NameType>("'block-literal'");
2503
0
  }
2504
0
  return nullptr;
2505
0
}
Unexecuted instantiation: ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseUnnamedTypeName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseUnnamedTypeName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2473
2
AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *) {
2474
2
  if (consumeIf("Ut")) {
2475
0
    StringView Count = parseNumber();
2476
0
    if (!consumeIf('_'))
2477
0
      return nullptr;
2478
0
    return make<UnnamedTypeName>(Count);
2479
0
  }
2480
2
  if (consumeIf("Ul")) {
2481
2
    NodeArray Params;
2482
2
    SwapAndRestore<bool> SwapParams(ParsingLambdaParams, true);
2483
2
    if (!consumeIf("vE")) {
2484
0
      size_t ParamsBegin = Names.size();
2485
0
      do {
2486
0
        Node *P = getDerived().parseType();
2487
0
        if (P == nullptr)
2488
0
          return nullptr;
2489
0
        Names.push_back(P);
2490
0
      } while (!consumeIf('E'));
2491
0
      Params = popTrailingNodeArray(ParamsBegin);
2492
0
    }
2493
2
    StringView Count = parseNumber();
2494
2
    if (!consumeIf('_'))
2495
0
      return nullptr;
2496
2
    return make<ClosureTypeName>(Params, Count);
2497
2
  }
2498
0
  if (consumeIf("Ub")) {
2499
0
    (void)parseNumber();
2500
0
    if (!consumeIf('_'))
2501
0
      return nullptr;
2502
0
    return make<NameType>("'block-literal'");
2503
0
  }
2504
0
  return nullptr;
2505
0
}
2506
2507
// <source-name> ::= <positive length number> <identifier>
2508
template <typename Derived, typename Alloc>
2509
2.87k
Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
2510
2.87k
  size_t Length = 0;
2511
2.87k
  if (parsePositiveInteger(&Length))
2512
0
    return nullptr;
2513
2.87k
  if (numLeft() < Length || Length == 0)
2514
0
    return nullptr;
2515
2.87k
  StringView Name(First, First + Length);
2516
2.87k
  First += Length;
2517
2.87k
  if (Name.startsWith("_GLOBAL__N"))
2518
0
    return make<NameType>("(anonymous namespace)");
2519
2.87k
  return make<NameType>(Name);
2520
2.87k
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseSourceName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2509
820
Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
2510
820
  size_t Length = 0;
2511
820
  if (parsePositiveInteger(&Length))
2512
0
    return nullptr;
2513
820
  if (numLeft() < Length || Length == 0)
2514
0
    return nullptr;
2515
820
  StringView Name(First, First + Length);
2516
820
  First += Length;
2517
820
  if (Name.startsWith("_GLOBAL__N"))
2518
0
    return make<NameType>("(anonymous namespace)");
2519
820
  return make<NameType>(Name);
2520
820
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseSourceName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2509
2.05k
Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
2510
2.05k
  size_t Length = 0;
2511
2.05k
  if (parsePositiveInteger(&Length))
2512
0
    return nullptr;
2513
2.05k
  if (numLeft() < Length || Length == 0)
2514
0
    return nullptr;
2515
2.05k
  StringView Name(First, First + Length);
2516
2.05k
  First += Length;
2517
2.05k
  if (Name.startsWith("_GLOBAL__N"))
2518
0
    return make<NameType>("(anonymous namespace)");
2519
2.05k
  return make<NameType>(Name);
2520
2.05k
}
2521
2522
//   <operator-name> ::= aa    # &&
2523
//                   ::= ad    # & (unary)
2524
//                   ::= an    # &
2525
//                   ::= aN    # &=
2526
//                   ::= aS    # =
2527
//                   ::= cl    # ()
2528
//                   ::= cm    # ,
2529
//                   ::= co    # ~
2530
//                   ::= cv <type>    # (cast)
2531
//                   ::= da    # delete[]
2532
//                   ::= de    # * (unary)
2533
//                   ::= dl    # delete
2534
//                   ::= dv    # /
2535
//                   ::= dV    # /=
2536
//                   ::= eo    # ^
2537
//                   ::= eO    # ^=
2538
//                   ::= eq    # ==
2539
//                   ::= ge    # >=
2540
//                   ::= gt    # >
2541
//                   ::= ix    # []
2542
//                   ::= le    # <=
2543
//                   ::= li <source-name>  # operator ""
2544
//                   ::= ls    # <<
2545
//                   ::= lS    # <<=
2546
//                   ::= lt    # <
2547
//                   ::= mi    # -
2548
//                   ::= mI    # -=
2549
//                   ::= ml    # *
2550
//                   ::= mL    # *=
2551
//                   ::= mm    # -- (postfix in <expression> context)
2552
//                   ::= na    # new[]
2553
//                   ::= ne    # !=
2554
//                   ::= ng    # - (unary)
2555
//                   ::= nt    # !
2556
//                   ::= nw    # new
2557
//                   ::= oo    # ||
2558
//                   ::= or    # |
2559
//                   ::= oR    # |=
2560
//                   ::= pm    # ->*
2561
//                   ::= pl    # +
2562
//                   ::= pL    # +=
2563
//                   ::= pp    # ++ (postfix in <expression> context)
2564
//                   ::= ps    # + (unary)
2565
//                   ::= pt    # ->
2566
//                   ::= qu    # ?
2567
//                   ::= rm    # %
2568
//                   ::= rM    # %=
2569
//                   ::= rs    # >>
2570
//                   ::= rS    # >>=
2571
//                   ::= ss    # <=> C++2a
2572
//                   ::= v <digit> <source-name>        # vendor extended operator
2573
template <typename Derived, typename Alloc>
2574
Node *
2575
41
AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
2576
41
  switch (look()) {
2577
41
  case 'a':
2578
0
    switch (look(1)) {
2579
0
    case 'a':
2580
0
      First += 2;
2581
0
      return make<NameType>("operator&&");
2582
0
    case 'd':
2583
0
    case 'n':
2584
0
      First += 2;
2585
0
      return make<NameType>("operator&");
2586
0
    case 'N':
2587
0
      First += 2;
2588
0
      return make<NameType>("operator&=");
2589
0
    case 'S':
2590
0
      First += 2;
2591
0
      return make<NameType>("operator=");
2592
0
    }
2593
0
    return nullptr;
2594
13
  case 'c':
2595
13
    switch (look(1)) {
2596
13
    case 'l':
2597
4
      First += 2;
2598
4
      return make<NameType>("operator()");
2599
13
    case 'm':
2600
0
      First += 2;
2601
0
      return make<NameType>("operator,");
2602
13
    case 'o':
2603
0
      First += 2;
2604
0
      return make<NameType>("operator~");
2605
13
    //                   ::= cv <type>    # (cast)
2606
13
    case 'v': {
2607
9
      First += 2;
2608
9
      SwapAndRestore<bool> SaveTemplate(TryToParseTemplateArgs, false);
2609
9
      // If we're parsing an encoding, State != nullptr and the conversion
2610
9
      // operators' <type> could have a <template-param> that refers to some
2611
9
      // <template-arg>s further ahead in the mangled name.
2612
9
      SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
2613
9
                                      PermitForwardTemplateReferences ||
2614
9
                                          State != nullptr);
2615
9
      Node *Ty = getDerived().parseType();
2616
9
      if (Ty == nullptr)
2617
1
        return nullptr;
2618
8
      if (State) State->CtorDtorConversion = true;
2619
8
      return make<ConversionOperatorType>(Ty);
2620
8
    }
2621
0
    }
2622
0
    return nullptr;
2623
0
  case 'd':
2624
0
    switch (look(1)) {
2625
0
    case 'a':
2626
0
      First += 2;
2627
0
      return make<NameType>("operator delete[]");
2628
0
    case 'e':
2629
0
      First += 2;
2630
0
      return make<NameType>("operator*");
2631
0
    case 'l':
2632
0
      First += 2;
2633
0
      return make<NameType>("operator delete");
2634
0
    case 'v':
2635
0
      First += 2;
2636
0
      return make<NameType>("operator/");
2637
0
    case 'V':
2638
0
      First += 2;
2639
0
      return make<NameType>("operator/=");
2640
0
    }
2641
0
    return nullptr;
2642
0
  case 'e':
2643
0
    switch (look(1)) {
2644
0
    case 'o':
2645
0
      First += 2;
2646
0
      return make<NameType>("operator^");
2647
0
    case 'O':
2648
0
      First += 2;
2649
0
      return make<NameType>("operator^=");
2650
0
    case 'q':
2651
0
      First += 2;
2652
0
      return make<NameType>("operator==");
2653
0
    }
2654
0
    return nullptr;
2655
0
  case 'g':
2656
0
    switch (look(1)) {
2657
0
    case 'e':
2658
0
      First += 2;
2659
0
      return make<NameType>("operator>=");
2660
0
    case 't':
2661
0
      First += 2;
2662
0
      return make<NameType>("operator>");
2663
0
    }
2664
0
    return nullptr;
2665
2
  case 'i':
2666
2
    if (look(1) == 'x') {
2667
1
      First += 2;
2668
1
      return make<NameType>("operator[]");
2669
1
    }
2670
1
    return nullptr;
2671
1
  case 'l':
2672
0
    switch (look(1)) {
2673
0
    case 'e':
2674
0
      First += 2;
2675
0
      return make<NameType>("operator<=");
2676
0
    //                   ::= li <source-name>  # operator ""
2677
0
    case 'i': {
2678
0
      First += 2;
2679
0
      Node *SN = getDerived().parseSourceName(State);
2680
0
      if (SN == nullptr)
2681
0
        return nullptr;
2682
0
      return make<LiteralOperator>(SN);
2683
0
    }
2684
0
    case 's':
2685
0
      First += 2;
2686
0
      return make<NameType>("operator<<");
2687
0
    case 'S':
2688
0
      First += 2;
2689
0
      return make<NameType>("operator<<=");
2690
0
    case 't':
2691
0
      First += 2;
2692
0
      return make<NameType>("operator<");
2693
0
    }
2694
0
    return nullptr;
2695
0
  case 'm':
2696
0
    switch (look(1)) {
2697
0
    case 'i':
2698
0
      First += 2;
2699
0
      return make<NameType>("operator-");
2700
0
    case 'I':
2701
0
      First += 2;
2702
0
      return make<NameType>("operator-=");
2703
0
    case 'l':
2704
0
      First += 2;
2705
0
      return make<NameType>("operator*");
2706
0
    case 'L':
2707
0
      First += 2;
2708
0
      return make<NameType>("operator*=");
2709
0
    case 'm':
2710
0
      First += 2;
2711
0
      return make<NameType>("operator--");
2712
0
    }
2713
0
    return nullptr;
2714
5
  case 'n':
2715
5
    switch (look(1)) {
2716
5
    case 'a':
2717
1
      First += 2;
2718
1
      return make<NameType>("operator new[]");
2719
5
    case 'e':
2720
0
      First += 2;
2721
0
      return make<NameType>("operator!=");
2722
5
    case 'g':
2723
0
      First += 2;
2724
0
      return make<NameType>("operator-");
2725
5
    case 't':
2726
0
      First += 2;
2727
0
      return make<NameType>("operator!");
2728
5
    case 'w':
2729
3
      First += 2;
2730
3
      return make<NameType>("operator new");
2731
1
    }
2732
1
    return nullptr;
2733
1
  case 'o':
2734
1
    switch (look(1)) {
2735
1
    case 'o':
2736
0
      First += 2;
2737
0
      return make<NameType>("operator||");
2738
1
    case 'r':
2739
0
      First += 2;
2740
0
      return make<NameType>("operator|");
2741
1
    case 'R':
2742
0
      First += 2;
2743
0
      return make<NameType>("operator|=");
2744
1
    }
2745
1
    return nullptr;
2746
1
  case 'p':
2747
0
    switch (look(1)) {
2748
0
    case 'm':
2749
0
      First += 2;
2750
0
      return make<NameType>("operator->*");
2751
0
    case 'l':
2752
0
      First += 2;
2753
0
      return make<NameType>("operator+");
2754
0
    case 'L':
2755
0
      First += 2;
2756
0
      return make<NameType>("operator+=");
2757
0
    case 'p':
2758
0
      First += 2;
2759
0
      return make<NameType>("operator++");
2760
0
    case 's':
2761
0
      First += 2;
2762
0
      return make<NameType>("operator+");
2763
0
    case 't':
2764
0
      First += 2;
2765
0
      return make<NameType>("operator->");
2766
0
    }
2767
0
    return nullptr;
2768
10
  case 'q':
2769
10
    if (look(1) == 'u') {
2770
10
      First += 2;
2771
10
      return make<NameType>("operator?");
2772
10
    }
2773
0
    return nullptr;
2774
0
  case 'r':
2775
0
    switch (look(1)) {
2776
0
    case 'm':
2777
0
      First += 2;
2778
0
      return make<NameType>("operator%");
2779
0
    case 'M':
2780
0
      First += 2;
2781
0
      return make<NameType>("operator%=");
2782
0
    case 's':
2783
0
      First += 2;
2784
0
      return make<NameType>("operator>>");
2785
0
    case 'S':
2786
0
      First += 2;
2787
0
      return make<NameType>("operator>>=");
2788
0
    }
2789
0
    return nullptr;
2790
0
  case 's':
2791
0
    if (look(1) == 's') {
2792
0
      First += 2;
2793
0
      return make<NameType>("operator<=>");
2794
0
    }
2795
0
    return nullptr;
2796
0
  // ::= v <digit> <source-name>        # vendor extended operator
2797
0
  case 'v':
2798
0
    if (std::isdigit(look(1))) {
2799
0
      First += 2;
2800
0
      Node *SN = getDerived().parseSourceName(State);
2801
0
      if (SN == nullptr)
2802
0
        return nullptr;
2803
0
      return make<ConversionOperatorType>(SN);
2804
0
    }
2805
0
    return nullptr;
2806
10
  }
2807
10
  return nullptr;
2808
10
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseOperatorName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2575
18
AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
2576
18
  switch (look()) {
2577
18
  case 'a':
2578
0
    switch (look(1)) {
2579
0
    case 'a':
2580
0
      First += 2;
2581
0
      return make<NameType>("operator&&");
2582
0
    case 'd':
2583
0
    case 'n':
2584
0
      First += 2;
2585
0
      return make<NameType>("operator&");
2586
0
    case 'N':
2587
0
      First += 2;
2588
0
      return make<NameType>("operator&=");
2589
0
    case 'S':
2590
0
      First += 2;
2591
0
      return make<NameType>("operator=");
2592
0
    }
2593
0
    return nullptr;
2594
8
  case 'c':
2595
8
    switch (look(1)) {
2596
8
    case 'l':
2597
0
      First += 2;
2598
0
      return make<NameType>("operator()");
2599
8
    case 'm':
2600
0
      First += 2;
2601
0
      return make<NameType>("operator,");
2602
8
    case 'o':
2603
0
      First += 2;
2604
0
      return make<NameType>("operator~");
2605
8
    //                   ::= cv <type>    # (cast)
2606
8
    case 'v': {
2607
8
      First += 2;
2608
8
      SwapAndRestore<bool> SaveTemplate(TryToParseTemplateArgs, false);
2609
8
      // If we're parsing an encoding, State != nullptr and the conversion
2610
8
      // operators' <type> could have a <template-param> that refers to some
2611
8
      // <template-arg>s further ahead in the mangled name.
2612
8
      SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
2613
8
                                      PermitForwardTemplateReferences ||
2614
8
                                          State != nullptr);
2615
8
      Node *Ty = getDerived().parseType();
2616
8
      if (Ty == nullptr)
2617
1
        return nullptr;
2618
7
      if (State) State->CtorDtorConversion = true;
2619
7
      return make<ConversionOperatorType>(Ty);
2620
7
    }
2621
0
    }
2622
0
    return nullptr;
2623
0
  case 'd':
2624
0
    switch (look(1)) {
2625
0
    case 'a':
2626
0
      First += 2;
2627
0
      return make<NameType>("operator delete[]");
2628
0
    case 'e':
2629
0
      First += 2;
2630
0
      return make<NameType>("operator*");
2631
0
    case 'l':
2632
0
      First += 2;
2633
0
      return make<NameType>("operator delete");
2634
0
    case 'v':
2635
0
      First += 2;
2636
0
      return make<NameType>("operator/");
2637
0
    case 'V':
2638
0
      First += 2;
2639
0
      return make<NameType>("operator/=");
2640
0
    }
2641
0
    return nullptr;
2642
0
  case 'e':
2643
0
    switch (look(1)) {
2644
0
    case 'o':
2645
0
      First += 2;
2646
0
      return make<NameType>("operator^");
2647
0
    case 'O':
2648
0
      First += 2;
2649
0
      return make<NameType>("operator^=");
2650
0
    case 'q':
2651
0
      First += 2;
2652
0
      return make<NameType>("operator==");
2653
0
    }
2654
0
    return nullptr;
2655
0
  case 'g':
2656
0
    switch (look(1)) {
2657
0
    case 'e':
2658
0
      First += 2;
2659
0
      return make<NameType>("operator>=");
2660
0
    case 't':
2661
0
      First += 2;
2662
0
      return make<NameType>("operator>");
2663
0
    }
2664
0
    return nullptr;
2665
1
  case 'i':
2666
1
    if (look(1) == 'x') {
2667
0
      First += 2;
2668
0
      return make<NameType>("operator[]");
2669
0
    }
2670
1
    return nullptr;
2671
1
  case 'l':
2672
0
    switch (look(1)) {
2673
0
    case 'e':
2674
0
      First += 2;
2675
0
      return make<NameType>("operator<=");
2676
0
    //                   ::= li <source-name>  # operator ""
2677
0
    case 'i': {
2678
0
      First += 2;
2679
0
      Node *SN = getDerived().parseSourceName(State);
2680
0
      if (SN == nullptr)
2681
0
        return nullptr;
2682
0
      return make<LiteralOperator>(SN);
2683
0
    }
2684
0
    case 's':
2685
0
      First += 2;
2686
0
      return make<NameType>("operator<<");
2687
0
    case 'S':
2688
0
      First += 2;
2689
0
      return make<NameType>("operator<<=");
2690
0
    case 't':
2691
0
      First += 2;
2692
0
      return make<NameType>("operator<");
2693
0
    }
2694
0
    return nullptr;
2695
0
  case 'm':
2696
0
    switch (look(1)) {
2697
0
    case 'i':
2698
0
      First += 2;
2699
0
      return make<NameType>("operator-");
2700
0
    case 'I':
2701
0
      First += 2;
2702
0
      return make<NameType>("operator-=");
2703
0
    case 'l':
2704
0
      First += 2;
2705
0
      return make<NameType>("operator*");
2706
0
    case 'L':
2707
0
      First += 2;
2708
0
      return make<NameType>("operator*=");
2709
0
    case 'm':
2710
0
      First += 2;
2711
0
      return make<NameType>("operator--");
2712
0
    }
2713
0
    return nullptr;
2714
0
  case 'n':
2715
0
    switch (look(1)) {
2716
0
    case 'a':
2717
0
      First += 2;
2718
0
      return make<NameType>("operator new[]");
2719
0
    case 'e':
2720
0
      First += 2;
2721
0
      return make<NameType>("operator!=");
2722
0
    case 'g':
2723
0
      First += 2;
2724
0
      return make<NameType>("operator-");
2725
0
    case 't':
2726
0
      First += 2;
2727
0
      return make<NameType>("operator!");
2728
0
    case 'w':
2729
0
      First += 2;
2730
0
      return make<NameType>("operator new");
2731
0
    }
2732
0
    return nullptr;
2733
0
  case 'o':
2734
0
    switch (look(1)) {
2735
0
    case 'o':
2736
0
      First += 2;
2737
0
      return make<NameType>("operator||");
2738
0
    case 'r':
2739
0
      First += 2;
2740
0
      return make<NameType>("operator|");
2741
0
    case 'R':
2742
0
      First += 2;
2743
0
      return make<NameType>("operator|=");
2744
0
    }
2745
0
    return nullptr;
2746
0
  case 'p':
2747
0
    switch (look(1)) {
2748
0
    case 'm':
2749
0
      First += 2;
2750
0
      return make<NameType>("operator->*");
2751
0
    case 'l':
2752
0
      First += 2;
2753
0
      return make<NameType>("operator+");
2754
0
    case 'L':
2755
0
      First += 2;
2756
0
      return make<NameType>("operator+=");
2757
0
    case 'p':
2758
0
      First += 2;
2759
0
      return make<NameType>("operator++");
2760
0
    case 's':
2761
0
      First += 2;
2762
0
      return make<NameType>("operator+");
2763
0
    case 't':
2764
0
      First += 2;
2765
0
      return make<NameType>("operator->");
2766
0
    }
2767
0
    return nullptr;
2768
0
  case 'q':
2769
0
    if (look(1) == 'u') {
2770
0
      First += 2;
2771
0
      return make<NameType>("operator?");
2772
0
    }
2773
0
    return nullptr;
2774
0
  case 'r':
2775
0
    switch (look(1)) {
2776
0
    case 'm':
2777
0
      First += 2;
2778
0
      return make<NameType>("operator%");
2779
0
    case 'M':
2780
0
      First += 2;
2781
0
      return make<NameType>("operator%=");
2782
0
    case 's':
2783
0
      First += 2;
2784
0
      return make<NameType>("operator>>");
2785
0
    case 'S':
2786
0
      First += 2;
2787
0
      return make<NameType>("operator>>=");
2788
0
    }
2789
0
    return nullptr;
2790
0
  case 's':
2791
0
    if (look(1) == 's') {
2792
0
      First += 2;
2793
0
      return make<NameType>("operator<=>");
2794
0
    }
2795
0
    return nullptr;
2796
0
  // ::= v <digit> <source-name>        # vendor extended operator
2797
0
  case 'v':
2798
0
    if (std::isdigit(look(1))) {
2799
0
      First += 2;
2800
0
      Node *SN = getDerived().parseSourceName(State);
2801
0
      if (SN == nullptr)
2802
0
        return nullptr;
2803
0
      return make<ConversionOperatorType>(SN);
2804
0
    }
2805
0
    return nullptr;
2806
9
  }
2807
9
  return nullptr;
2808
9
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseOperatorName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2575
23
AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
2576
23
  switch (look()) {
2577
23
  case 'a':
2578
0
    switch (look(1)) {
2579
0
    case 'a':
2580
0
      First += 2;
2581
0
      return make<NameType>("operator&&");
2582
0
    case 'd':
2583
0
    case 'n':
2584
0
      First += 2;
2585
0
      return make<NameType>("operator&");
2586
0
    case 'N':
2587
0
      First += 2;
2588
0
      return make<NameType>("operator&=");
2589
0
    case 'S':
2590
0
      First += 2;
2591
0
      return make<NameType>("operator=");
2592
0
    }
2593
0
    return nullptr;
2594
5
  case 'c':
2595
5
    switch (look(1)) {
2596
5
    case 'l':
2597
4
      First += 2;
2598
4
      return make<NameType>("operator()");
2599
5
    case 'm':
2600
0
      First += 2;
2601
0
      return make<NameType>("operator,");
2602
5
    case 'o':
2603
0
      First += 2;
2604
0
      return make<NameType>("operator~");
2605
5
    //                   ::= cv <type>    # (cast)
2606
5
    case 'v': {
2607
1
      First += 2;
2608
1
      SwapAndRestore<bool> SaveTemplate(TryToParseTemplateArgs, false);
2609
1
      // If we're parsing an encoding, State != nullptr and the conversion
2610
1
      // operators' <type> could have a <template-param> that refers to some
2611
1
      // <template-arg>s further ahead in the mangled name.
2612
1
      SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
2613
1
                                      PermitForwardTemplateReferences ||
2614
1
                                          State != nullptr);
2615
1
      Node *Ty = getDerived().parseType();
2616
1
      if (Ty == nullptr)
2617
0
        return nullptr;
2618
1
      if (State) State->CtorDtorConversion = true;
2619
1
      return make<ConversionOperatorType>(Ty);
2620
1
    }
2621
0
    }
2622
0
    return nullptr;
2623
0
  case 'd':
2624
0
    switch (look(1)) {
2625
0
    case 'a':
2626
0
      First += 2;
2627
0
      return make<NameType>("operator delete[]");
2628
0
    case 'e':
2629
0
      First += 2;
2630
0
      return make<NameType>("operator*");
2631
0
    case 'l':
2632
0
      First += 2;
2633
0
      return make<NameType>("operator delete");
2634
0
    case 'v':
2635
0
      First += 2;
2636
0
      return make<NameType>("operator/");
2637
0
    case 'V':
2638
0
      First += 2;
2639
0
      return make<NameType>("operator/=");
2640
0
    }
2641
0
    return nullptr;
2642
0
  case 'e':
2643
0
    switch (look(1)) {
2644
0
    case 'o':
2645
0
      First += 2;
2646
0
      return make<NameType>("operator^");
2647
0
    case 'O':
2648
0
      First += 2;
2649
0
      return make<NameType>("operator^=");
2650
0
    case 'q':
2651
0
      First += 2;
2652
0
      return make<NameType>("operator==");
2653
0
    }
2654
0
    return nullptr;
2655
0
  case 'g':
2656
0
    switch (look(1)) {
2657
0
    case 'e':
2658
0
      First += 2;
2659
0
      return make<NameType>("operator>=");
2660
0
    case 't':
2661
0
      First += 2;
2662
0
      return make<NameType>("operator>");
2663
0
    }
2664
0
    return nullptr;
2665
1
  case 'i':
2666
1
    if (look(1) == 'x') {
2667
1
      First += 2;
2668
1
      return make<NameType>("operator[]");
2669
1
    }
2670
0
    return nullptr;
2671
0
  case 'l':
2672
0
    switch (look(1)) {
2673
0
    case 'e':
2674
0
      First += 2;
2675
0
      return make<NameType>("operator<=");
2676
0
    //                   ::= li <source-name>  # operator ""
2677
0
    case 'i': {
2678
0
      First += 2;
2679
0
      Node *SN = getDerived().parseSourceName(State);
2680
0
      if (SN == nullptr)
2681
0
        return nullptr;
2682
0
      return make<LiteralOperator>(SN);
2683
0
    }
2684
0
    case 's':
2685
0
      First += 2;
2686
0
      return make<NameType>("operator<<");
2687
0
    case 'S':
2688
0
      First += 2;
2689
0
      return make<NameType>("operator<<=");
2690
0
    case 't':
2691
0
      First += 2;
2692
0
      return make<NameType>("operator<");
2693
0
    }
2694
0
    return nullptr;
2695
0
  case 'm':
2696
0
    switch (look(1)) {
2697
0
    case 'i':
2698
0
      First += 2;
2699
0
      return make<NameType>("operator-");
2700
0
    case 'I':
2701
0
      First += 2;
2702
0
      return make<NameType>("operator-=");
2703
0
    case 'l':
2704
0
      First += 2;
2705
0
      return make<NameType>("operator*");
2706
0
    case 'L':
2707
0
      First += 2;
2708
0
      return make<NameType>("operator*=");
2709
0
    case 'm':
2710
0
      First += 2;
2711
0
      return make<NameType>("operator--");
2712
0
    }
2713
0
    return nullptr;
2714
5
  case 'n':
2715
5
    switch (look(1)) {
2716
5
    case 'a':
2717
1
      First += 2;
2718
1
      return make<NameType>("operator new[]");
2719
5
    case 'e':
2720
0
      First += 2;
2721
0
      return make<NameType>("operator!=");
2722
5
    case 'g':
2723
0
      First += 2;
2724
0
      return make<NameType>("operator-");
2725
5
    case 't':
2726
0
      First += 2;
2727
0
      return make<NameType>("operator!");
2728
5
    case 'w':
2729
3
      First += 2;
2730
3
      return make<NameType>("operator new");
2731
1
    }
2732
1
    return nullptr;
2733
1
  case 'o':
2734
1
    switch (look(1)) {
2735
1
    case 'o':
2736
0
      First += 2;
2737
0
      return make<NameType>("operator||");
2738
1
    case 'r':
2739
0
      First += 2;
2740
0
      return make<NameType>("operator|");
2741
1
    case 'R':
2742
0
      First += 2;
2743
0
      return make<NameType>("operator|=");
2744
1
    }
2745
1
    return nullptr;
2746
1
  case 'p':
2747
0
    switch (look(1)) {
2748
0
    case 'm':
2749
0
      First += 2;
2750
0
      return make<NameType>("operator->*");
2751
0
    case 'l':
2752
0
      First += 2;
2753
0
      return make<NameType>("operator+");
2754
0
    case 'L':
2755
0
      First += 2;
2756
0
      return make<NameType>("operator+=");
2757
0
    case 'p':
2758
0
      First += 2;
2759
0
      return make<NameType>("operator++");
2760
0
    case 's':
2761
0
      First += 2;
2762
0
      return make<NameType>("operator+");
2763
0
    case 't':
2764
0
      First += 2;
2765
0
      return make<NameType>("operator->");
2766
0
    }
2767
0
    return nullptr;
2768
10
  case 'q':
2769
10
    if (look(1) == 'u') {
2770
10
      First += 2;
2771
10
      return make<NameType>("operator?");
2772
10
    }
2773
0
    return nullptr;
2774
0
  case 'r':
2775
0
    switch (look(1)) {
2776
0
    case 'm':
2777
0
      First += 2;
2778
0
      return make<NameType>("operator%");
2779
0
    case 'M':
2780
0
      First += 2;
2781
0
      return make<NameType>("operator%=");
2782
0
    case 's':
2783
0
      First += 2;
2784
0
      return make<NameType>("operator>>");
2785
0
    case 'S':
2786
0
      First += 2;
2787
0
      return make<NameType>("operator>>=");
2788
0
    }
2789
0
    return nullptr;
2790
0
  case 's':
2791
0
    if (look(1) == 's') {
2792
0
      First += 2;
2793
0
      return make<NameType>("operator<=>");
2794
0
    }
2795
0
    return nullptr;
2796
0
  // ::= v <digit> <source-name>        # vendor extended operator
2797
0
  case 'v':
2798
0
    if (std::isdigit(look(1))) {
2799
0
      First += 2;
2800
0
      Node *SN = getDerived().parseSourceName(State);
2801
0
      if (SN == nullptr)
2802
0
        return nullptr;
2803
0
      return make<ConversionOperatorType>(SN);
2804
0
    }
2805
0
    return nullptr;
2806
1
  }
2807
1
  return nullptr;
2808
1
}
2809
2810
// <ctor-dtor-name> ::= C1  # complete object constructor
2811
//                  ::= C2  # base object constructor
2812
//                  ::= C3  # complete object allocating constructor
2813
//   extension      ::= C4  # gcc old-style "[unified]" constructor
2814
//   extension      ::= C5  # the COMDAT used for ctors
2815
//                  ::= D0  # deleting destructor
2816
//                  ::= D1  # complete object destructor
2817
//                  ::= D2  # base object destructor
2818
//   extension      ::= D4  # gcc old-style "[unified]" destructor
2819
//   extension      ::= D5  # the COMDAT used for dtors
2820
template <typename Derived, typename Alloc>
2821
Node *
2822
AbstractManglingParser<Derived, Alloc>::parseCtorDtorName(Node *&SoFar,
2823
35
                                                          NameState *State) {
2824
35
  if (SoFar->getKind() == Node::KSpecialSubstitution) {
2825
1
    auto SSK = static_cast<SpecialSubstitution *>(SoFar)->SSK;
2826
1
    switch (SSK) {
2827
1
    case SpecialSubKind::string:
2828
1
    case SpecialSubKind::istream:
2829
1
    case SpecialSubKind::ostream:
2830
1
    case SpecialSubKind::iostream:
2831
1
      SoFar = make<ExpandedSpecialSubstitution>(SSK);
2832
1
      if (!SoFar)
2833
0
        return nullptr;
2834
1
      break;
2835
1
    default:
2836
0
      break;
2837
35
    }
2838
35
  }
2839
35
2840
35
  if (consumeIf('C')) {
2841
25
    bool IsInherited = consumeIf('I');
2842
25
    if (look() != '1' && 
look() != '2'12
&&
look() != '3'0
&&
look() != '4'0
&&
2843
25
        
look() != '5'0
)
2844
0
      return nullptr;
2845
25
    int Variant = look() - '0';
2846
25
    ++First;
2847
25
    if (State) State->CtorDtorConversion = true;
2848
25
    if (IsInherited) {
2849
1
      if (getDerived().parseName(State) == nullptr)
2850
0
        return nullptr;
2851
25
    }
2852
25
    return make<CtorDtorName>(SoFar, /*IsDtor=*/false, Variant);
2853
25
  }
2854
10
2855
10
  if (look() == 'D' && (look(1) == '0' || look(1) == '1' || 
look(1) == '2'6
||
2856
10
                        
look(1) == '4'0
||
look(1) == '5'0
)) {
2857
10
    int Variant = look(1) - '0';
2858
10
    First += 2;
2859
10
    if (State) State->CtorDtorConversion = true;
2860
10
    return make<CtorDtorName>(SoFar, /*IsDtor=*/true, Variant);
2861
10
  }
2862
0
2863
0
  return nullptr;
2864
0
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseCtorDtorName(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2823
12
                                                          NameState *State) {
2824
12
  if (SoFar->getKind() == Node::KSpecialSubstitution) {
2825
0
    auto SSK = static_cast<SpecialSubstitution *>(SoFar)->SSK;
2826
0
    switch (SSK) {
2827
0
    case SpecialSubKind::string:
2828
0
    case SpecialSubKind::istream:
2829
0
    case SpecialSubKind::ostream:
2830
0
    case SpecialSubKind::iostream:
2831
0
      SoFar = make<ExpandedSpecialSubstitution>(SSK);
2832
0
      if (!SoFar)
2833
0
        return nullptr;
2834
0
      break;
2835
0
    default:
2836
0
      break;
2837
12
    }
2838
12
  }
2839
12
2840
12
  if (consumeIf('C')) {
2841
6
    bool IsInherited = consumeIf('I');
2842
6
    if (look() != '1' && 
look() != '2'3
&&
look() != '3'0
&&
look() != '4'0
&&
2843
6
        
look() != '5'0
)
2844
0
      return nullptr;
2845
6
    int Variant = look() - '0';
2846
6
    ++First;
2847
6
    if (State) State->CtorDtorConversion = true;
2848
6
    if (IsInherited) {
2849
0
      if (getDerived().parseName(State) == nullptr)
2850
0
        return nullptr;
2851
6
    }
2852
6
    return make<CtorDtorName>(SoFar, /*IsDtor=*/false, Variant);
2853
6
  }
2854
6
2855
6
  if (look() == 'D' && (look(1) == '0' || look(1) == '1' || 
look(1) == '2'3
||
2856
6
                        
look(1) == '4'0
||
look(1) == '5'0
)) {
2857
6
    int Variant = look(1) - '0';
2858
6
    First += 2;
2859
6
    if (State) State->CtorDtorConversion = true;
2860
6
    return make<CtorDtorName>(SoFar, /*IsDtor=*/true, Variant);
2861
6
  }
2862
0
2863
0
  return nullptr;
2864
0
}
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseCtorDtorName(llvm::itanium_demangle::Node*&, llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)
Line
Count
Source
2823
23
                                                          NameState *State) {
2824
23
  if (SoFar->getKind() == Node::KSpecialSubstitution) {
2825
1
    auto SSK = static_cast<SpecialSubstitution *>(SoFar)->SSK;
2826
1
    switch (SSK) {
2827
1
    case SpecialSubKind::string:
2828
1
    case SpecialSubKind::istream:
2829
1
    case SpecialSubKind::ostream:
2830
1
    case SpecialSubKind::iostream:
2831
1
      SoFar = make<ExpandedSpecialSubstitution>(SSK);
2832
1
      if (!SoFar)
2833
0
        return nullptr;
2834
1
      break;
2835
1
    default:
2836
0
      break;
2837
23
    }
2838
23
  }
2839
23
2840
23
  if (consumeIf('C')) {
2841
19
    bool IsInherited = consumeIf('I');
2842
19
    if (look() != '1' && 
look() != '2'9
&&
look() != '3'0
&&
look() != '4'0
&&
2843
19
        
look() != '5'0
)
2844
0
      return nullptr;
2845
19
    int Variant = look() - '0';
2846
19
    ++First;
2847
19
    if (State) State->CtorDtorConversion = true;
2848
19
    if (IsInherited) {
2849
1
      if (getDerived().parseName(State) == nullptr)
2850
0
        return nullptr;
2851
19
    }
2852
19
    return make<CtorDtorName>(SoFar, /*IsDtor=*/false, Variant);
2853
19
  }
2854
4
2855
4
  if (look() == 'D' && (look(1) == '0' || look(1) == '1' || 
look(1) == '2'3
||
2856
4
                        
look(1) == '4'0
||
look(1) == '5'0
)) {
2857
4
    int Variant = look(1) - '0';
2858
4
    First += 2;
2859
4
    if (State) State->CtorDtorConversion = true;
2860
4
    return make<CtorDtorName>(SoFar, /*IsDtor=*/true, Variant);
2861
4
  }
2862
0
2863
0
  return nullptr;
2864
0
}
2865
2866
// <nested-name> ::= N [<CV-Qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
2867
//               ::= N [<CV-Qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
2868
//
2869
// <prefix> ::= <prefix> <unqualified-name>
2870
//          ::= <template-prefix> <template-args>
2871
//          ::= <template-param>
2872
//          ::= <decltype>
2873
//          ::= # empty
2874
//          ::= <substitution>
2875
//          ::= <prefix> <data-member-prefix>
2876
//  extension ::= L
2877
//
2878
// <data-member-prefix> := <member source-name> [<template-args>] M
2879
//
2880
// <template-prefix> ::= <prefix> <template unqualified-name>
2881
//                   ::= <template-param>
2882
//                   ::= <substitution>
2883
template <typename Derived, typename Alloc>
2884
Node *
2885
281
AbstractManglingParser<Derived, Alloc>::parseNestedName(NameState *State) {
2886
281
  if (!consumeIf('N'))
2887
0
    return nullptr;
2888
281
2889
281
  Qualifiers CVTmp = parseCVQualifiers();
2890
281
  if (State) 
State->CVQualifiers = CVTmp102
;
2891
281
2892
281
  if (consumeIf('O')) {
2893
0
    if (State) State->ReferenceQualifier = FrefQualRValue;
2894
281
  } else if (consumeIf('R')) {
2895
1
    if (State) State->ReferenceQualifier = FrefQualLValue;
2896
1
  } else
2897
280
    if (State) 
State->ReferenceQualifier = FrefQualNone101
;
2898
281
2899
281
  Node *SoFar = nullptr;
2900
590
  auto PushComponent = [&](Node *Comp) {
2901
590
    if (!Comp) 
return false3
;
2902
587
    if (SoFar) 
SoFar = make<NestedName>(SoFar, Comp)382
;
2903
205
    else       SoFar = Comp;
2904
587
    if (State) 
State->EndsWithTemplateArgs = false221
;
2905
587
    return SoFar != nullptr;
2906
587
  };
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseNestedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)::'lambda'(llvm::itanium_demangle::Node*)::operator()(llvm::itanium_demangle::Node*) const
Line
Count
Source
2900
482
  auto PushComponent = [&](Node *Comp) {
2901
482
    if (!Comp) 
return false2
;
2902
480
    if (SoFar) 
SoFar = make<NestedName>(SoFar, Comp)325
;
2903
155
    else       SoFar = Comp;
2904
480
    if (State) 
State->EndsWithTemplateArgs = false120
;
2905
480
    return SoFar != nullptr;
2906
480
  };
ItaniumDemangle.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseNestedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::NameState*)::'lambda'(llvm::itanium_demangle::Node*)::operator()(llvm::itanium_demangle::Node*) const
Line
Count
Source
2900
108
  auto PushComponent = [&](Node *Comp) {
2901
108
    if (!Comp) 
return false1
;
2902
107
    if (SoFar) 
SoFar = make<NestedName>(SoFar, Comp)57
;
2903
50
    else       SoFar = Comp;
2904
107
    if (State) 
State->EndsWithTemplateArgs = false101
;
2905
107
    return SoFar != nullptr;
2906
107
  };
2907
281
2908
281
  if (consumeIf("St")) {
2909
74
    SoFar = make<NameType>("std");
2910
74
    if (!SoFar)
2911
0
      return nullptr;
2912
281
  }
2913
281
2914
993
  
while (281
!consumeIf('E')) {
2915
717
    consumeIf('L'); // extension
2916
717
2917
717
    // <data-member-prefix> := <member source-name> [<template-args>] M
2918
717
    if (consumeIf('M')) {
2919
0
      if (SoFar == nullptr)
2920
0
        return nullptr;
2921
0
      continue;
2922
0
    }
2923
717
2924
717
    //          ::= <template-param>
2925
717
    if (look() == 'T') {
2926
0
      if (!PushComponent(getDerived().parseTemplateParam()))
2927
0
        return nullptr;
2928
0
      Subs.push_back(SoFar);
2929
0
      continue;
2930
0
    }
2931
717
2932
717
    //          ::= <template-prefix> <template-args>
2933
717
    if (look() == 'I') {
2934
127
      Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2935
127
      if (TA == nullptr || SoFar == nullptr)
2936
0
        return nullptr;
2937
127
      SoFar = make<NameWithTemplateArgs>(SoFar, TA);
2938
127
      if (!SoFar)
2939
0
        return nullptr;
2940
127
      if (State) 
State->EndsWithTemplateArgs = true39
;
2941
127
      Subs.push_back(SoFar);
2942
127
      continue;
2943
127
    }
2944
590
2945
590
    //          ::= <decltype>
2946
590
    if (look() == 'D' && 
(11
look(1) == 't'11
||
look(1) == 'T'11
)) {
2947
0
      if (!PushComponent(getDerived().parseDecltype()))
2948
0
        return nullptr;
2949
0
      Subs.push_back(SoFar);
2950
0
      continue;
2951
0
    }
2952
590
2953
590
    //          ::= <substitution>
2954
590
    if (look() == 'S' && 
look(1) != 't'66
) {
2955
66
      Node *S = getDerived().parseSubstitution();
2956
66
      if (!PushComponent(S))
2957
0
        return nullptr;
2958
66
      if (SoFar != S)
2959
0
        Subs.push_back(S);
2960
66
      continue;
2961
66
    }
2962
524
2963
524
    // Parse an <unqualified-name> thats actually a <ctor-dtor-name>.
2964
524
    if (look() == 'C' || 
(499
look() == 'D'499
&&
look(1) != 'C'11
)) {
2965
35
      if (SoFar == nullptr)
2966
0
        return nullptr;
2967
35
      if (!PushComponent(getDerived().parseCtorDtorName(SoFar, State)))
2968
0
        return nullptr;
2969
35
      SoFar = getDerived().parseAbiTags(SoFar);
2970
35
      if (SoFar == nullptr)
2971
0
        return nullptr;
2972
35
      Subs.push_back(SoFar);
2973
35
      continue;
2974
35
    }
2975
489
2976
489
    //          ::= <prefix> <unqualified-name>
2977
489
    if (!PushComponent(getDerived().parseUnqualifiedName(State)))
2978
5
      return nullptr;
2979
484
    Subs.push_back(SoFar);
2980
484
  }
2981
281
2982
281
  
if (276
SoFar == nullptr276
||
Subs.empty()276
)
2983
0
    return nullptr;
2984
276
2985
276
  Subs.pop_back();
2986
276
  return SoFar;
2987
276
}
ItaniumManglingCanonicalizer.cpp:llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::parseNestedName(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::CanonicalizerAllocator>, (anonymous namespace)::CanonicalizerAllocator>::NameState*)
Line
Count
Source
2885
228
AbstractManglingParser<Derived, Alloc>::parseNestedName(NameState *State) {
2886
228
  if (!consumeIf('N'))
2887
0
    return nullptr;
2888
228
2889
228
  Qualifiers CVTmp = parseCVQualifiers();
2890
228
  if (State) 
State->CVQualifiers = CVTmp53
;
2891
228
2892
228
  if (consumeIf('O')) {
2893
0
    if (State) State->ReferenceQualifier = FrefQualRValue;
2894
228
  } else if (consumeIf('R')) {
2895
0
    if (State) State->ReferenceQualifier = FrefQualLValue;
2896
0
  } else
2897
228
    if (State) 
State->ReferenceQualifier = FrefQualNone53
;
2898
228
2899
228
  Node *SoFar = nullptr;
2900
228
  auto PushComponent = [&](Node *Comp) {
2901
228
    if (!Comp) return false;
2902
228
    if (SoFar) SoFar = make<NestedName>(SoFar, Comp);
2903
228
    else       SoFar = Comp;
2904
228
    if (State) State->EndsWithTemplateArgs = false;
2905
228
    return SoFar != nullptr;
2906
228
  };
2907
228
2908
228
  if (consumeIf("St")) {
2909
72
    SoFar = make<NameType>("std");
2910
72
    if (!SoFar)
2911
0
      return nullptr;
2912
228
  }
2913
228
2914
805
  
while (228
!consumeIf('E')) {
2915
581
    consumeIf('L'); // extension
2916
581
2917
581
    // <data-member-prefix> := <member source-name> [<template-args>] M
2918
581
    if (consumeIf('M')) {
2919
0
      if (SoFar == nullptr)
2920
0
        return nullptr;
2921
0
      continue;
2922
0
    }
2923
581
2924
581
    //          ::= <template-param>
2925
581
    if (look() == 'T') {
2926
0
      if (!PushComponent(getDerived().parseTemplateParam()))
2927
0
        return nullptr;
2928
0
      Subs.push_back(SoFar);
2929
0
      continue;
2930
0
    }
2931
581
2932
581
    //          ::= <template-prefix> <template-args>
2933
581
    if (look() == 'I') {
2934
99
      Node *TA = getDerived().parseTemplateArgs(State != nullptr);
2935
99
      if (TA == nullptr || SoFar == nullptr)
2936
0
        return nullptr;
2937
99
      SoFar = make<NameWithTemplateArgs>(SoFar, TA);
2938
99
      if (!SoFar)
2939
0
        return nullptr;
2940
99
      if (State) 
State->EndsWithTemplateArgs = true13
;
2941
99
      Subs.push_back(SoFar);
2942
99
      continue;
2943
99
    }
2944
482
2945
482
    //          ::= <decltype>
2946
482
    if (look() == 'D' && 
(6
look(1) == 't'6
||
look(1) == 'T'6
)) {
2947
0
      if (!PushComponent(getDerived().parseDecltype()))
2948
0
        return nullptr;
2949
0
      Subs.push_back(SoFar);
2950
0
      continue;
2951
0
    }
2952
482
2953
482
    //          ::= <substitution>
2954
482
    if (look() == 'S' && 
look(1) != 't'53
) {
2955
53
      Node *S = getDerived().parseSubstitution();
2956
53
      if (!PushComponent(S))
2957
0
        return nullptr;
2958
53
      if (SoFar != S)
2959
0
        Subs.push_back(S);
2960
53
      continue;
2961
53
    }
2962
429
2963
429
    // Parse an <unqualified-name> thats actually a <ctor-dtor-name>.
2964
429
    if (look() == 'C' || 
(423
look() == 'D'423
&&
look(1) != 'C'6
)) {
2965
12
      if (SoFar == nullptr)
2966