Add profiling and canonicalization support to demangler nodes. No functionality change intended.

[rsmith]

Summary

Adds the ability to deduplicate demangler nodes as they're being created. I've
kept the new functionality behind #ifdefs to make it easier to keep this in
sync with the libc++abi version of this code. This is a prerequisite for
profile data remapping functionality; you can see the big picture here:
https://reviews.llvm.org/differential/diff/160950/

[erik.pilkington]

Thanks for fixing up some of the const inconsistencies! I agree with you that it'd be nice to move all the profiling stuff to a separate file once the AST moves to a header, but I'm fine with doing that in a follow up.

How are you handling the circular dependency problem? Support depends on Demangle, and with this patch Demangle would now depend on Support, right?

lib/Demangle/ItaniumDemangle.cpp

36

nit: this shouldn't be indented.

747

#ifndef STANDALONE_DEMANGLER

[rsmith]

In D50828#1203056, @erik.pilkington wrote:

How are you handling the circular dependency problem? Support depends on Demangle, and with this patch Demangle would now depend on Support, right?

Good question. So far I've not handled that problem :(

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

[erik.pilkington]

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

[zturner]

In D50828#1203354, @erik.pilkington wrote:

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

My understanding is that Demangle is used by other projects like compiler-rt which can't depend on Support. If I'm wrong, it would be great. For some reason I can't find it when I search the archive, but if you search your inbox for "llvm r328123" you'll find a long discussion thread with various people who were dealing with this and/or may know something about it. Anyway, I'm CC'ing them all here.

Personally if we can get Demangle into support I would be very happy.

[chandlerc]

In D50828#1203392, @zturner wrote:

In D50828#1203354, @erik.pilkington wrote:

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

My understanding is that Demangle is used by other projects like compiler-rt which can't depend on Support. If I'm wrong, it would be great. For some reason I can't find it when I search the archive, but if you search your inbox for "llvm r328123" you'll find a long discussion thread with various people who were dealing with this and/or may know something about it. Anyway, I'm CC'ing them all here.

Personally if we can get Demangle into support I would be very happy.

That's why all of this is behind an #ifdef? It seems to be trying to preserve the ability to build a stand-alone demangler that does not in fact pull in Support or anything else.

[zturner]

In D50828#1203398, @chandlerc wrote:

In D50828#1203392, @zturner wrote:

In D50828#1203354, @erik.pilkington wrote:

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

My understanding is that Demangle is used by other projects like compiler-rt which can't depend on Support. If I'm wrong, it would be great. For some reason I can't find it when I search the archive, but if you search your inbox for "llvm r328123" you'll find a long discussion thread with various people who were dealing with this and/or may know something about it. Anyway, I'm CC'ing them all here.

Personally if we can get Demangle into support I would be very happy.

That's why all of this is behind an #ifdef? It seems to be trying to preserve the ability to build a stand-alone demangler that does not in fact pull in Support or anything else.

The question is, who needs that? Can we just put it *into* Support?

[chandlerc]

In D50828#1203399, @zturner wrote:

In D50828#1203398, @chandlerc wrote:

In D50828#1203392, @zturner wrote:

In D50828#1203354, @erik.pilkington wrote:

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

My understanding is that Demangle is used by other projects like compiler-rt which can't depend on Support. If I'm wrong, it would be great. For some reason I can't find it when I search the archive, but if you search your inbox for "llvm r328123" you'll find a long discussion thread with various people who were dealing with this and/or may know something about it. Anyway, I'm CC'ing them all here.

Personally if we can get Demangle into support I would be very happy.

That's why all of this is behind an #ifdef? It seems to be trying to preserve the ability to build a stand-alone demangler that does not in fact pull in Support or anything else.

The question is, who needs that? Can we just put it *into* Support?

libc++abi is under a different license than support.

We can't fix this until at a minimum the relicensing is "done".

[zturner]

In D50828#1203407, @chandlerc wrote:

In D50828#1203399, @zturner wrote:

In D50828#1203398, @chandlerc wrote:

In D50828#1203392, @zturner wrote:

In D50828#1203354, @erik.pilkington wrote:

In D50828#1203312, @rsmith wrote:

I think the only reasonable way to handle this is for Demangle to move into Support. We could keep the headers separate but move the implementation into lib/Support/Demangle, similar to what we do for AST. Or we could also move the headers to include/llvm/Support/Demangle. My preference is the latter; it seems reasonable to me for Demangle to generally live inside Support.

Sure, I really don't know why we didn't just do that to start with. The original RFC[1] talked about putting the demangler into Support, but the commit that materialized it (r280732) put Demangle into it's own library. Would be nice to get @zturner's sign-off for a move too, since he owns the microsoft demangler.

[1]: https://groups.google.com/forum/#!topic/llvm-dev/v_7OuWx8n1A

My understanding is that Demangle is used by other projects like compiler-rt which can't depend on Support. If I'm wrong, it would be great. For some reason I can't find it when I search the archive, but if you search your inbox for "llvm r328123" you'll find a long discussion thread with various people who were dealing with this and/or may know something about it. Anyway, I'm CC'ing them all here.

Personally if we can get Demangle into support I would be very happy.

That's why all of this is behind an #ifdef? It seems to be trying to preserve the ability to build a stand-alone demangler that does not in fact pull in Support or anything else.

The question is, who needs that? Can we just put it *into* Support?

libc++abi is under a different license than support.

We can't fix this until at a minimum the relicensing is "done".

But libc++abi doesn't include these headers. It makes a copy of them and checks them in. Does this solve that problem?

[erik.pilkington]

In D50828#1203407, @chandlerc wrote:

libc++abi is under a different license than support.

We can't fix this until at a minimum the relicensing is "done".

Wait why? Do lawyers really care if we put this stuff in LLVMDemangle instead of LLVMSupport??

[chandlerc]

In D50828#1203412, @zturner wrote:

But libc++abi doesn't include these headers. It makes a copy of them and checks them in. Does this solve that problem?

My understanding was that this macro would *allow* them to make that copy. They would copy the code, set the define, and not need a copy of Support.

We could of course insist that they do some kind of preprocessing of the source code as part of the copy, but not sure what that gains?

In D50828#1203413, @erik.pilkington wrote:

In D50828#1203407, @chandlerc wrote:

libc++abi is under a different license than support.

We can't fix this until at a minimum the relicensing is "done".

Wait why? Do lawyers really care if we put this stuff in LLVMDemangle instead of LLVMSupport??

No, they care that libc++abi doesn't include code from Support which is under a different license.

If you want to move the file from one directory to another (without changing the code), maybe we can do that. But I don't think that discussion really needs to happen befor ethis change can be reviewed?

[rsmith]

Changes to move Demangle library under Support are here: https://reviews.llvm.org/D50875

I don't believe there is any compiler-rt / libc++abi impact: libc++abi has its own copy of the demangler that is notionally separately maintained but actually is kept in sync with the one in LLVM.

[zturner]

If we're not going to allow code from Support to be used in the demangler, then I don't think we should move it to support, because it will be too easy for people to mess up and use code they shouldn't.

Perhaps what we need are some hooks into the demangler (e.g. an interface defined in LLVMDemangle that exposes some virtual methods with default implementations), and then LLVM / Clang could override them to inject custom functionality.

[chandlerc]

In D50828#1203431, @zturner wrote:

If we're not going to allow code from Support to be used in the demangler, then I don't think we should move it to support, because it will be too easy for people to mess up and use code they shouldn't.

We could easily add a unittest (or something similar) that builds and uses the file in the standalone mode without the Support library to ensure that when it gets copied into libc++abi it still works. This should be possible to implement both with a single file in the Support library and for a separate library. And regardless of which design, seem like a more reliable way of preserving the invariant that we want here?

Perhaps what we need are some hooks into the demangler (e.g. an interface defined in LLVMDemangle that exposes some virtual methods with default implementations), and then LLVM / Clang could override them to inject custom functionality.

No strong feelings here, happy to let you and Richard discuss this aspect of the design.

[zturner]

Another option is to simply move it into support and say that going forward
merges to libcxxabi might get more difficult. Perhaps this isn’t so bad
though. Isn’t the itanium demangler mostly complete? If the potential for
future changes to it is low, maybe this is an acceptable tradeoff. Then we
could just move it to support, use it and evolve it any way we want with no
restrictions, and when new functionality gets added to the itanium mangler
that needs to be port to libcxxabi, it’s a little more effort than a simple
copy paste because you have to think about it some.

Thoughts?

[chandlerc]

In D50828#1203493, @zturner wrote:

Another option is to simply move it into support and say that going forward
merges to libcxxabi might get more difficult. Perhaps this isn’t so bad
though. Isn’t the itanium demangler mostly complete?

