[WIP][NOT FOR COMMIT][PROTOTYPE] clang-scan-deps: dependency scanning tool rough prototype

[arphaman]

Oops, this is a wrong patch. Sorry for the noise.

include/llvm/Demangle/Canonicalize.h

+//===--- Canonicalize.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEMANGLE_CANONICALIZE_H
+#define LLVM_DEMANGLE_CANONICALIZE_H
+
+#include "llvm/ADT/StringRef.h"
+
+#include <cstddef>
+
+namespace llvm {
+/// Canonicalizer for mangled names.
+///
+/// This class allows specifying a list of "equivalent" manglings. For example,
+/// you can specify that Ss is equivalent to
+///   NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE
+/// and then manglings that refer to libstdc++'s 'std::string' will be
+/// considered equivalent to manglings that are the same except that they refer
+/// to libc++'s 'std::string'.
+///
+/// This can be used when data (eg, profiling data) is available for a version
+/// of a program built in a different configuration, with correspondingly
+/// different manglings.
+class ItaniumManglingCanonicalizer {
+public:
+  ItaniumManglingCanonicalizer();
+  ItaniumManglingCanonicalizer(const ItaniumManglingCanonicalizer &) = delete;
+  void operator=(const ItaniumManglingCanonicalizer &) = delete;
+  ~ItaniumManglingCanonicalizer();
+
+  enum class EquivalenceError {
+    Success,
+
+    /// Both the equivalent manglings have already been used as components of
+    /// some other mangling we've looked at. It's too late to add this
+    /// equivalence.
+    ManglingAlreadyUsed,
+
+    /// The first equivalent mangling is invalid.
+    InvalidFirstMangling,
+
+    /// The second equivalent mangling is invalid.
+    InvalidSecondMangling,
+  };
+
+  enum class FragmentKind {
+    /// The mangling fragment is a <name> (or a predefined <substitution>).
+    Name,
+    /// The mangling fragment is a <type>.
+    Type,
+    /// The mangling fragment is an <encoding>.
+    Encoding,
+  };
+
+  /// Add an equivalence between \p First and \p Second. Both manglings must
+  /// live at least as long as the canonicalizer.
+  EquivalenceError addEquivalence(FragmentKind Kind, StringRef First,
+                                  StringRef Second);
+
+  using Key = uintptr_t;
+
+  /// Form a canonical key for the specified mangling. They key will be the
+  /// same for all equivalent manglings, and different for any two
+  /// non-equivalent manglings, but is otherwise unspecified.
+  ///
+  /// Returns Key() if (and only if) the mangling is not a valid Itanium C++
+  /// ABI mangling.
+  ///
+  /// The string denoted by Mangling must live as long as the canonicalizer.
+  Key canonicalize(StringRef Mangling);
+
+  /// Find a canonical key for the specified mangling, if one has already been
+  /// formed. Otherwise returns Key().
+  Key lookup(StringRef Mangling);
+
+private:
+  struct Impl;
+  Impl *P;
+};
+} // namespace llvm
+
+#endif

include/llvm/LTO/Config.h

struct Config {
 
   /// Setting this field will replace unspecified target triples in input files
   /// with this triple.
   std::string DefaultTriple;
 
   /// Sample PGO profile path.
   std::string SampleProfile;
 
+  /// Name remapping file for profile data.
+  std::string ProfileRemapping;
+
   /// The directory to store .dwo files.
   std::string DwoDir;
 
   /// The path to write a .dwo file to. This should generally only be used when
   /// running an individual backend directly via thinBackend(), as otherwise
   /// all .dwo files will be written to the same path.
   std::string DwoPath;
 

include/llvm/Passes/PassBuilder.h

 class StringRef;
 class AAManager;
 class TargetMachine;
 class ModuleSummaryIndex;
 