I think the primary changes we want to share will be bugfixes. There have been a lot of those over the past few years. Not sure how many are left?

If the potential for
future changes to it is low, maybe this is an acceptable tradeoff. Then we
could just move it to support, use it and evolve it any way we want with no
restrictions, and when new functionality gets added to the itanium mangler
that needs to be port to libcxxabi, it’s a little more effort than a simple
copy paste because you have to think about it some.

Thoughts?

FWIW, I think this is mostly a question for the maintainers. I'm happy for them to somewhat dictate what works w.r.t. sharing the logic between the two domains given the (perhaps frustrating) constraints here.

[llvm-commits]

Yea, I agree it’s mostly bugfixes. My hypothesis is that bugfixes are, on
average, pretty small and isolated, so it shouldn’t be too hard to port one
between the two even if they evolve separately. I’m curious what Erik
thinks though.

• msg-4823-24.txt162 BDownload

[erik.pilkington]

In D50828#1203493, @zturner wrote:

Another option is to simply move it into support and say that going forward
merges to libcxxabi might get more difficult. Perhaps this isn’t so bad
though. Isn’t the itanium demangler mostly complete? If the potential for
future changes to it is low, maybe this is an acceptable tradeoff.

It's pretty much complete, but there is still going to be a steady stream of updates. Each release of C++ is likely to add a handful more constructs that need manglings, and often new attributes/extensions get custom manglings that need to be handled as well.

Then we
could just move it to support, use it and evolve it any way we want with no
restrictions, and when new functionality gets added to the itanium mangler
that needs to be port to libcxxabi, it’s a little more effort than a simple
copy paste because you have to think about it some.

Thoughts?

-1 from me, large-scale refactorings such as this, or Pavel's plans here: https://reviews.llvm.org/D50599 would make updating/fixing bugs in the demangler a nightmare. I really don't want to have to implement every feature twice. Not to mention its just plain ugly to have two vaguely similar demanglers in the source tree.

[zturner]

But do you actually need those changes that pavel is working on? That looks
like a whole bunch of code that someone who just wants to print a demangled
name won’t care about. How involved are bugs usually, because I’m imagining
they’re a) usually just a couple lines change and b) pretty infrequent.
Once the relicense happens, you just change the include path and include
the real one.

I mean I agree it’s a bit ugly, but I don’t think it’s any more ugly than
moving it to support and hacking up the file with ifdefs so that it both is
and isn’t part of support at the same time. After all, we already have two
vaguely similar demanglers in the tree. One in llvm and one in libcxxabi.
So that doesn’t actually get any worse.

I pretty strongly dislike the alternative of moving demangler to support
and “lying” about it being part of support :-:

[chandlerc]

In D50828#1203532, @erik.pilkington wrote:

In D50828#1203493, @zturner wrote:

Another option is to simply move it into support and say that going forward
merges to libcxxabi might get more difficult. Perhaps this isn’t so bad
though. Isn’t the itanium demangler mostly complete? If the potential for
future changes to it is low, maybe this is an acceptable tradeoff.

It's pretty much complete, but there is still going to be a steady stream of updates. Each release of C++ is likely to add a handful more constructs that need manglings, and often new attributes/extensions get custom manglings that need to be handled as well.

Then we
could just move it to support, use it and evolve it any way we want with no
restrictions, and when new functionality gets added to the itanium mangler
that needs to be port to libcxxabi, it’s a little more effort than a simple
copy paste because you have to think about it some.

Thoughts?

-1 from me, large-scale refactorings such as this, or Pavel's plans here: https://reviews.llvm.org/D50599 would make updating/fixing bugs in the demangler a nightmare. I really don't want to have to implement every feature twice. Not to mention its just plain ugly to have two vaguely similar demanglers in the source tree.

This, combined with the comments on the move of the library IMO make it very clear what our two realistic choices are.

We can either make Demangle part of Support, and if we do so I think Zach is essentially right about how we do this (it'll move, the directory structure and other things will change), or we don't.

If we don't, we can't (even conditionally) use Support.

So the choices become:
a) We truly merge this into Support (and force manual porting of bugfixes between the two versions) and get all of the interesting enhancements we're talking about here such as what Richard is working on.
b) We don't merge this into Support, we keep it truly separate as it is today, and we do the very significant refactorings necessary to support these kinds of facilities with the layering as it is.

I'm worried that (b) will turn into "we don't get the fancy features at all" which worries me. But I'm seeing very little good compromise between (a) and (b). =/

[rsmith]

I'm going to try to split this patch so it adds a generic visitation mechanism to the demangler AST, and introduce a separate layer that includes Support and builds profiling off the visitation mechanism. That seems like the only way out that meets everyone's acceptance criteria. However, I don't see any way to do that without moving all of the demangler to a public header in include/llvm (since the whole thing will need to be included from both the Demangle/ demangler and the profiling demangler). That header would only be included (and the templates in it instantiated) in two places in LLVM, but still, it'd be a 5000-line header file. If people are strongly opposed to that approach, please shout now!

[zturner]

Can’t we just use a base class with pure virtual methods, pass it to the
demangle function, implement this in clang, and pass null from libcxxabi?
Moving the whole thing to a header file seems kinda unfortunate.

[erik.pilkington]

In D50828#1203539, @rsmith wrote:

I'm going to try to split this patch so it adds a generic visitation mechanism to the demangler AST, and introduce a separate layer that includes Support and builds profiling off the visitation mechanism. That seems like the only way out that meets everyone's acceptance criteria. However, I don't see any way to do that without moving all of the demangler to a public header in include/llvm (since the whole thing will need to be included from both the Demangle/ demangler and the profiling demangler). That header would only be included (and the templates in it instantiated) in two places in LLVM, but still, it'd be a 5000-line header file. If people are strongly opposed to that approach, please shout now!

+1 from me! I was just writing an argument to do something like this.

One more thing that I want to mention: If/when we go monorepo, then we can share code between libcxxabi and llvm the old-fashioned way. Tangling in support would just make it impossible to ever de-duplicate the demanglers.

[llvm-commits]

Yea this approach is fine I guess, but I’m not really a fan of gigantic
headers, so if it’s possible to use runtime polymorphism that seems better
to me. Otoh, I’m not the maintainer of the itanium demangler, so feel free
to ignore :)

• msg-18523-120.txt162 BDownload

[rsmith]

Abandoned in favor of https://reviews.llvm.org/D50930 and https://reviews.llvm.org/D50935

lib/Demangle/ItaniumDemangle.cpp

 //===------------------------- ItaniumDemangle.cpp ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // FIXME: (possibly) incomplete list of features that clang mangles that this
 // file does not yet support:
 //   - C++ modules TS
 
+#include "llvm/Demangle/Demangle.h"
+
 #include "Compiler.h"
 #include "StringView.h"
 #include "Utility.h"
-#include "llvm/Demangle/Demangle.h"
+
+#ifndef STANDALONE_DEMANGLER
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/StringRef.h"
+#endif
 
 #include <cassert>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <numeric>
 #include <utility>
 #include <vector>
 
 namespace {
+#ifndef STANDALONE_DEMANGLER
+  void addString(llvm::FoldingSetNodeID &ID, StringView Str) {
+    ID.AddString(llvm::StringRef(Str.begin(), Str.size()));
+  }
+#endif
+
 // Base class of all AST nodes. The AST is built by the parser, then is
 // traversed by the printLeft/Right functions to produce a demangled string.
 class Node {
 public:
   enum Kind : unsigned char {
     KNodeArrayNode,
     KDotSuffix,
     KVendorExtQualType,
public:
   /// affect how we format the output string.
   Cache FunctionCache;
 
   Node(Kind K_, Cache RHSComponentCache_ = Cache::No,
        Cache ArrayCache_ = Cache::No, Cache FunctionCache_ = Cache::No)
       : K(K_), RHSComponentCache(RHSComponentCache_), ArrayCache(ArrayCache_),
         FunctionCache(FunctionCache_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  /// Compute a FoldingSetNodeID for the node created by invoking the
+  /// constructor with the given arguments.
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Kind K, Cache = Cache::No,
+                          Cache = Cache::No, Cache = Cache::No) {
+    ID.AddInteger(K);
+    // Don't profile the cached values. They're not part of the value of the
+    // node for profiling purposes.
+  }
+
+  /// Compute a FoldingSetNodeID for this node.
+  virtual void profile(llvm::FoldingSetNodeID &ID) const { profileCtor(ID, K); }
+#endif
+
   bool hasRHSComponent(OutputStream &S) const {
     if (RHSComponentCache != Cache::Unknown)
       return RHSComponentCache == Cache::Yes;
     return hasRHSComponentSlow(S);
   }
 
   bool hasArray(OutputStream &S) const {
     if (ArrayCache != Cache::Unknown)
class NodeArray {
   Node **Elements;
   size_t NumElements;
 
 public:
   NodeArray() : Elements(nullptr), NumElements(0) {}
   NodeArray(Node **Elements_, size_t NumElements_)
       : Elements(Elements_), NumElements(NumElements_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  void profile(llvm::FoldingSetNodeID &ID) {
+    ID.AddInteger(size());
+    for (Node *N : *this)
+      ID.AddPointer(N);
+  }
+#endif
+
   bool empty() const { return NumElements == 0; }
   size_t size() const { return NumElements; }
 
   Node **begin() const { return Elements; }
   Node **end() const { return Elements + NumElements; }
 
   Node *operator[](size_t Idx) const { return Elements[Idx]; }
 
for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       FirstElement = false;
     }
   }
 };
 
 struct NodeArrayNode : Node {
   NodeArray Array;
   NodeArrayNode(NodeArray Array_) : Node(KNodeArrayNode), Array(Array_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray A) {
+    Node::profileCtor(ID, KNodeArrayNode);
+    A.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Array);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     Array.printWithComma(S);
   }
 };
 
 class DotSuffix final : public Node {
   const Node *Prefix;
   const StringView Suffix;
 
 public:
-  DotSuffix(Node *Prefix_, StringView Suffix_)
+  DotSuffix(const Node *Prefix_, StringView Suffix_)
       : Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Prefix,
+                          StringView Suffix) {
+    Node::profileCtor(ID, KDotSuffix);
+    ID.AddPointer(Prefix);
+    addString(ID, Suffix);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Prefix, Suffix);
+  }
+#endif
+
   void printLeft(OutputStream &s) const override {
     Prefix->print(s);
     s += " (";
     s += Suffix;
     s += ")";
   }
 };
 
 class VendorExtQualType final : public Node {
   const Node *Ty;
   StringView Ext;
 
 public:
-  VendorExtQualType(Node *Ty_, StringView Ext_)
+  VendorExtQualType(const Node *Ty_, StringView Ext_)
       : Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ty,
+                          StringView Ext) {
+    Node::profileCtor(ID, KVendorExtQualType);
+    ID.AddPointer(Ty);
+    addString(ID, Ext);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty, Ext);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     Ty->print(S);
     S += " ";
     S += Ext;
   }
 };
 
 enum FunctionRefQual : unsigned char {
if (Quals & QualConst)
       S += " const";
     if (Quals & QualVolatile)
       S += " volatile";
     if (Quals & QualRestrict)
       S += " restrict";
   }
 
 public:
-  QualType(Node *Child_, Qualifiers Quals_)
+  QualType(const Node *Child_, Qualifiers Quals_)
       : Node(KQualType, Child_->RHSComponentCache,
              Child_->ArrayCache, Child_->FunctionCache),
         Quals(Quals_), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Child,