 /// A struct capturing PGO tunables.
 struct PGOOptions {
   PGOOptions(std::string ProfileGenFile = "", std::string ProfileUseFile = "",
-             std::string SampleProfileFile = "", bool RunProfileGen = false,
-             bool SamplePGOSupport = false)
+             std::string SampleProfileFile = "",
+             std::string ProfileRemappingFile = "",
+             bool RunProfileGen = false, bool SamplePGOSupport = false)
       : ProfileGenFile(ProfileGenFile), ProfileUseFile(ProfileUseFile),
-        SampleProfileFile(SampleProfileFile), RunProfileGen(RunProfileGen),
+        SampleProfileFile(SampleProfileFile),
+        ProfileRemappingFile(ProfileRemappingFile),
+        RunProfileGen(RunProfileGen),
         SamplePGOSupport(SamplePGOSupport || !SampleProfileFile.empty()) {
     assert((RunProfileGen ||
             !SampleProfileFile.empty() ||
             !ProfileUseFile.empty() ||
             SamplePGOSupport) && "Illegal PGOOptions.");
   }
   std::string ProfileGenFile;
   std::string ProfileUseFile;
   std::string SampleProfileFile;
+  std::string ProfileRemappingFile;
   bool RunProfileGen;
   bool SamplePGOSupport;
 };
 
 /// This class provides access to building LLVM's passes.
 ///
 /// It's members provide the baseline state available to passes during their
 /// construction. The \c PassRegistry.def file specifies how to construct all
bool parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
                               bool VerifyEachPass, bool DebugLogging);
   bool parseModulePassPipeline(ModulePassManager &MPM,
                                ArrayRef<PipelineElement> Pipeline,
                                bool VerifyEachPass, bool DebugLogging);
 
   void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
                          OptimizationLevel Level, bool RunProfileGen,
                          std::string ProfileGenFile,
-                         std::string ProfileUseFile);
+                         std::string ProfileUseFile,
+                         std::string ProfileRemappingFile);
 
   void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);
 
   // Extension Point callbacks
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       PeepholeEPCallbacks;
   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
       LateLoopOptimizationsEPCallbacks;

include/llvm/ProfileData/InstrProfReader.h

struct InstrProfReaderIndexBase {
   virtual uint64_t getVersion() const = 0;
   virtual bool isIRLevelProfile() const = 0;
   virtual Error populateSymtab(InstrProfSymtab &) = 0;
 };
 
 using OnDiskHashTableImplV3 =
     OnDiskIterableChainedHashTable<InstrProfLookupTrait>;
 
-template <typename HashTableImpl>
+template<typename HashTableImpl>
+class InstrProfReaderItaniumRemapper;
+
+template <typename HashTableImpl>
 class InstrProfReaderIndex : public InstrProfReaderIndexBase {
 private:
   std::unique_ptr<HashTableImpl> HashTable;
   typename HashTableImpl::data_iterator RecordIterator;
   uint64_t FormatVersion;
 
+  friend class InstrProfReaderItaniumRemapper<HashTableImpl>;
+
 public:
   InstrProfReaderIndex(const unsigned char *Buckets,
                        const unsigned char *const Payload,
                        const unsigned char *const Base,
                        IndexedInstrProf::HashT HashType, uint64_t Version);
   ~InstrProfReaderIndex() override = default;
 
   Error getRecords(ArrayRef<NamedInstrProfRecord> &Data) override;
public:
   }
 };
 
 /// Reader for the indexed binary instrprof format.
 class IndexedInstrProfReader : public InstrProfReader {
 private:
   /// The profile data file contents.
   std::unique_ptr<MemoryBuffer> DataBuffer;
+  /// The profile remapping file contents.
+  std::unique_ptr<MemoryBuffer> RemappingBuffer;
   /// The index into the profile data.
   std::unique_ptr<InstrProfReaderIndexBase> Index;
   /// Profile summary data.
   std::unique_ptr<ProfileSummary> Summary;
   // Index to the current record in the record array.
   unsigned RecordIndex;
 
   // Read the profile summary. Return a pointer pointing to one byte past the
   // end of the summary data if it exists or the input \c Cur.
   const unsigned char *readSummary(IndexedInstrProf::ProfVersion Version,
                                    const unsigned char *Cur);
 
 public:
-  IndexedInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
-      : DataBuffer(std::move(DataBuffer)), RecordIndex(0) {}
+  IndexedInstrProfReader(
+      std::unique_ptr<MemoryBuffer> DataBuffer,
+      std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr)
+      : DataBuffer(std::move(DataBuffer)),
+        RemappingBuffer(std::move(RemappingBuffer)), RecordIndex(0) {}
   IndexedInstrProfReader(const IndexedInstrProfReader &) = delete;
   IndexedInstrProfReader &operator=(const IndexedInstrProfReader &) = delete;
 
   /// Return the profile version.
   uint64_t getVersion() const { return Index->getVersion(); }
   bool isIRLevelProfile() const override { return Index->isIRLevelProfile(); }
 
   /// Return true if the given buffer is in an indexed instrprof format.
public:
   Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
                           std::vector<uint64_t> &Counts);
 
   /// Return the maximum of all known function counts.
   uint64_t getMaximumFunctionCount() { return Summary->getMaxFunctionCount(); }
 
   /// Factory method to create an indexed reader.
   static Expected<std::unique_ptr<IndexedInstrProfReader>>