+                          Qualifiers Quals) {
+    Node::profileCtor(ID, KQualType);
+    ID.AddPointer(Child);
+    ID.AddInteger(Quals);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Child, Quals);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Child->hasRHSComponent(S);
   }
   bool hasArraySlow(OutputStream &S) const override {
     return Child->hasArray(S);
   }
   bool hasFunctionSlow(OutputStream &S) const override {
     return Child->hasFunction(S);
   }
 
   void printLeft(OutputStream &S) const override {
     Child->printLeft(S);
     printQuals(S);
   }
 
   void printRight(OutputStream &S) const override { Child->printRight(S); }
 };
 
 class ConversionOperatorType final : public Node {
   const Node *Ty;
 
 public:
-  ConversionOperatorType(Node *Ty_)
+  ConversionOperatorType(const Node *Ty_)
       : Node(KConversionOperatorType), Ty(Ty_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ty) {
+    Node::profileCtor(ID, KConversionOperatorType);
+    ID.AddPointer(Ty);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "operator ";
     Ty->print(S);
   }
 };
 
 class PostfixQualifiedType final : public Node {
   const Node *Ty;
   const StringView Postfix;
 
 public:
   PostfixQualifiedType(Node *Ty_, StringView Postfix_)
       : Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ty,
+                          StringView Postfix) {
+    Node::profileCtor(ID, KPostfixQualifiedType);
+    ID.AddPointer(Ty);
+    addString(ID, Postfix);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty, Postfix);
+  }
+#endif
+
   void printLeft(OutputStream &s) const override {
     Ty->printLeft(s);
     s += Postfix;
   }
 };
 
 class NameType final : public Node {
   const StringView Name;
 
 public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Name) {
+    Node::profileCtor(ID, KNameType);
+    addString(ID, Name);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Name);
+  }
+#endif
+
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
   void printLeft(OutputStream &s) const override { s += Name; }
 };
 
 class ElaboratedTypeSpefType : public Node {
   StringView Kind;
   Node *Child;
 public:
   ElaboratedTypeSpefType(StringView Kind_, Node *Child_)
       : Node(KElaboratedTypeSpefType), Kind(Kind_), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Kind,
+                          Node *Child) {
+    Node::profileCtor(ID, KElaboratedTypeSpefType);
+    addString(ID, Kind);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Kind, Child);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += Kind;
     S += ' ';
     Child->print(S);
   }
 };
 
 struct AbiTagAttr : Node {
   Node *Base;
   StringView Tag;
 
   AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Base,
+                          StringView Tag) {
+    Node::profileCtor(ID, KAbiTagAttr);
+    ID.AddPointer(Base);
+    addString(ID, Tag);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Base, Tag);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     Base->printLeft(S);
     S += "[abi:";
     S += Tag;
     S += "]";
   }
 };
 
 class EnableIfAttr : public Node {
   NodeArray Conditions;
 public:
   EnableIfAttr(NodeArray Conditions_)
       : Node(KEnableIfAttr), Conditions(Conditions_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Conditions) {
+    Node::profileCtor(ID, KEnableIfAttr);
+    Conditions.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Conditions);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += " [enable_if:";
     Conditions.printWithComma(S);
     S += ']';
   }
 };
 
 class ObjCProtoName : public Node {
-  Node *Ty;
+  const Node *Ty;
   StringView Protocol;
 
   friend class PointerType;
 
 public:
-  ObjCProtoName(Node *Ty_, StringView Protocol_)
+  ObjCProtoName(const Node *Ty_, StringView Protocol_)
       : Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ty,
+                          StringView Protocol) {
+    Node::profileCtor(ID, KObjCProtoName);
+    ID.AddPointer(Ty);
+    addString(ID, Protocol);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty, Protocol);
+  }
+#endif
+
   bool isObjCObject() const {
     return Ty->getKind() == KNameType &&
-           static_cast<NameType *>(Ty)->getName() == "objc_object";
+           static_cast<const NameType *>(Ty)->getName() == "objc_object";
   }
 
   void printLeft(OutputStream &S) const override {
     Ty->print(S);
     S += "<";
     S += Protocol;
     S += ">";
   }
 };
 
 class PointerType final : public Node {
   const Node *Pointee;
 
 public:
-  PointerType(Node *Pointee_)
+  PointerType(const Node *Pointee_)
       : Node(KPointerType, Pointee_->RHSComponentCache),
         Pointee(Pointee_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Pointee) {
+    Node::profileCtor(ID, KPointerType);
+    ID.AddPointer(Pointee);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Pointee);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
   void printLeft(OutputStream &s) const override {
     // We rewrite objc_object<SomeProtocol>* into id<SomeProtocol>.
     if (Pointee->getKind() != KObjCProtoName ||
         !static_cast<const ObjCProtoName *>(Pointee)->isObjCObject()) {
for (;;) {
       auto *RT = static_cast<const ReferenceType *>(SN);
       SoFar.second = RT->Pointee;
       SoFar.first = std::min(SoFar.first, RT->RK);
     }
     return SoFar;
   }
 
 public:
-  ReferenceType(Node *Pointee_, ReferenceKind RK_)
+  ReferenceType(const Node *Pointee_, ReferenceKind RK_)
       : Node(KReferenceType, Pointee_->RHSComponentCache),
         Pointee(Pointee_), RK(RK_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Pointee,
+                          ReferenceKind RK) {
+    Node::profileCtor(ID, KReferenceType);
+    ID.AddPointer(Pointee);
+    ID.AddInteger((unsigned)RK);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Pointee, RK);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return Pointee->hasRHSComponent(S);
   }
 
   void printLeft(OutputStream &s) const override {
     if (Printing)
       return;
     SwapAndRestore<bool> SavePrinting(Printing, true);
#endif
   }
 };
 
 class PointerToMemberType final : public Node {
   const Node *ClassType;
   const Node *MemberType;
 
 public:
-  PointerToMemberType(Node *ClassType_, Node *MemberType_)
+  PointerToMemberType(const Node *ClassType_, const Node *MemberType_)
       : Node(KPointerToMemberType, MemberType_->RHSComponentCache),
         ClassType(ClassType_), MemberType(MemberType_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *ClassType,
+                          const Node *MemberType) {
+    Node::profileCtor(ID, KPointerToMemberType);
+    ID.AddPointer(ClassType);
+    ID.AddPointer(MemberType);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, ClassType, MemberType);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     return MemberType->hasRHSComponent(S);
   }
 
   void printLeft(OutputStream &s) const override {
     MemberType->printLeft(s);
     if (MemberType->hasArray(s) || MemberType->hasFunction(s))
       s += "(";
/* implicit */ NodeOrString(StringView Str) {
     First = static_cast<const void *>(FirstChar);
     Second = static_cast<const void *>(SecondChar);
   }
 
   /* implicit */ NodeOrString(Node *N)
       : First(static_cast<const void *>(N)), Second(nullptr) {}
   NodeOrString() : First(nullptr), Second(nullptr) {}
 
+  void profile(llvm::FoldingSetNodeID &ID) {
+    if (isEmpty()) {
+      ID.AddInteger(0);
+    } else if (isNode()) {
+      ID.AddInteger(1);
+      ID.AddPointer(asNode());
+    } else {
+      ID.AddInteger(2);
+      addString(ID, asString());
+    }
+  }
+
   bool isString() const { return Second && First; }
   bool isNode() const { return First && !Second; }
   bool isEmpty() const { return !First && !Second; }
 
   StringView asString() const {
     assert(isString());
     return StringView(static_cast<const char *>(First),
                       static_cast<const char *>(Second));
   }
 
   const Node *asNode() const {
     assert(isNode());
     return static_cast<const Node *>(First);
   }
 };
 
 class ArrayType final : public Node {
-  Node *Base;
+  const Node *Base;
   NodeOrString Dimension;
 
 public:
-  ArrayType(Node *Base_, NodeOrString Dimension_)
+  ArrayType(const Node *Base_, NodeOrString Dimension_ = NodeOrString())
       : Node(KArrayType,
              /*RHSComponentCache=*/Cache::Yes,
              /*ArrayCache=*/Cache::Yes),
         Base(Base_), Dimension(Dimension_) {}
 
-  // Incomplete array type.
-  ArrayType(Node *Base_)
-      : Node(KArrayType,
-             /*RHSComponentCache=*/Cache::Yes,
-             /*ArrayCache=*/Cache::Yes),
-        Base(Base_) {}
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Base,
+                          NodeOrString Dimension = NodeOrString()) {
+    Node::profileCtor(ID, KArrayType);
+    ID.AddPointer(Base);
+    Dimension.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Base, Dimension);
+  }
+#endif
 
   bool hasRHSComponentSlow(OutputStream &) const override { return true; }
   bool hasArraySlow(OutputStream &) const override { return true; }
 
   void printLeft(OutputStream &S) const override { Base->printLeft(S); }
 
   void printRight(OutputStream &S) const override {
     if (S.back() != ']')
       S += " ";
     S += "[";
     if (Dimension.isString())
       S += Dimension.asString();
     else if (Dimension.isNode())
       Dimension.asNode()->print(S);
     S += "]";
     Base->printRight(S);
   }
 };
 
 class FunctionType final : public Node {
-  Node *Ret;
+  const Node *Ret;
   NodeArray Params;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
-  Node *ExceptionSpec;
+  const Node *ExceptionSpec;
 
 public:
-  FunctionType(Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
-               FunctionRefQual RefQual_, Node *ExceptionSpec_)
+  FunctionType(const Node *Ret_, NodeArray Params_, Qualifiers CVQuals_,
+               FunctionRefQual RefQual_, const Node *ExceptionSpec_)
       : Node(KFunctionType,
              /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
         ExceptionSpec(ExceptionSpec_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ret,
+                          NodeArray Params, Qualifiers CVQuals,
+                          FunctionRefQual RefQual, const Node *ExceptionSpec) {
+    Node::profileCtor(ID, KFunctionType);
+    ID.AddPointer(Ret);
+    Params.profile(ID);
+    ID.AddInteger((unsigned)CVQuals);
+    ID.AddInteger((unsigned)RefQual);
+    ID.AddPointer(ExceptionSpec);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ret, Params, CVQuals, RefQual, ExceptionSpec);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &) const override { return true; }
   bool hasFunctionSlow(OutputStream &) const override { return true; }
 
   // Handle C++'s ... quirky decl grammar by using the left & right
   // distinction. Consider:
   //   int (*f(float))(char) {}
   // f is a function that takes a float and returns a pointer to a function
   // that takes a char and returns an int. If we're trying to print f, start
void printRight(OutputStream &S) const override {
     if (ExceptionSpec != nullptr) {
       S += ' ';
       ExceptionSpec->print(S);
     }
   }
 };
 
 class NoexceptSpec : public Node {
-  Node *E;
+  const Node *E;
 public:
-  NoexceptSpec(Node *E_) : Node(KNoexceptSpec), E(E_) {}
+  NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *E) {
+    Node::profileCtor(ID, KNoexceptSpec);
+    ID.AddPointer(E);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, E);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "noexcept(";
     E->print(S);
     S += ")";
   }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Types) {
+    Node::profileCtor(ID, KDynamicExceptionSpec);
+    Types.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Types);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "throw(";
     Types.printWithComma(S);
     S += ')';
   }
 };
 
 class FunctionEncoding final : public Node {
-  Node *Ret;
-  Node *Name;
+  const Node *Ret;
+  const Node *Name;
   NodeArray Params;
-  Node *Attrs;
+  const Node *Attrs;
   Qualifiers CVQuals;
   FunctionRefQual RefQual;
 
 public:
-  FunctionEncoding(Node *Ret_, Node *Name_, NodeArray Params_,
-                   Node *Attrs_, Qualifiers CVQuals_, FunctionRefQual RefQual_)
+  FunctionEncoding(const Node *Ret_, const Node *Name_, NodeArray Params_,
+                   const Node *Attrs_, Qualifiers CVQuals_,
+                   FunctionRefQual RefQual_)
       : Node(KFunctionEncoding,
              /*RHSComponentCache=*/Cache::Yes, /*ArrayCache=*/Cache::No,
              /*FunctionCache=*/Cache::Yes),
         Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
         CVQuals(CVQuals_), RefQual(RefQual_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ret,
+                          const Node *Name, NodeArray Params, const Node *Attrs,
+                          Qualifiers CVQuals, FunctionRefQual RefQual) {
+    Node::profileCtor(ID, KFunctionEncoding);
+    ID.AddPointer(Ret);
+    ID.AddPointer(Name);
+    Params.profile(ID);
+    ID.AddPointer(Attrs);
+    ID.AddInteger((unsigned)CVQuals);
+    ID.AddInteger((unsigned)RefQual);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ret, Name, Params, Attrs, CVQuals, RefQual);
+  }
+#endif
+
   Qualifiers getCVQuals() const { return CVQuals; }
   FunctionRefQual getRefQual() const { return RefQual; }
   NodeArray getParams() const { return Params; }
-  Node *getReturnType() const { return Ret; }
+  const Node *getReturnType() const { return Ret; }
 
   bool hasRHSComponentSlow(OutputStream &) const override { return true; }
   bool hasFunctionSlow(OutputStream &) const override { return true; }
 
-  Node *getName() { return const_cast<Node *>(Name); }
+  const Node *getName() const { return Name; }
 
   void printLeft(OutputStream &S) const override {
     if (Ret) {
       Ret->printLeft(S);
       if (!Ret->hasRHSComponent(S))
         S += " ";
     }
     Name->print(S);
if (Attrs != nullptr)
       Attrs->print(S);
   }
 };
 
 class LiteralOperator : public Node {
   const Node *OpName;
 
 public:
-  LiteralOperator(Node *OpName_) : Node(KLiteralOperator), OpName(OpName_) {}
+  LiteralOperator(const Node *OpName_)
+      : Node(KLiteralOperator), OpName(OpName_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *OpName) {
+    Node::profileCtor(ID, KLiteralOperator);
+    ID.AddPointer(OpName);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, OpName);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "operator\"\" ";
     OpName->print(S);
   }
 };
 
 class SpecialName final : public Node {
   const StringView Special;
   const Node *Child;
 
 public:
-  SpecialName(StringView Special_, Node* Child_)
+  SpecialName(StringView Special_, const Node *Child_)
       : Node(KSpecialName), Special(Special_), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Special,
+                          const Node *Child) {
+    Node::profileCtor(ID, KSpecialName);
+    addString(ID, Special);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Special, Child);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += Special;
     Child->print(S);
   }
 };
 
 class CtorVtableSpecialName final : public Node {
   const Node *FirstType;
   const Node *SecondType;
 
 public:
-  CtorVtableSpecialName(Node *FirstType_, Node *SecondType_)
+  CtorVtableSpecialName(const Node *FirstType_, const Node *SecondType_)
       : Node(KCtorVtableSpecialName),
         FirstType(FirstType_), SecondType(SecondType_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *FirstType,
+                          const Node *SecondType) {
+    Node::profileCtor(ID, KCtorVtableSpecialName);
+    ID.AddPointer(FirstType);
+    ID.AddPointer(SecondType);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, FirstType, SecondType);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "construction vtable for ";
     FirstType->print(S);
     S += "-in-";
     SecondType->print(S);
   }
 };
 
 struct NestedName : Node {
   Node *Qual;
   Node *Name;
 
   NestedName(Node *Qual_, Node *Name_)
       : Node(KNestedName), Qual(Qual_), Name(Name_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Qual,
+                          Node *Name) {
+    Node::profileCtor(ID, KNestedName);
+    ID.AddPointer(Qual);
+    ID.AddPointer(Name);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Qual, Name);
+  }
+#endif
+
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Qual->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 struct LocalName : Node {
   Node *Encoding;
   Node *Entity;
 
   LocalName(Node *Encoding_, Node *Entity_)
       : Node(KLocalName), Encoding(Encoding_), Entity(Entity_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Encoding,
+                          Node *Entity) {
+    Node::profileCtor(ID, KLocalName);
+    ID.AddPointer(Encoding);
+    ID.AddPointer(Entity);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Encoding, Entity);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     Encoding->print(S);
     S += "::";
     Entity->print(S);
   }
 };
 
 class QualifiedName final : public Node {
   // qualifier::name
   const Node *Qualifier;
   const Node *Name;
 
 public:
-  QualifiedName(Node* Qualifier_, Node* Name_)
+  QualifiedName(const Node *Qualifier_, const Node *Name_)
       : Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Qualifier,
+                          const Node *Name) {
+    Node::profileCtor(ID, KQualifiedName);
+    ID.AddPointer(Qualifier);
+    ID.AddPointer(Name);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Qualifier, Name);
+  }
+#endif
+
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Qualifier->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
 class VectorType final : public Node {
   const Node *BaseType;
   const NodeOrString Dimension;
+  // FIXME: Is this just the same as '!BaseType'?
   const bool IsPixel;
 
 public:
   VectorType(NodeOrString Dimension_)
       : Node(KVectorType), BaseType(nullptr), Dimension(Dimension_),
         IsPixel(true) {}
-  VectorType(Node *BaseType_, NodeOrString Dimension_)
+  VectorType(const Node *BaseType_, NodeOrString Dimension_)
       : Node(KVectorType), BaseType(BaseType_),
         Dimension(Dimension_), IsPixel(false) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeOrString Dimension) {
+    Node::profileCtor(ID, KVectorType);
+    ID.AddBoolean(true); // IsPixel
+    Dimension.profile(ID);
+  }
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *BaseType,
+                          NodeOrString Dimension) {
+    Node::profileCtor(ID, KVectorType);
+    ID.AddBoolean(false); // IsPixel
+    ID.AddPointer(BaseType);
+    Dimension.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    if (IsPixel)
+      profileCtor(ID, Dimension);
+    else
+      profileCtor(ID, BaseType, Dimension);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (IsPixel) {
       S += "pixel vector[";
       S += Dimension.asString();
       S += "]";
     } else {
       BaseType->print(S);
       S += " vector[";
if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
         }))
       FunctionCache = Cache::No;
     if (std::all_of(Data.begin(), Data.end(), [](Node* P) {
           return P->RHSComponentCache == Cache::No;
         }))
       RHSComponentCache = Cache::No;
   }
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Data) {
+    Node::profileCtor(ID, KParameterPack);
+    Data.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Data);
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;
     return Idx < Data.size() && Data[Idx]->hasRHSComponent(S);
   }
   bool hasArraySlow(OutputStream &S) const override {
     initializePackExpansion(S);
     size_t Idx = S.CurrentPackIndex;

 /// TemplateParams table if the <template-args> this pack belongs to apply to an
 /// <encoding>.
 class TemplateArgumentPack final : public Node {
   NodeArray Elements;
 public:
   TemplateArgumentPack(NodeArray Elements_)
       : Node(KTemplateArgumentPack), Elements(Elements_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Elements) {
+    Node::profileCtor(ID, KTemplateArgumentPack);
+    Elements.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Elements);
+  }
+#endif
+
   NodeArray getElements() const { return Elements; }
 
   void printLeft(OutputStream &S) const override {
     Elements.printWithComma(S);
   }
 };
 
 /// A pack expansion. Below this node, there are some unexpanded ParameterPacks
 /// which each have Child->ParameterPackSize elements.
 class ParameterPackExpansion final : public Node {
   const Node *Child;
 
 public:
-  ParameterPackExpansion(Node* Child_)
+  ParameterPackExpansion(const Node *Child_)
       : Node(KParameterPackExpansion), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Child) {
+    Node::profileCtor(ID, KParameterPackExpansion);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Child);
+  }
+#endif
+
   const Node *getChild() const { return Child; }
 
   void printLeft(OutputStream &S) const override {
     constexpr unsigned Max = std::numeric_limits<unsigned>::max();
     SwapAndRestore<unsigned> SavePackIdx(S.CurrentPackIndex, Max);
     SwapAndRestore<unsigned> SavePackMax(S.CurrentPackMax, Max);
     size_t StreamPos = S.getCurrentPosition();
 

 };
 
 class TemplateArgs final : public Node {
   NodeArray Params;
 
 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Params) {
+    Node::profileCtor(ID, KTemplateArgs);
+    Params.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Params);
+  }
+#endif
+
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputStream &S) const override {
     S += "<";
     Params.printWithComma(S);
     if (S.back() == '>')
       S += " ";
     S += ">";
struct ForwardTemplateReference : Node {
   // out if more than one print* function is active.
   mutable bool Printing = false;
 
   ForwardTemplateReference(size_t Index_)
       : Node(KForwardTemplateReference, Cache::Unknown, Cache::Unknown,
              Cache::Unknown),
         Index(Index_) {}
 
+  // We don't canonicalize these, because the index would mean different things
+  // in different mangled names, and we can't rely on the Ref being known in
+  // time.
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, size_t Index) = delete;
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    llvm_unreachable("forward template reference should not be canonicalized");
+  }
+#endif
+
   bool hasRHSComponentSlow(OutputStream &S) const override {
     if (Printing)
       return false;
     SwapAndRestore<bool> SavePrinting(Printing, true);
     return Ref->hasRHSComponent(S);
   }
   bool hasArraySlow(OutputStream &S) const override {
     if (Printing)

 struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
 
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
       : Node(KNameWithTemplateArgs), Name(Name_), TemplateArgs(TemplateArgs_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Name,
+                          Node *TemplateArgs) {
+    Node::profileCtor(ID, KNameWithTemplateArgs);
+    ID.AddPointer(Name);
+    ID.AddPointer(TemplateArgs);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Name, TemplateArgs);
+  }
+#endif
+
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Name->print(S);
     TemplateArgs->print(S);
   }
 };
 
 class GlobalQualifiedName final : public Node {
   Node *Child;
 
 public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Child) {
+    Node::profileCtor(ID, KGlobalQualifiedName);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Child);
+  }
+#endif
+
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     S += "::";
     Child->print(S);
   }
 };
 
 struct StdQualifiedName : Node {
   Node *Child;
 
   StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Child) {
+    Node::profileCtor(ID, KStdQualifiedName);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Child);
+  }
+#endif
+
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     S += "std::";
     Child->print(S);
   }
 };
 
 enum class SpecialSubKind {
   allocator,
   basic_string,
   string,
   istream,
   ostream,
   iostream,
 };
 
 class ExpandedSpecialSubstitution final : public Node {
   SpecialSubKind SSK;
 
 public:
   ExpandedSpecialSubstitution(SpecialSubKind SSK_)
       : Node(KExpandedSpecialSubstitution), SSK(SSK_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, SpecialSubKind SSK) {
+    Node::profileCtor(ID, KExpandedSpecialSubstitution);
+    ID.AddInteger((unsigned)SSK);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, SSK);
+  }
+#endif
+
   StringView getBaseName() const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       return StringView("allocator");
     case SpecialSubKind::basic_string:
       return StringView("basic_string");
     case SpecialSubKind::string:
       return StringView("basic_string");

 
 class SpecialSubstitution final : public Node {
 public:
   SpecialSubKind SSK;
 
   SpecialSubstitution(SpecialSubKind SSK_)
       : Node(KSpecialSubstitution), SSK(SSK_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, SpecialSubKind SSK) {
+    Node::profileCtor(ID, KSpecialSubstitution);
+    ID.AddInteger((unsigned)SSK);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, SSK);
+  }
+#endif
+
   StringView getBaseName() const override {
     switch (SSK) {
     case SpecialSubKind::allocator:
       return StringView("allocator");
     case SpecialSubKind::basic_string:
       return StringView("basic_string");
     case SpecialSubKind::string:
       return StringView("string");
#endif
   }
 };
 
 class CtorDtorName final : public Node {
   const Node *Basename;
   const bool IsDtor;
 
 public:
-  CtorDtorName(Node *Basename_, bool IsDtor_)
+  CtorDtorName(const Node *Basename_, bool IsDtor_)
       : Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Basename,
+                          bool IsDtor) {
+    Node::profileCtor(ID, KCtorDtorName);
+    ID.AddPointer(Basename);
+    ID.AddBoolean(IsDtor);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Basename, IsDtor);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (IsDtor)
       S += "~";
     S += Basename->getBaseName();
   }
 };
 
 class DtorName : public Node {
   const Node *Base;
 
 public:
-  DtorName(Node *Base_) : Node(KDtorName), Base(Base_) {}
+  DtorName(const Node *Base_) : Node(KDtorName), Base(Base_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Base) {
+    Node::profileCtor(ID, KDtorName);
+    ID.AddPointer(Base);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Base);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "~";
     Base->printLeft(S);
   }
 };
 
 class UnnamedTypeName : public Node {
   const StringView Count;
 
 public:
   UnnamedTypeName(StringView Count_) : Node(KUnnamedTypeName), Count(Count_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Count) {
+    Node::profileCtor(ID, KUnnamedTypeName);
+    addString(ID, Count);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Count);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "'unnamed";
     S += Count;
     S += "\'";
   }
 };
 
 class ClosureTypeName : public Node {
   NodeArray Params;
   StringView Count;
 
 public:
   ClosureTypeName(NodeArray Params_, StringView Count_)
       : Node(KClosureTypeName), Params(Params_), Count(Count_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Params,
+                          StringView Count) {
+    Node::profileCtor(ID, KClosureTypeName);
+    Params.profile(ID);
+    addString(ID, Count);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Params, Count);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "\'lambda";
     S += Count;
     S += "\'(";
     Params.printWithComma(S);
     S += ")";
   }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray Bindings) {
+    Node::profileCtor(ID, KStructuredBindingName);
+    Bindings.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Bindings);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += '[';
     Bindings.printWithComma(S);
     S += ']';
   }
 };
 
 // -- Expression Nodes --
 
 struct Expr : public Node {
+  /// Expr kinds, used for profiling.
+  enum ExprKind : unsigned char {
+    KBinaryExpr,
+    KArraySubscriptExpr,
+    KPostfixExpr,
+    KConditionalExpr,
+    KMemberExpr,
+    KEnclosingExpr,
+    KCastExpr,
+    KSizeofParamPackExpr,
+    KCallExpr,
+    KNewExpr,
+    KDeleteExpr,
+    KPrefixExpr,
+    KFunctionParam,
+    KConversionExpr,
+    KInitListExpr,
+    KFoldExpr,
+    KThrowExpr,
+    KBoolExpr,
+    KIntegerCastExpr,
+    KIntegerExpr,
+    KFloatExpr,
+  };
+
   Expr(Kind K = KExpr) : Node(K) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Kind K = KExpr) {
+    Node::profileCtor(ID, K);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, K);
+  }
 };