-  create(const Twine &Path);
+  create(const Twine &Path, const Twine &RemappingPath = "");
 
   static Expected<std::unique_ptr<IndexedInstrProfReader>>
-  create(std::unique_ptr<MemoryBuffer> Buffer);
+  create(std::unique_ptr<MemoryBuffer> Buffer,
+         std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr);
 
   // Used for testing purpose only.
   void setValueProfDataEndianness(support::endianness Endianness) {
     Index->setValueProfDataEndianness(Endianness);
   }
 
   // See description in the base class. This interface is designed
   // to be used by llvm-profdata (for dumping). Avoid using this when
   // the client is the compiler.
   InstrProfSymtab &getSymtab() override;
   ProfileSummary &getSummary() { return *(Summary.get()); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFREADER_H

include/llvm/ProfileData/ProfRemappingReader.h

+//===- ProfRemappingReader.h - Read profile remapping file ------*- C++ -*-===//
+//
+//                      The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains definitions needed for reading and applying profile
+// remapping files.
+//
+// NOTE: If you are making changes to this file format, please remember
+//       to document them in the Clang documentation at
+//       tools/clang/docs/UsersManual.rst.
+//
+// File format
+// -----------
+//
+// The profile remappings are written as an ASCII text file. Blank lines and
+// lines starting with a # are ignored. All other lines specify a kind of
+// mangled name fragment, along with two fragments of that kind that should
+// be treated as equivalent, separated by spaces.
+//
+// See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
+// description of the Itanium name mangling scheme.
+//
+// The accepted fragment kinds are:
+//
+//  * name  A <name>, such as 6foobar or St3__1
+//  * type  A <type>, such as Ss or N4llvm9StringRefE
+//  * encoding  An <encoding> (a complete mangling without the leading _Z)
+//
+// For example:
+//
+// # Ignore int / long differences to allow profile reuse between
+// # 32-bit and 64-bit builds with differing size_t / ptrdiff_t / intptr_t.
+// type i l
+// type j m
+//
+// # Ignore differences between libc++ and libstdc++, and between libstdc++'s
+// # C++98 and C++11 ABIs.
+// name 3std St3__1
+// name 3std St7__cxx11
+//
+// # Substitutions must be remapped separately from namespace 'std' for now.
+// name Sa NSt3__19allocatorE
+// name Sb NSt3__112basic_stringE
+// type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
+// # ...
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PROFILEDATA_PROFREMAPPINGREADER_H
+#define LLVM_PROFILEDATA_PROFREMAPPINGREADER_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Demangle/Canonicalize.h"
+
+namespace llvm {
+
+class ProfileRemappingParseError
+    : public ErrorInfo<ProfileRemappingParseError> {
+public:
+  ProfileRemappingParseError(StringRef File, int64_t Line, Twine Message)
+      : File(File), Line(Line), Message(Message.str()) {}
+
+  void log(llvm::raw_ostream &OS) const override {
+    OS << File << ':' << Line << ": " << Message;
+  }
+  std::error_code convertToErrorCode() const override {
+    return llvm::inconvertibleErrorCode();
+  }
+
+  StringRef getFileName() const { return File; }
+  int64_t getLineNum() const { return Line; }
+  StringRef getMessage() const { return Message; }
+
+  static char ID;
+
+private:
+  std::string File;
+  int64_t Line;
+  std::string Message;
+};
+
+/// Profile name remapper.
+///
+/// Remaps the symbol names in profile data to match those in the program
+/// according to a set of rules specified in a given file.
+class ItaniumProfileRemappingReader {
+public:
+  /// Read remappings from the given buffer, which must live as long as
+  /// the remapper.
+  Error read(MemoryBuffer &B);
+
+  using Key = ItaniumManglingCanonicalizer::Key;
+
+  /// Map the given function name from the profiling data into a profile
+  /// data key. The result will be Key() if the name cannot be remapped.
+  Key remap(StringRef FunctionName) {
+    return Canonicalizer.canonicalize(FunctionName);
+  }
+
+  /// Map the given function name from the program into a profile data key.
+  ///
+  /// The result will be Key() if the name has no corresponding entry in the
+  /// profile data, in which case the original name should be looked up in the
+  /// profile data.
+  ///
+  /// There is no guarantee that return values other than Key() have ever been
+  /// returned by remap(...), but this should be rare.
+  Key lookup(StringRef FunctionName) {
+    return Canonicalizer.lookup(FunctionName);
+  }
+
+private:
+  ItaniumManglingCanonicalizer Canonicalizer;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_PROFILEDATA_PROFREMAPPINGREADER_H

include/llvm/ProfileData/SampleProfReader.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/GCOV.h"
 #include "llvm/ProfileData/SampleProf.h"
+#include "llvm/ProfileData/ProfRemappingReader.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <system_error>
public:
   /// Print all the profiles on stream \p OS.
   void dump(raw_ostream &OS = dbgs());
 
   /// Return the samples collected for function \p F.
   FunctionSamples *getSamplesFor(const Function &F) {
     // The function name may have been updated by adding suffix. In sample
     // profile, the function names are all stripped, so we need to strip
     // the function name suffix before matching with profile.
-    StringRef Fname = F.getName().split('.').first;
+    return getSamplesFor(F.getName().split('.').first);
+  }
+
+  /// Return the samples collected for function \p F.
+  virtual FunctionSamples *getSamplesFor(StringRef Fname) {
     std::string FGUID;
     Fname = getRepInFormat(Fname, getFormat(), FGUID);
-    if (Profiles.count(Fname))
-      return &Profiles[Fname];
+    auto It = Profiles.find(Fname);
+    if (It != Profiles.end())
+      return &It->second;
     return nullptr;
   }
 
   /// Return all the profiles.
   StringMap<FunctionSamples> &getProfiles() { return Profiles; }
 
   /// Report a parse error message.
   void reportError(int64_t LineNumber, Twine Msg) const {
protected:
   LLVMContext &Ctx;
 
   /// Memory buffer holding the profile file.
   std::unique_ptr<MemoryBuffer> Buffer;
 
   /// Profile summary information.
   std::unique_ptr<ProfileSummary> Summary;
 
+  /// Take ownership of the summary of this reader.
+  static std::unique_ptr<ProfileSummary>
+  takeSummary(SampleProfileReader &Reader) {
+    return std::move(Reader.Summary);
+  }
+
   /// Compute summary for this profile.
   void computeSummary();
 
   /// \brief The format of sample.
   SampleProfileFormat Format = SPF_None;
 };
 
 class SampleProfileReaderText : public SampleProfileReader {
protected:
   /// Function names in this profile.
   std::vector<std::string> Names;
 
   /// GCOV tags used to separate sections in the profile file.
   static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
   static const uint32_t GCOVTagAFDOFunction = 0xac000000;
 };
 
+class SampleProfileReaderItaniumRemapper : public SampleProfileReader {
+public:
+  SampleProfileReaderItaniumRemapper(
+      std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
+      std::unique_ptr<SampleProfileReader> Underlying)
+      : SampleProfileReader(std::move(B), C, Underlying->getFormat()) {
+    Profiles = std::move(Underlying->getProfiles());
+    Summary = takeSummary(*Underlying);
+  }
+
+  /// Create a remapped sample profile from the given remapping file and
+  /// underlying samples.
+  static ErrorOr<std::unique_ptr<SampleProfileReader>>
+  create(const Twine &Filename, LLVMContext &C,
+         std::unique_ptr<SampleProfileReader> Underlying);
+
+  /// Read and validate the file header.
+  std::error_code readHeader() override { return sampleprof_error::success; }
+
+  /// Read sample profiles from the associated file.
+  std::error_code read() override;
+
+  /// Return the samples collected for function \p F.
+  FunctionSamples *getSamplesFor(StringRef FunctionName) override;
+  using SampleProfileReader::getSamplesFor;
+
+private:
+  ItaniumProfileRemappingReader Remappings;
+  DenseMap<ItaniumManglingCanonicalizer::Key, FunctionSamples*> SampleMap;
+};
+
 } // end namespace sampleprof
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H

include/llvm/Transforms/IPO/SampleProfile.h

 
 namespace llvm {
 
 class Module;
 
 /// The sample profiler data loader pass.
 class SampleProfileLoaderPass : public PassInfoMixin<SampleProfileLoaderPass> {
 public:
-  SampleProfileLoaderPass(std::string File = "", bool IsThinLTOPreLink = false)
-      : ProfileFileName(File), IsThinLTOPreLink(IsThinLTOPreLink) {}
+  SampleProfileLoaderPass(std::string File = "", std::string RemappingFile = "",
+                          bool IsThinLTOPreLink = false)
+      : ProfileFileName(File), ProfileRemappingFileName(RemappingFile),
+        IsThinLTOPreLink(IsThinLTOPreLink) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
 private:
   std::string ProfileFileName;
+  std::string ProfileRemappingFileName;
   bool IsThinLTOPreLink;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SAMPLEPROFILE_H

include/llvm/Transforms/Instrumentation/PGOInstrumentation.h

 class PGOInstrumentationGen : public PassInfoMixin<PGOInstrumentationGen> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 
 /// The profile annotation (profile-instr-use) pass for IR based PGO.
 class PGOInstrumentationUse : public PassInfoMixin<PGOInstrumentationUse> {
 public:
-  PGOInstrumentationUse(std::string Filename = "");
+  PGOInstrumentationUse(std::string Filename = "",
+                        std::string RemappingFilename = "");
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
 private:
   std::string ProfileFileName;
+  std::string ProfileRemappingFileName;
 };
 
 /// The indirect function call promotion pass.
 class PGOIndirectCallPromotion : public PassInfoMixin<PGOIndirectCallPromotion> {
 public:
   PGOIndirectCallPromotion(bool IsInLTO = false, bool SamplePGO = false)
       : InLTO(IsInLTO), SamplePGO(SamplePGO) {}
 

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/Demangle/Canonicalize.h"
+
+#include "llvm/ADT/DenseMap.h"
+#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,
enum Kind : unsigned char {
     KVectorType,
     KParameterPack,
     KTemplateArgumentPack,
     KParameterPackExpansion,
     KTemplateArgs,
     KForwardTemplateReference,
     KNameWithTemplateArgs,
     KGlobalQualifiedName,
-    KStdQualifiedName,
     KExpandedSpecialSubstitution,
     KSpecialSubstitution,
     KCtorDtorName,
     KDtorName,
     KUnnamedTypeName,
     KClosureTypeName,
     KStructuredBindingName,
     KExpr,
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_) {}
 
-  StringView getBaseName() const override { return Child->getBaseName(); }
-
-  void printLeft(OutputStream &S) const override {
-    S += "::";
-    Child->print(S);
+#ifndef STANDALONE_DEMANGLER
+  static void profileCtor(llvm::FoldingSetNodeID &ID, Node *Child) {
+    Node::profileCtor(ID, KGlobalQualifiedName);
+    ID.AddPointer(Child);
   }
-};
-
-struct StdQualifiedName : Node {
-  Node *Child;
-
-  StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(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::";
+    S += "::";
     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 {