+#endif
 
 class BinaryExpr : public Expr {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
 
 public:
-  BinaryExpr(Node *LHS_, StringView InfixOperator_, Node *RHS_)
+  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
       : LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *LHS,
+                          StringView InfixOperator, const Node *RHS) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KBinaryExpr);
+    ID.AddPointer(LHS);
+    addString(ID, InfixOperator);
+    ID.AddPointer(RHS);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, LHS, InfixOperator, RHS);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     // might be a template argument expression, then we need to disambiguate
     // with parens.
     if (InfixOperator == ">")
       S += "(";
 
     S += "(";
     LHS->print(S);
     S += ") ";
     S += InfixOperator;
     S += " (";
     RHS->print(S);
     S += ")";
 
     if (InfixOperator == ">")
       S += ")";
   }
 };
 
 class ArraySubscriptExpr : public Expr {
   const Node *Op1;
   const Node *Op2;
 
 public:
-  ArraySubscriptExpr(Node *Op1_, Node *Op2_) : Op1(Op1_), Op2(Op2_) {}
+  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
+      : Op1(Op1_), Op2(Op2_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Op1,
+                          const Node *Op2) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KArraySubscriptExpr);
+    ID.AddPointer(Op1);
+    ID.AddPointer(Op2);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Op1, Op2);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "(";
     Op1->print(S);
     S += ")[";
     Op2->print(S);
     S += "]";
   }
 };
 
 class PostfixExpr : public Expr {
   const Node *Child;
-  const StringView Operand;
+  const StringView Operator;
 
 public:
-  PostfixExpr(Node *Child_, StringView Operand_)
-      : Child(Child_), Operand(Operand_) {}
+  PostfixExpr(const Node *Child_, StringView Operator_)
+      : Child(Child_), Operator(Operator_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Child,
+                          StringView Operator) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KPostfixExpr);
+    ID.AddPointer(Child);
+    addString(ID, Operator);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Child, Operator);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "(";
     Child->print(S);
     S += ")";
-    S += Operand;
+    S += Operator;
   }
 };
 
 class ConditionalExpr : public Expr {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
-  ConditionalExpr(Node *Cond_, Node *Then_, Node *Else_)
+  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
       : Cond(Cond_), Then(Then_), Else(Else_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Cond,
+                          const Node *Then, const Node *Else) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KConditionalExpr);
+    ID.AddPointer(Cond);
+    ID.AddPointer(Then);
+    ID.AddPointer(Else);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Cond, Then, Else);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "(";
     Cond->print(S);
     S += ") ? (";
     Then->print(S);
     S += ") : (";
     Else->print(S);
     S += ")";
   }
 };
 
 class MemberExpr : public Expr {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
-  MemberExpr(Node *LHS_, StringView Kind_, Node *RHS_)
+  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
       : LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *LHS,
+                          StringView Kind, const Node *RHS) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KMemberExpr);
+    ID.AddPointer(LHS);
+    addString(ID, Kind);
+    ID.AddPointer(RHS);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, LHS, Kind, RHS);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     LHS->print(S);
     S += Kind;
     RHS->print(S);
   }
 };
 
 class EnclosingExpr : public Expr {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
   EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
       : Prefix(Prefix_), Infix(Infix_), Postfix(Postfix_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Prefix,
+                          const Node *Infix, StringView Postfix) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KEnclosingExpr);
+    addString(ID, Prefix);
+    ID.AddPointer(Infix);
+    addString(ID, Postfix);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Prefix, Infix, Postfix);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += Prefix;
     Infix->print(S);
     S += Postfix;
   }
 };
 
 class CastExpr : public Expr {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
-  CastExpr(StringView CastKind_, Node *To_, Node *From_)
+  CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
       : CastKind(CastKind_), To(To_), From(From_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView CastKind,
+                          const Node *To, const Node *From) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KCastExpr);
+    addString(ID, CastKind);
+    ID.AddPointer(To);
+    ID.AddPointer(From);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, CastKind, To, From);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += CastKind;
     S += "<";
     To->printLeft(S);
     S += ">(";
     From->printLeft(S);
     S += ")";
   }
 };
 
 class SizeofParamPackExpr : public Expr {
-  Node *Pack;
+  const Node *Pack;
 
 public:
-  SizeofParamPackExpr(Node *Pack_) : Pack(Pack_) {}
+  SizeofParamPackExpr(const Node *Pack_) : Pack(Pack_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Pack) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KSizeofParamPackExpr);
+    ID.AddPointer(Pack);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Pack);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "sizeof...(";
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(S);
     S += ")";
   }
 };
 
 class CallExpr : public Expr {
   const Node *Callee;
   NodeArray Args;
 
 public:
-  CallExpr(Node *Callee_, NodeArray Args_) : Callee(Callee_), Args(Args_) {}
+  CallExpr(const Node *Callee_, NodeArray Args_)
+      : Callee(Callee_), Args(Args_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Callee,
+                          NodeArray Args) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KCallExpr);
+    ID.AddPointer(Callee);
+    Args.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Callee, Args);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     Callee->print(S);
     S += "(";
     Args.printWithComma(S);
     S += ")";
   }
 };
 
 class NewExpr : public Expr {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
   bool IsArray;  // new[] ?
 public:
   NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
           bool IsArray_)
       : ExprList(ExprList_), Type(Type_), InitList(InitList_),
         IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, NodeArray ExprList,
+                          Node *Type, NodeArray InitList, bool IsGlobal,
+                          bool IsArray) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KNewExpr);
+    ExprList.profile(ID);
+    ID.AddPointer(Type);
+    InitList.profile(ID);
+    ID.AddBoolean(IsGlobal);
+    ID.AddBoolean(IsArray);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, ExprList, Type, InitList, IsGlobal, IsArray);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (IsGlobal)
       S += "::operator ";
     S += "new";
     if (IsArray)
       S += "[]";
     S += ' ';
     if (!ExprList.empty()) {
class DeleteExpr : public Expr {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
   DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
       : Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Op, bool IsGlobal,
+                          bool IsArray) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KDeleteExpr);
+    ID.AddPointer(Op);
+    ID.AddBoolean(IsGlobal);
+    ID.AddBoolean(IsArray);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Op, IsGlobal, IsArray);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (IsGlobal)
       S += "::";
     S += "delete";
     if (IsArray)
       S += "[] ";
     Op->print(S);
   }
 };
 
 class PrefixExpr : public Expr {
   StringView Prefix;
   Node *Child;
 
 public:
-  PrefixExpr(StringView Prefix_, Node *Child_) : Prefix(Prefix_), Child(Child_) {}
+  PrefixExpr(StringView Prefix_, Node *Child_)
+      : Prefix(Prefix_), Child(Child_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Prefix,
+                          Node *Child) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KPrefixExpr);
+    addString(ID, Prefix);
+    ID.AddPointer(Child);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Prefix, Child);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += Prefix;
     S += "(";
     Child->print(S);
     S += ")";
   }
 };
 
 class FunctionParam : public Expr {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Number(Number_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Number) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KFunctionParam);
+    addString(ID, Number);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Number);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "fp";
     S += Number;
   }
 };
 
 class ConversionExpr : public Expr {
   const Node *Type;
   NodeArray Expressions;
 
 public:
   ConversionExpr(const Node *Type_, NodeArray Expressions_)
       : Type(Type_), Expressions(Expressions_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Type,
+                          NodeArray Expressions) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KConversionExpr);
+    ID.AddPointer(Type);
+    Expressions.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Type, Expressions);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "(";
     Type->print(S);
     S += ")(";
     Expressions.printWithComma(S);
     S += ")";
   }
 };
 
 class InitListExpr : public Expr {
-  Node *Ty;
+  const Node *Ty;
   NodeArray Inits;
 public:
-  InitListExpr(Node *Ty_, NodeArray Inits_) : Ty(Ty_), Inits(Inits_) {}
+  InitListExpr(const Node *Ty_, NodeArray Inits_) : Ty(Ty_), Inits(Inits_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Type,
+                          NodeArray Inits) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KInitListExpr);
+    ID.AddPointer(Type);
+    Inits.profile(ID);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty, Inits);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     if (Ty)
       Ty->print(S);
     S += '{';
     Inits.printWithComma(S);
     S += '}';
   }
 };
 
 class BracedExpr : public Expr {
-  Node *Elem;
-  Node *Init;
+  const Node *Elem;
+  const Node *Init;
   bool IsArray;
 public:
-  BracedExpr(Node *Elem_, Node *Init_, bool IsArray_)
+  BracedExpr(const Node *Elem_, const Node *Init_, bool IsArray_)
       : Expr(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Elem,
+                          const Node *Init, bool IsArray) {
+    Expr::profileCtor(ID, KBracedExpr);
+    ID.AddPointer(Elem);
+    ID.AddPointer(Init);
+    ID.AddBoolean(IsArray);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Elem, Init, IsArray);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (IsArray) {
       S += '[';
       Elem->print(S);
       S += ']';
     } else {
       S += '.';
       Elem->print(S);
     }
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
   }
 };
 
 class BracedRangeExpr : public Expr {
-  Node *First;
-  Node *Last;
-  Node *Init;
+  const Node *First;
+  const Node *Last;
+  const Node *Init;
 public:
-  BracedRangeExpr(Node *First_, Node *Last_, Node *Init_)
+  BracedRangeExpr(const Node *First_, const Node *Last_, const Node *Init_)
       : Expr(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *First,
+                          const Node *Last, const Node *Init) {
+    Expr::profileCtor(ID, KBracedRangeExpr);
+    ID.AddPointer(First);
+    ID.AddPointer(Last);
+    ID.AddPointer(Init);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, First, Last, Init);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += '[';
     First->print(S);
     S += " ... ";
     Last->print(S);
     S += ']';
     if (Init->getKind() != KBracedExpr && Init->getKind() != KBracedRangeExpr)
       S += " = ";
     Init->print(S);
   }
 };
 
 struct FoldExpr : Expr {
-  Node *Pack, *Init;
+  const Node *Pack, *Init;
   StringView OperatorName;
   bool IsLeftFold;
 
-  FoldExpr(bool IsLeftFold_, StringView OperatorName_, Node *Pack_, Node *Init_)
+  FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
+           const Node *Init_)
       : Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
         IsLeftFold(IsLeftFold_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, bool IsLeftFold,
+                          StringView OperatorName, const Node *Pack,
+                          const Node *Init) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KFoldExpr);
+    ID.AddBoolean(IsLeftFold);
+    addString(ID, OperatorName);
+    ID.AddPointer(Pack);
+    ID.AddPointer(Init);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, IsLeftFold, OperatorName, Pack, Init);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     auto PrintPack = [&] {
       S += '(';
       ParameterPackExpansion(Pack).print(S);
       S += ')';
     };
 
     S += '(';
void printLeft(OutputStream &S) const override {
     S += ')';
   }
 };
 
 class ThrowExpr : public Expr {
   const Node *Op;
 
 public:
-  ThrowExpr(Node *Op_) : Op(Op_) {}
+  ThrowExpr(const Node *Op_) : Op(Op_) {}
+
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Op) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KThrowExpr);
+    ID.AddPointer(Op);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Op);
+  }
+#endif
 
   void printLeft(OutputStream &S) const override {
     S += "throw ";
     Op->print(S);
   }
 };
 
 class BoolExpr : public Expr {
   bool Value;
 
 public:
   BoolExpr(bool Value_) : Value(Value_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, bool Value) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KBoolExpr);
+    ID.AddBoolean(Value);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Value);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += Value ? StringView("true") : StringView("false");
   }
 };
 
 class IntegerCastExpr : public Expr {
   // ty(integer)
-  Node *Ty;
+  const Node *Ty;
   StringView Integer;
 
 public:
-  IntegerCastExpr(Node *Ty_, StringView Integer_)
+  IntegerCastExpr(const Node *Ty_, StringView Integer_)
       : Ty(Ty_), Integer(Integer_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, const Node *Ty,
+                          StringView Integer) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KIntegerCastExpr);
+    ID.AddPointer(Ty);
+    addString(ID, Integer);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Ty, Integer);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     S += "(";
     Ty->print(S);
     S += ")";
     S += Integer;
   }
 };
 
 class IntegerExpr : public Expr {
   StringView Type;
   StringView Value;
 
 public:
   IntegerExpr(StringView Type_, StringView Value_) : Type(Type_), Value(Value_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Type,
+                          StringView Value) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KIntegerExpr);
+    addString(ID, Type);
+    addString(ID, Value);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Type, Value);
+  }
+#endif
+
   void printLeft(OutputStream &S) const override {
     if (Type.size() > 3) {
       S += "(";
       S += Type;
       S += ")";
     }
 
     if (Value[0] == 'n') {

 template <class Float> struct FloatData;
 
 template <class Float> class FloatExpr : public Expr {
   const StringView Contents;
 
 public:
   FloatExpr(StringView Contents_) : Contents(Contents_) {}
 
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, StringView Contents) {
+    Expr::profileCtor(ID);
+    ID.AddInteger(KFloatExpr);
+    addString(ID, Contents);
+  }
+  void profile(llvm::FoldingSetNodeID &ID) const override {
+    profileCtor(ID, Contents);
+  }
+#endif
+
   void printLeft(OutputStream &s) const override {
     const char *first = Contents.begin();
     const char *last = Contents.end() + 1;
 
     const size_t N = FloatData<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N) {
       last = first + N;
       union {
return new (Alloc.allocate(sizeof(T)))
         T(std::forward<Args>(args)...);
   }
 
   void *allocateNodeArray(size_t sz) {
     return Alloc.allocate(sizeof(Node *) * sz);
   }
 };
 
-template<typename Alloc = DefaultAllocator>
+#ifndef STANDALONE_DEMANGLER
+class FoldingNodeAllocator {
+  class alignas(alignof(Node *)) NodeHeader : public llvm::FoldingSetNode {
+  public:
+    ::Node *getNode() { return reinterpret_cast<::Node*>(this + 1); }
+    void Profile(llvm::FoldingSetNodeID &ID) {
+      getNode()->profile(ID);
+    }
+  };
+
+  BumpPointerAllocator RawAlloc;
+  llvm::FoldingSet<NodeHeader> Nodes;
+
+public:
+  void reset() {}
+
+  template<typename T, typename ...Args> T *makeNode(Args &&...args) {
+    llvm::FoldingSetNodeID ID;
+    T::profileCtor(ID, args...);
+
+    void *InsertPos;
+    if (NodeHeader *Existing = Nodes.FindNodeOrInsertPos(ID, InsertPos))
+      return static_cast<T*>(Existing->getNode());
+
+    void *Storage = RawAlloc.allocate(sizeof(NodeHeader) + sizeof(T));
+    NodeHeader *New = new (Storage) NodeHeader;
+    T *Result = new (New->getNode()) T(std::forward<Args>(args)...);
+    Nodes.InsertNode(New, InsertPos);
+    return Result;
+  }
+
+  void *allocateNodeArray(size_t sz) {
+    return RawAlloc.allocate(sizeof(Node *) * sz);
+  }
+};
+
+// FIXME: Don't canonicalize forward template references for now, because they
+// contain state (the resolved template node) that's not known at their point
+// of creation.
+template <>
+ForwardTemplateReference *
+FoldingNodeAllocator::makeNode<ForwardTemplateReference, size_t&>(
+    size_t &Index) {
+  return new (RawAlloc.allocate(sizeof(ForwardTemplateReference)))
+      ForwardTemplateReference(Index);
+}
+#endif
+
+template <typename Alloc = DefaultAllocator>
 struct Db {
   const char *First;
   const char *Last;
 
   // Name stack, this is used by the parser to hold temporary names that were
   // parsed. The parser collapses multiple names into new nodes to construct
   // the AST. Once the parser is finished, names.size() == 1.
   PODSmallVector<Node *, 32> Names;

 bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
   Db<> *Parser = static_cast<Db<> *>(Context);
   size_t Len = std::strlen(MangledName);
   Parser->reset(MangledName, MangledName + Len);
   RootNode = Parser->parse();
   return RootNode == nullptr;
 }
 
-static char *printNode(Node *RootNode, char *Buf, size_t *N) {
+static char *printNode(const Node *RootNode, char *Buf, size_t *N) {
   OutputStream S;
   if (initializeOutputStream(Buf, N, S, 128))
     return nullptr;
   RootNode->print(S);
   S += '\0';
   if (N != nullptr)
     *N = S.getCurrentPosition();
   return S.getBuffer();
 }
 
 char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const {
   if (!isFunction())
     return nullptr;
 
-  Node *Name = static_cast<FunctionEncoding *>(RootNode)->getName();
+  const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName();
 
   while (true) {
     switch (Name->getKind()) {
     case Node::KAbiTagAttr:
-      Name = static_cast<AbiTagAttr *>(Name)->Base;
+      Name = static_cast<const AbiTagAttr *>(Name)->Base;
       continue;
     case Node::KStdQualifiedName:
-      Name = static_cast<StdQualifiedName *>(Name)->Child;
+      Name = static_cast<const StdQualifiedName *>(Name)->Child;
       continue;
     case Node::KNestedName:
-      Name = static_cast<NestedName *>(Name)->Name;
+      Name = static_cast<const NestedName *>(Name)->Name;
       continue;
     case Node::KLocalName:
-      Name = static_cast<LocalName *>(Name)->Entity;
+      Name = static_cast<const LocalName *>(Name)->Entity;
       continue;
     case Node::KNameWithTemplateArgs:
-      Name = static_cast<NameWithTemplateArgs *>(Name)->Name;
+      Name = static_cast<const NameWithTemplateArgs *>(Name)->Name;
       continue;
     default:
       return printNode(Name, Buf, N);
     }
   }
 }
 
 char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf,
                                                           size_t *N) const {
   if (!isFunction())
     return nullptr;
-  Node *Name = static_cast<FunctionEncoding *>(RootNode)->getName();
+  const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName();
 
   OutputStream S;
   if (initializeOutputStream(Buf, N, S, 128))
     return nullptr;
 
  KeepGoingLocalFunction:
   while (true) {
     if (Name->getKind() == Node::KAbiTagAttr) {
-      Name = static_cast<AbiTagAttr *>(Name)->Base;
+      Name = static_cast<const AbiTagAttr *>(Name)->Base;
       continue;
     }
     if (Name->getKind() == Node::KNameWithTemplateArgs) {
-      Name = static_cast<NameWithTemplateArgs *>(Name)->Name;
+      Name = static_cast<const NameWithTemplateArgs *>(Name)->Name;
       continue;
     }
     break;
   }
 
   switch (Name->getKind()) {
   case Node::KStdQualifiedName:
     S += "std";
     break;
   case Node::KNestedName:
-    static_cast<NestedName *>(Name)->Qual->print(S);
+    static_cast<const NestedName *>(Name)->Qual->print(S);
     break;
   case Node::KLocalName: {
-    auto *LN = static_cast<LocalName *>(Name);
+    auto *LN = static_cast<const LocalName *>(Name);
     LN->Encoding->print(S);
     S += "::";
     Name = LN->Entity;
     goto KeepGoingLocalFunction;
   }
   default:
     break;
   }
char *ItaniumPartialDemangler::getFunctionReturnType(
     char *Buf, size_t *N) const {
   if (!isFunction())
     return nullptr;
 
   OutputStream S;
   if (initializeOutputStream(Buf, N, S, 128))
     return nullptr;
 
-  if (Node *Ret = static_cast<FunctionEncoding *>(RootNode)->getReturnType())
+  if (const Node *Ret =
+          static_cast<const FunctionEncoding *>(RootNode)->getReturnType())
     Ret->print(S);
 
   S += '\0';
   if (N != nullptr)
     *N = S.getCurrentPosition();
   return S.getBuffer();
 }
 
 char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   return printNode(static_cast<Node *>(RootNode), Buf, N);
 }
 
 bool ItaniumPartialDemangler::hasFunctionQualifiers() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
   if (!isFunction())
     return false;
-  auto *E = static_cast<FunctionEncoding *>(RootNode);
+  auto *E = static_cast<const FunctionEncoding *>(RootNode);
   return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone;
 }
 
 bool ItaniumPartialDemangler::isCtorOrDtor() const {
-  Node *N = static_cast<Node *>(RootNode);
+  const Node *N = static_cast<const Node *>(RootNode);
   while (N) {
     switch (N->getKind()) {
     default:
       return false;
     case Node::KCtorDtorName:
       return true;
 
     case Node::KAbiTagAttr:
-      N = static_cast<AbiTagAttr *>(N)->Base;
+      N = static_cast<const AbiTagAttr *>(N)->Base;
       break;
     case Node::KFunctionEncoding:
-      N = static_cast<FunctionEncoding *>(N)->getName();
+      N = static_cast<const FunctionEncoding *>(N)->getName();
       break;
     case Node::KLocalName:
-      N = static_cast<LocalName *>(N)->Entity;
+      N = static_cast<const LocalName *>(N)->Entity;
       break;
     case Node::KNameWithTemplateArgs:
-      N = static_cast<NameWithTemplateArgs *>(N)->Name;
+      N = static_cast<const NameWithTemplateArgs *>(N)->Name;
       break;
     case Node::KNestedName:
-      N = static_cast<NestedName *>(N)->Name;
+      N = static_cast<const NestedName *>(N)->Name;
       break;
     case Node::KStdQualifiedName:
-      N = static_cast<StdQualifiedName *>(N)->Child;
+      N = static_cast<const StdQualifiedName *>(N)->Child;
       break;
     }
   }
   return false;
 }
 
 bool ItaniumPartialDemangler::isFunction() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
-  return static_cast<Node *>(RootNode)->getKind() == Node::KFunctionEncoding;
+  return static_cast<const Node *>(RootNode)->getKind() ==
+         Node::KFunctionEncoding;
 }
 
 bool ItaniumPartialDemangler::isSpecialName() const {
   assert(RootNode != nullptr && "must call partialDemangle()");
-  auto K = static_cast<Node *>(RootNode)->getKind();
+  auto K = static_cast<const Node *>(RootNode)->getKind();
   return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName;
 }
 
 bool ItaniumPartialDemangler::isData() const {
   return !isFunction() && !isSpecialName();
 }
 }  // namespace llvm