Index: include/llvm/Demangle/Canonicalize.h
===================================================================
--- /dev/null
+++ include/llvm/Demangle/Canonicalize.h
@@ -0,0 +1,88 @@
+//===--- 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
Index: include/llvm/LTO/Config.h
===================================================================
--- include/llvm/LTO/Config.h
+++ include/llvm/LTO/Config.h
@@ -73,6 +73,9 @@
   /// 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;
 
Index: include/llvm/Passes/PassBuilder.h
===================================================================
--- include/llvm/Passes/PassBuilder.h
+++ include/llvm/Passes/PassBuilder.h
@@ -32,10 +32,13 @@
 /// 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() ||
@@ -45,6 +48,7 @@
   std::string ProfileGenFile;
   std::string ProfileUseFile;
   std::string SampleProfileFile;
+  std::string ProfileRemappingFile;
   bool RunProfileGen;
   bool SamplePGOSupport;
 };
@@ -585,7 +589,8 @@
   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);
 
Index: include/llvm/ProfileData/InstrProfReader.h
===================================================================
--- include/llvm/ProfileData/InstrProfReader.h
+++ include/llvm/ProfileData/InstrProfReader.h
@@ -348,6 +348,9 @@
 using OnDiskHashTableImplV3 =
     OnDiskIterableChainedHashTable<InstrProfLookupTrait>;
 
+template<typename HashTableImpl>
+class InstrProfReaderItaniumRemapper;
+
 template <typename HashTableImpl>
 class InstrProfReaderIndex : public InstrProfReaderIndexBase {
 private:
@@ -355,6 +358,8 @@
   typename HashTableImpl::data_iterator RecordIterator;
   uint64_t FormatVersion;
 
+  friend class InstrProfReaderItaniumRemapper<HashTableImpl>;
+
 public:
   InstrProfReaderIndex(const unsigned char *Buckets,
                        const unsigned char *const Payload,
@@ -391,6 +396,8 @@
 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.
@@ -404,8 +411,11 @@
                                    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;
 
@@ -434,10 +444,11 @@
 
   /// 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: include/llvm/ProfileData/ProfRemappingReader.h
===================================================================
--- /dev/null
+++ include/llvm/ProfileData/ProfRemappingReader.h
@@ -0,0 +1,125 @@
+//===- 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
Index: include/llvm/ProfileData/SampleProfReader.h
===================================================================
--- include/llvm/ProfileData/SampleProfReader.h
+++ include/llvm/ProfileData/SampleProfReader.h
@@ -219,6 +219,7 @@
 #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"
@@ -287,11 +288,16 @@
     // 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;
   }
 
@@ -335,6 +341,12 @@
   /// 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();
 
@@ -503,6 +515,37 @@
   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
Index: include/llvm/Transforms/IPO/SampleProfile.h
===================================================================
--- include/llvm/Transforms/IPO/SampleProfile.h
+++ include/llvm/Transforms/IPO/SampleProfile.h
@@ -25,13 +25,16 @@
 /// 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;
 };
 
Index: include/llvm/Transforms/Instrumentation/PGOInstrumentation.h
===================================================================
--- include/llvm/Transforms/Instrumentation/PGOInstrumentation.h
+++ include/llvm/Transforms/Instrumentation/PGOInstrumentation.h
@@ -36,12 +36,14 @@
 /// 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.
Index: lib/Demangle/ItaniumDemangle.cpp
===================================================================
--- lib/Demangle/ItaniumDemangle.cpp
+++ lib/Demangle/ItaniumDemangle.cpp
@@ -11,10 +11,19 @@
 // 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>
@@ -26,6 +35,12 @@
 #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 {
@@ -64,7 +79,6 @@
     KForwardTemplateReference,
     KNameWithTemplateArgs,
     KGlobalQualifiedName,
-    KStdQualifiedName,
     KExpandedSpecialSubstitution,
     KSpecialSubstitution,
     KCtorDtorName,
@@ -100,6 +114,20 @@
       : 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;
@@ -171,6 +199,14 @@
   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; }
 
@@ -203,6 +239,17 @@
 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);
   }
@@ -213,9 +260,21 @@
   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 += " (";
@@ -229,9 +288,21 @@
   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 += " ";
@@ -271,11 +342,23 @@
   }
 
 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);
   }
@@ -298,9 +381,19 @@
   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);
@@ -315,6 +408,18 @@
   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;
@@ -327,6 +432,16 @@
 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; }
 
@@ -340,6 +455,18 @@
   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 += ' ';
@@ -356,6 +483,18 @@
              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:";
@@ -370,6 +509,16 @@
   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);
@@ -378,18 +527,30 @@
 };
 
 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 {
@@ -404,10 +565,20 @@
   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);
   }
@@ -469,10 +640,22 @@
   }
 
 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);
   }
@@ -506,10 +689,22 @@
   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);
   }
@@ -551,6 +746,18 @@
       : 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; }
@@ -568,22 +775,27 @@
 };
 
 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; }
@@ -604,21 +816,37 @@
 };
 
 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; }
 
@@ -660,9 +888,19 @@
 };
 
 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(";
@@ -677,6 +915,16 @@
   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);
@@ -685,31 +933,49 @@
 };
 
 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) {
@@ -748,7 +1014,18 @@
   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\"\" ";
@@ -761,9 +1038,21 @@
   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);
@@ -775,10 +1064,22 @@
   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);
@@ -794,6 +1095,18 @@
   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 {
@@ -810,6 +1123,18 @@
   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 += "::";
@@ -823,9 +1148,21 @@
   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 {
@@ -838,16 +1175,38 @@
 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[";
@@ -901,6 +1260,16 @@
       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;
@@ -947,6 +1316,16 @@
   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 {
@@ -960,9 +1339,19 @@
   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 {
@@ -1004,6 +1393,16 @@
 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 {
@@ -1030,6 +1429,16 @@
              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;
@@ -1077,6 +1486,18 @@
   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 {
@@ -1092,6 +1513,16 @@
   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 {
@@ -1100,19 +1531,6 @@
   }
 };
 
-struct StdQualifiedName : Node {
-  Node *Child;
-
-  StdQualifiedName(Node *Child_) : Node(KStdQualifiedName), Child(Child_) {}
-
-  StringView getBaseName() const override { return Child->getBaseName(); }
-
-  void printLeft(OutputStream &S) const override {
-    S += "std::";
-    Child->print(S);
-  }
-};
-
 enum class SpecialSubKind {
   allocator,
   basic_string,
@@ -1129,6 +1547,16 @@
   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:
@@ -1178,6 +1606,16 @@
   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:
@@ -1225,9 +1663,21 @@
   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 += "~";
@@ -1239,7 +1689,17 @@
   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 += "~";
@@ -1253,6 +1713,16 @@
 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;
@@ -1268,6 +1738,18 @@
   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;
@@ -1283,6 +1765,16 @@
   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);
@@ -1293,8 +1785,42 @@
 // -- 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;
@@ -1302,9 +1828,23 @@
   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.
@@ -1329,7 +1869,21 @@
   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 += "(";
@@ -1342,17 +1896,30 @@
 
 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;
   }
 };
 
@@ -1362,9 +1929,23 @@
   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);
@@ -1382,9 +1963,23 @@
   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;
@@ -1401,6 +1996,20 @@
   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);
@@ -1415,9 +2024,23 @@
   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 += "<";
@@ -1429,10 +2052,21 @@
 };
 
 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...(";
@@ -1447,7 +2081,21 @@
   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);
@@ -1470,6 +2118,23 @@
       : 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 ";
@@ -1501,6 +2166,20 @@
   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 += "::";
@@ -1516,7 +2195,21 @@
   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;
@@ -1532,6 +2225,17 @@
 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;
@@ -1546,6 +2250,19 @@
   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);
@@ -1556,10 +2273,23 @@
 };
 
 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)
@@ -1571,13 +2301,26 @@
 };
 
 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 += '[';
@@ -1594,13 +2337,26 @@
 };
 
 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);
@@ -1614,14 +2370,31 @@
 };
 
 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 += '(';
@@ -1666,7 +2439,18 @@
   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 ";
@@ -1680,6 +2464,17 @@
 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");
   }
@@ -1687,13 +2482,26 @@
 
 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);
@@ -1709,6 +2517,19 @@
 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 += "(";
@@ -1735,6 +2556,17 @@
 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;
@@ -1942,6 +2774,80 @@
   }
 };
 
+class DefaultAllocator {
+  BumpPointerAllocator Alloc;
+
+public:
+  void reset() { Alloc.reset(); }
+
+  template<typename T, typename ...Args> T *makeNode(Args &&...args) {
+    return new (Alloc.allocate(sizeof(T)))
+        T(std::forward<Args>(args)...);
+  }
+
+  void *allocateNodeArray(size_t sz) {
+    return Alloc.allocate(sizeof(Node *) * sz);
+  }
+};
+
+#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>
+  std::pair<T *, bool> makeNodeImpl(bool CreateNewNodes, Args &&...args) {
+    llvm::FoldingSetNodeID ID;
+    T::profileCtor(ID, args...);
+
+    void *InsertPos;
+    if (NodeHeader *Existing = Nodes.FindNodeOrInsertPos(ID, InsertPos))
+      return {static_cast<T*>(Existing->getNode()), false};
+
+    if (!CreateNewNodes)
+      return {nullptr, true};
+
+    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, true};
+  }
+
+  template<typename T, typename ...Args> T *makeNode(Args &&...args) {
+    return makeNodeImpl<T>(true, std::forward<Args>(args)...).first;
+  }
+
+  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 <>
+std::pair<ForwardTemplateReference *, bool>
+FoldingNodeAllocator::makeNodeImpl<ForwardTemplateReference, size_t&>(
+    bool, size_t &Index) {
+  return {new (RawAlloc.allocate(sizeof(ForwardTemplateReference)))
+              ForwardTemplateReference(Index),
+          true};
+}
+#endif
+
+template <typename Alloc = DefaultAllocator>
 struct Db {
   const char *First;
   const char *Last;
@@ -1972,7 +2878,7 @@
   bool PermitForwardTemplateReferences = false;
   bool ParsingLambdaParams = false;
 
-  BumpPointerAllocator ASTAllocator;
+  Alloc ASTAllocator;
 
   Db(const char *First_, const char *Last_) : First(First_), Last(Last_) {}
 
@@ -1988,14 +2894,13 @@
     ASTAllocator.reset();
   }
 
-  template <class T, class... Args> T *make(Args &&... args) {
-    return new (ASTAllocator.allocate(sizeof(T)))
-        T(std::forward<Args>(args)...);
+  template <class T, class... Args> Node *make(Args &&... args) {
+    return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
   }
 
   template <class It> NodeArray makeNodeArray(It begin, It end) {
     size_t sz = static_cast<size_t>(end - begin);
-    void *mem = ASTAllocator.allocate(sizeof(Node *) * sz);
+    void *mem = ASTAllocator.allocateNodeArray(sz);
     Node **data = new (mem) Node *[sz];
     std::copy(begin, end, data);
     return NodeArray(data, sz);
@@ -2132,7 +3037,7 @@
 //
 // <unscoped-template-name> ::= <unscoped-name>
 //                          ::= <substitution>
-Node *Db::parseName(NameState *State) {
+template<typename Alloc> Node *Db<Alloc>::parseName(NameState *State) {
   consumeIf('L'); // extension
 
   if (look() == 'N')
@@ -2173,7 +3078,7 @@
 // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
 //              := Z <function encoding> E s [<discriminator>]
 //              := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
-Node *Db::parseLocalName(NameState *State) {
+template<typename Alloc> Node *Db<Alloc>::parseLocalName(NameState *State) {
   if (!consumeIf('Z'))
     return nullptr;
   Node *Encoding = parseEncoding();
@@ -2182,7 +3087,8 @@
 
   if (consumeIf('s')) {
     First = parse_discriminator(First, Last);
-    return make<LocalName>(Encoding, make<NameType>("string literal"));
+    auto *StringLitName = make<NameType>("string literal");
+    return make<LocalName>(Encoding, StringLitName);
   }
 
   if (consumeIf('d')) {
@@ -2205,12 +3111,12 @@
 // <unscoped-name> ::= <unqualified-name>
 //                 ::= St <unqualified-name>   # ::std::
 // extension       ::= StL<unqualified-name>
-Node *Db::parseUnscopedName(NameState *State) {
+template<typename Alloc> Node *Db<Alloc>::parseUnscopedName(NameState *State) {
  if (consumeIf("StL") || consumeIf("St")) {
    Node *R = parseUnqualifiedName(State);
    if (R == nullptr)
      return nullptr;
-   return make<StdQualifiedName>(R);
+   return make<NestedName>(make<NameType>("std"), R);
  }
  return parseUnqualifiedName(State);
 }
@@ -2220,27 +3126,28 @@
 //                    ::= <source-name>
 //                    ::= <unnamed-type-name>
 //                    ::= DC <source-name>+ E      # structured binding declaration
-Node *Db::parseUnqualifiedName(NameState *State) {
- // <ctor-dtor-name>s are special-cased in parseNestedName().
- Node *Result;
- if (look() == 'U')
-   Result = parseUnnamedTypeName(State);
- else if (look() >= '1' && look() <= '9')
-   Result = parseSourceName(State);
- else if (consumeIf("DC")) {
-   size_t BindingsBegin = Names.size();
-   do {
-     Node *Binding = parseSourceName(State);
-     if (Binding == nullptr)
-       return nullptr;
-     Names.push_back(Binding);
-   } while (!consumeIf('E'));
-   Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
- } else
-   Result = parseOperatorName(State);
- if (Result != nullptr)
-   Result = parseAbiTags(Result);
- return Result;
+template<typename Alloc>
+Node *Db<Alloc>::parseUnqualifiedName(NameState *State) {
+  // <ctor-dtor-name>s are special-cased in parseNestedName().
+  Node *Result;
+  if (look() == 'U')
+    Result = parseUnnamedTypeName(State);
+  else if (look() >= '1' && look() <= '9')
+    Result = parseSourceName(State);
+  else if (consumeIf("DC")) {
+    size_t BindingsBegin = Names.size();
+    do {
+      Node *Binding = parseSourceName(State);
+      if (Binding == nullptr)
+        return nullptr;
+      Names.push_back(Binding);
+    } while (!consumeIf('E'));
+    Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
+  } else
+    Result = parseOperatorName(State);
+  if (Result != nullptr)
+    Result = parseAbiTags(Result);
+  return Result;
 }
 
 // <unnamed-type-name> ::= Ut [<nonnegative number>] _
@@ -2249,7 +3156,7 @@
 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
 //
 // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
-Node *Db::parseUnnamedTypeName(NameState *) {
+template<typename Alloc> Node *Db<Alloc>::parseUnnamedTypeName(NameState *) {
   if (consumeIf("Ut")) {
     StringView Count = parseNumber();
     if (!consumeIf('_'))
@@ -2278,7 +3185,7 @@
 }
 
 // <source-name> ::= <positive length number> <identifier>
-Node *Db::parseSourceName(NameState *) {
+template<typename Alloc> Node *Db<Alloc>::parseSourceName(NameState *) {
   size_t Length = 0;
   if (parsePositiveInteger(&Length))
     return nullptr;
@@ -2342,7 +3249,7 @@
 //                   ::= rS    # >>=
 //                   ::= ss    # <=> C++2a
 //                   ::= v <digit> <source-name>        # vendor extended operator
-Node *Db::parseOperatorName(NameState *State) {
+template<typename Alloc> Node *Db<Alloc>::parseOperatorName(NameState *State) {
   switch (look()) {
   case 'a':
     switch (look(1)) {
@@ -2585,7 +3492,8 @@
 //                  ::= D1  # complete object destructor
 //                  ::= D2  # base object destructor
 //   extension      ::= D5    # ?
-Node *Db::parseCtorDtorName(Node *&SoFar, NameState *State) {
+template<typename Alloc>
+Node *Db<Alloc>::parseCtorDtorName(Node *&SoFar, NameState *State) {
   if (SoFar->K == Node::KSpecialSubstitution) {
     auto SSK = static_cast<SpecialSubstitution *>(SoFar)->SSK;
     switch (SSK) {
@@ -2639,7 +3547,7 @@
 // <template-prefix> ::= <prefix> <template unqualified-name>
 //                   ::= <template-param>
 //                   ::= <substitution>
-Node *Db::parseNestedName(NameState *State) {
+template<typename Alloc> Node *Db<Alloc>::parseNestedName(NameState *State) {
   if (!consumeIf('N'))
     return nullptr;
 
@@ -2658,6 +3566,7 @@
     if (SoFar) SoFar = make<NestedName>(SoFar, Comp);
     else       SoFar = Comp;
     if (State) State->EndsWithTemplateArgs = false;
+    return SoFar != nullptr;
   };
 
   if (consumeIf("St"))
@@ -2678,7 +3587,8 @@
       Node *TP = parseTemplateParam();
       if (TP == nullptr)
         return nullptr;
-      PushComponent(TP);
+      if (!PushComponent(TP))
+        return nullptr;
       Subs.push_back(SoFar);
       continue;
     }
@@ -2699,7 +3609,8 @@
       Node *DT = parseDecltype();
       if (DT == nullptr)
         return nullptr;
-      PushComponent(DT);
+      if (!PushComponent(DT))
+        return nullptr;
       Subs.push_back(SoFar);
       continue;
     }
@@ -2709,7 +3620,8 @@
       Node *S = parseSubstitution();
       if (S == nullptr)
         return nullptr;
-      PushComponent(S);
+      if (!PushComponent(S))
+        return nullptr;
       if (SoFar != S)
         Subs.push_back(S);
       continue;
@@ -2722,7 +3634,8 @@
       Node *CtorDtor = parseCtorDtorName(SoFar, State);
       if (CtorDtor == nullptr)
         return nullptr;
-      PushComponent(CtorDtor);
+      if (!PushComponent(CtorDtor))
+        return nullptr;
       SoFar = parseAbiTags(SoFar);
       if (SoFar == nullptr)
         return nullptr;
@@ -2734,7 +3647,8 @@
     Node *N = parseUnqualifiedName(State);
     if (N == nullptr)
       return nullptr;
-    PushComponent(N);
+    if (!PushComponent(N))
+      return nullptr;
     Subs.push_back(SoFar);
   }
 
@@ -2746,7 +3660,7 @@
 }
 
 // <simple-id> ::= <source-name> [ <template-args> ]
-Node *Db::parseSimpleId() {
+template<typename Alloc> Node *Db<Alloc>::parseSimpleId() {
   Node *SN = parseSourceName(/*NameState=*/nullptr);
   if (SN == nullptr)
     return nullptr;
@@ -2761,7 +3675,7 @@
 
 // <destructor-name> ::= <unresolved-type>  # e.g., ~T or ~decltype(f())
 //                   ::= <simple-id>        # e.g., ~A<2*N>
-Node *Db::parseDestructorName() {
+template<typename Alloc> Node *Db<Alloc>::parseDestructorName() {
   Node *Result;
   if (std::isdigit(look()))
     Result = parseSimpleId();
@@ -2775,7 +3689,7 @@
 // <unresolved-type> ::= <template-param>
 //                   ::= <decltype>
 //                   ::= <substitution>
-Node *Db::parseUnresolvedType() {
+template<typename Alloc> Node *Db<Alloc>::parseUnresolvedType() {
   if (look() == 'T') {
     Node *TP = parseTemplateParam();
     if (TP == nullptr)
@@ -2800,7 +3714,7 @@
 //                        ::= on <operator-name> <template-args>         # unresolved operator template-id
 //                        ::= dn <destructor-name>                       # destructor or pseudo-destructor;
 //                                                                         # e.g. ~X or ~X<N-1>
-Node *Db::parseBaseUnresolvedName() {
+template<typename Alloc> Node *Db<Alloc>::parseBaseUnresolvedName() {
   if (std::isdigit(look()))
     return parseSimpleId();
 
@@ -2832,7 +3746,7 @@
 //  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+ E <base-unresolved-name>
 //
 // <unresolved-qualifier-level> ::= <simple-id>
-Node *Db::parseUnresolvedName() {
+template<typename Alloc> Node *Db<Alloc>::parseUnresolvedName() {
   Node *SoFar = nullptr;
 
   // srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
@@ -2847,6 +3761,8 @@
       if (TA == nullptr)
         return nullptr;
       SoFar = make<NameWithTemplateArgs>(SoFar, TA);
+      if (!SoFar)
+        return nullptr;
     }
 
     while (!consumeIf('E')) {
@@ -2854,6 +3770,8 @@
       if (Qual == nullptr)
         return nullptr;
       SoFar = make<QualifiedName>(SoFar, Qual);
+      if (!SoFar)
+        return nullptr;
     }
 
     Node *Base = parseBaseUnresolvedName();
@@ -2886,6 +3804,8 @@
         SoFar = make<GlobalQualifiedName>(Qual);
       else
         SoFar = Qual;
+      if (!SoFar)
+        return nullptr;
     } while (!consumeIf('E'));
   }
   //      sr <unresolved-type>                 <base-unresolved-name>
@@ -2900,6 +3820,8 @@
       if (TA == nullptr)
         return nullptr;
       SoFar = make<NameWithTemplateArgs>(SoFar, TA);
+      if (!SoFar)
+        return nullptr;
     }
   }
 
@@ -2913,18 +3835,21 @@
 
 // <abi-tags> ::= <abi-tag> [<abi-tags>]
 // <abi-tag> ::= B <source-name>
-Node *Db::parseAbiTags(Node *N) {
+template<typename Alloc> Node *Db<Alloc>::parseAbiTags(Node *N) {
   while (consumeIf('B')) {
     StringView SN = parseBareSourceName();
     if (SN.empty())
       return nullptr;
     N = make<AbiTagAttr>(N, SN);
+    if (!N)
+      return nullptr;
   }
   return N;
 }
 
 // <number> ::= [n] <non-negative decimal integer>
-StringView Db::parseNumber(bool AllowNegative) {
+template<typename Alloc>
+StringView Db<Alloc>::parseNumber(bool AllowNegative) {
   const char *Tmp = First;
   if (AllowNegative)
     consumeIf('n');
@@ -2936,7 +3861,7 @@
 }
 
 // <positive length number> ::= [0-9]*
-bool Db::parsePositiveInteger(size_t *Out) {
+template<typename Alloc> bool Db<Alloc>::parsePositiveInteger(size_t *Out) {
   *Out = 0;
   if (look() < '0' || look() > '9')
     return true;
@@ -2947,7 +3872,7 @@
   return false;
 }
 
-StringView Db::parseBareSourceName() {
+template<typename Alloc> StringView Db<Alloc>::parseBareSourceName() {
   size_t Int = 0;
   if (parsePositiveInteger(&Int) || numLeft() < Int)
     return StringView();
@@ -2964,17 +3889,21 @@
 //
 // <ref-qualifier> ::= R                   # & ref-qualifier
 // <ref-qualifier> ::= O                   # && ref-qualifier
-Node *Db::parseFunctionType() {
+template<typename Alloc> Node *Db<Alloc>::parseFunctionType() {
   Qualifiers CVQuals = parseCVQualifiers();
 
   Node *ExceptionSpec = nullptr;
   if (consumeIf("Do")) {
     ExceptionSpec = make<NameType>("noexcept");
+    if (!ExceptionSpec)
+      return nullptr;
   } else if (consumeIf("DO")) {
     Node *E = parseExpr();
     if (E == nullptr || !consumeIf('E'))
       return nullptr;
     ExceptionSpec = make<NoexceptSpec>(E);
+    if (!ExceptionSpec)
+      return nullptr;
   } else if (consumeIf("Dw")) {
     size_t SpecsBegin = Names.size();
     while (!consumeIf('E')) {
@@ -2985,6 +3914,8 @@
     }
     ExceptionSpec =
       make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
+    if (!ExceptionSpec)
+      return nullptr;
   }
 
   consumeIf("Dx"); // transaction safe
@@ -3027,7 +3958,7 @@
 //                         ::= Dv [<dimension expression>] _ <element type>
 // <extended element type> ::= <element type>
 //                         ::= p # AltiVec vector pixel
-Node *Db::parseVectorType() {
+template<typename Alloc> Node *Db<Alloc>::parseVectorType() {
   if (!consumeIf("Dv"))
     return nullptr;
   if (look() >= '1' && look() <= '9') {
@@ -3061,7 +3992,7 @@
 
 // <decltype>  ::= Dt <expression> E  # decltype of an id-expression or class member access (C++0x)
 //             ::= DT <expression> E  # decltype of an expression (C++0x)
-Node *Db::parseDecltype() {
+template<typename Alloc> Node *Db<Alloc>::parseDecltype() {
   if (!consumeIf('D'))
     return nullptr;
   if (!consumeIf('t') && !consumeIf('T'))
@@ -3076,7 +4007,7 @@
 
 // <array-type> ::= A <positive dimension number> _ <element type>
 //              ::= A [<dimension expression>] _ <element type>
-Node *Db::parseArrayType() {
+template<typename Alloc> Node *Db<Alloc>::parseArrayType() {
   if (!consumeIf('A'))
     return nullptr;
 
@@ -3109,7 +4040,7 @@
 }
 
 // <pointer-to-member-type> ::= M <class type> <member type>
-Node *Db::parsePointerToMemberType() {
+template<typename Alloc> Node *Db<Alloc>::parsePointerToMemberType() {
   if (!consumeIf('M'))
     return nullptr;
   Node *ClassType = parseType();
@@ -3125,7 +4056,7 @@
 //                   ::= Ts <name>  # dependent elaborated type specifier using 'struct' or 'class'
 //                   ::= Tu <name>  # dependent elaborated type specifier using 'union'
 //                   ::= Te <name>  # dependent elaborated type specifier using 'enum'
-Node *Db::parseClassEnumType() {
+template<typename Alloc> Node *Db<Alloc>::parseClassEnumType() {
   StringView ElabSpef;
   if (consumeIf("Ts"))
     ElabSpef = "struct";
@@ -3147,7 +4078,7 @@
 // <qualified-type>     ::= <qualifiers> <type>
 // <qualifiers> ::= <extended-qualifier>* <CV-qualifiers>
 // <extended-qualifier> ::= U <source-name> [<template-args>] # vendor extended type qualifier
-Node *Db::parseQualifiedType() {
+template<typename Alloc> Node *Db<Alloc>::parseQualifiedType() {
   if (consumeIf('U')) {
     StringView Qual = parseBareSourceName();
     if (Qual.empty())
@@ -3207,7 +4138,7 @@
 //
 // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 + <number of digits in k1> + k1
 // <objc-type> ::= <source-name>  # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
-Node *Db::parseType() {
+template<typename Alloc> Node *Db<Alloc>::parseType() {
   Node *Result = nullptr;
 
   if (TypeCallback != nullptr)
@@ -3534,14 +4465,14 @@
   return Result;
 }
 
-Node *Db::parsePrefixExpr(StringView Kind) {
+template<typename Alloc> Node *Db<Alloc>::parsePrefixExpr(StringView Kind) {
   Node *E = parseExpr();
   if (E == nullptr)
     return nullptr;
   return make<PrefixExpr>(Kind, E);
 }
 
-Node *Db::parseBinaryExpr(StringView Kind) {
+template<typename Alloc> Node *Db<Alloc>::parseBinaryExpr(StringView Kind) {
   Node *LHS = parseExpr();
   if (LHS == nullptr)
     return nullptr;
@@ -3551,7 +4482,7 @@
   return make<BinaryExpr>(LHS, Kind, RHS);
 }
 
-Node *Db::parseIntegerLiteral(StringView Lit) {
+template<typename Alloc> Node *Db<Alloc>::parseIntegerLiteral(StringView Lit) {
   StringView Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
     return make<IntegerExpr>(Lit, Tmp);
@@ -3559,7 +4490,7 @@
 }
 
 // <CV-Qualifiers> ::= [r] [V] [K]
-Qualifiers Db::parseCVQualifiers() {
+template<typename Alloc> Qualifiers Db<Alloc>::parseCVQualifiers() {
   Qualifiers CVR = QualNone;
   if (consumeIf('r'))
     addQualifiers(CVR, QualRestrict);
@@ -3574,7 +4505,7 @@
 //                  ::= fp <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L == 0, second and later parameters
 //                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _         # L > 0, first parameter
 //                  ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> <parameter-2 non-negative number> _   # L > 0, second and later parameters
-Node *Db::parseFunctionParam() {
+template<typename Alloc> Node *Db<Alloc>::parseFunctionParam() {
   if (consumeIf("fp")) {
     parseCVQualifiers();
     StringView Num = parseNumber();
@@ -3601,7 +4532,7 @@
 // [gs] na <expression>* _ <type> E                     # new[] (expr-list) type
 // [gs] na <expression>* _ <type> <initializer>         # new[] (expr-list) type (init)
 // <initializer> ::= pi <expression>* E                 # parenthesized initialization
-Node *Db::parseNewExpr() {
+template<typename Alloc> Node *Db<Alloc>::parseNewExpr() {
   bool Global = consumeIf("gs");
   bool IsArray = look(1) == 'a';
   if (!consumeIf("nw") && !consumeIf("na"))
@@ -3634,7 +4565,7 @@
 
 // cv <type> <expression>                               # conversion with one argument
 // cv <type> _ <expression>* E                          # conversion with a different number of arguments
-Node *Db::parseConversionExpr() {
+template<typename Alloc> Node *Db<Alloc>::parseConversionExpr() {
   if (!consumeIf("cv"))
     return nullptr;
   Node *Ty;
@@ -3670,7 +4601,7 @@
 //                ::= L <nullptr type> E                                 # nullptr literal (i.e., "LDnE")
 // FIXME:         ::= L <type> <real-part float> _ <imag-part float> E   # complex floating point literal (C 2000)
 //                ::= L <mangled-name> E                                 # external name
-Node *Db::parseExprPrimary() {
+template<typename Alloc> Node *Db<Alloc>::parseExprPrimary() {
   if (!consumeIf('L'))
     return nullptr;
   switch (look()) {
@@ -3764,7 +4695,7 @@
 //                     ::= di <field source-name> <braced-expression>    # .name = expr
 //                     ::= dx <index expression> <braced-expression>     # [expr] = expr
 //                     ::= dX <range begin expression> <range end expression> <braced-expression>
-Node *Db::parseBracedExpr() {
+template<typename Alloc> Node *Db<Alloc>::parseBracedExpr() {
   if (look() == 'd') {
     switch (look(1)) {
     case 'i': {
@@ -3810,7 +4741,7 @@
 //             ::= fR <binary-operator-name> <expression> <expression>
 //             ::= fl <binary-operator-name> <expression>
 //             ::= fr <binary-operator-name> <expression>
-Node *Db::parseFoldExpr() {
+template<typename Alloc> Node *Db<Alloc>::parseFoldExpr() {
   if (!consumeIf('f'))
     return nullptr;
 
@@ -3919,7 +4850,7 @@
 //              ::= fl <binary-operator-name> <expression>
 //              ::= fr <binary-operator-name> <expression>
 //              ::= <expr-primary>
-Node *Db::parseExpr() {
+template<typename Alloc> Node *Db<Alloc>::parseExpr() {
   bool Global = consumeIf("gs");
   if (numLeft() < 2)
     return nullptr;
@@ -4324,9 +5255,8 @@
           return nullptr;
         Names.push_back(Arg);
       }
-      return make<EnclosingExpr>(
-          "sizeof... (", make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin)),
-          ")");
+      auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
+      return make<EnclosingExpr>("sizeof... (", Pack, ")");
     }
     }
     return nullptr;
@@ -4394,7 +5324,7 @@
 //
 // <v-offset>  ::= <offset number> _ <virtual offset number>
 //               # virtual base override, with vcall offset
-bool Db::parseCallOffset() {
+template<typename Alloc> bool Db<Alloc>::parseCallOffset() {
   // Just scan through the call offset, we never add this information into the
   // output.
   if (consumeIf('h'))
@@ -4423,7 +5353,7 @@
 //                ::= GR <object name> <seq-id> _    # Subsequent temporaries
 //      extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
 //      extension ::= GR <object name> # reference temporary for object
-Node *Db::parseSpecialName() {
+template<typename Alloc> Node *Db<Alloc>::parseSpecialName() {
   switch (look()) {
   case 'T':
     switch (look(1)) {
@@ -4546,7 +5476,7 @@
 // <encoding> ::= <function name> <bare-function-type>
 //            ::= <data name>
 //            ::= <special-name>
-Node *Db::parseEncoding() {
+template<typename Alloc> Node *Db<Alloc>::parseEncoding() {
   if (look() == 'G' || look() == 'T')
     return parseSpecialName();
 
@@ -4646,7 +5576,9 @@
 
 constexpr const char *FloatData<long double>::spec;
 
-template <class Float> Node *Db::parseFloatingLiteral() {
+template<typename Alloc>
+template<class Float>
+Node *Db<Alloc>::parseFloatingLiteral() {
   const size_t N = FloatData<Float>::mangled_size;
   if (numLeft() <= N)
     return nullptr;
@@ -4661,7 +5593,7 @@
 }
 
 // <seq-id> ::= <0-9A-Z>+
-bool Db::parseSeqId(size_t *Out) {
+template<typename Alloc> bool Db<Alloc>::parseSeqId(size_t *Out) {
   if (!(look() >= '0' && look() <= '9') &&
       !(look() >= 'A' && look() <= 'Z'))
     return true;
@@ -4692,7 +5624,7 @@
 // <substitution> ::= Si # ::std::basic_istream<char,  std::char_traits<char> >
 // <substitution> ::= So # ::std::basic_ostream<char,  std::char_traits<char> >
 // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
-Node *Db::parseSubstitution() {
+template<typename Alloc> Node *Db<Alloc>::parseSubstitution() {
   if (!consumeIf('S'))
     return nullptr;
 
@@ -4726,6 +5658,8 @@
     default:
       return nullptr;
     }
+    if (!SpecialSub)
+      return nullptr;
     // Itanium C++ ABI 5.1.2: If a name that would use a built-in <substitution>
     // has ABI tags, the tags are appended to the substitution; the result is a
     // substitutable component.
@@ -4756,7 +5690,7 @@
 
 // <template-param> ::= T_    # first template parameter
 //                  ::= T <parameter-2 non-negative number> _
-Node *Db::parseTemplateParam() {
+template<typename Alloc> Node *Db<Alloc>::parseTemplateParam() {
   if (!consumeIf('T'))
     return nullptr;
 
@@ -4778,8 +5712,13 @@
   // <template-arg> further ahead in the mangled name (currently just conversion
   // operator types), then we should only look it up in the right context.
   if (PermitForwardTemplateReferences) {
-    ForwardTemplateRefs.push_back(make<ForwardTemplateReference>(Index));
-    return ForwardTemplateRefs.back();
+    Node *ForwardRef = make<ForwardTemplateReference>(Index);
+    if (!ForwardRef)
+      return nullptr;
+    assert(ForwardRef->getKind() == Node::KForwardTemplateReference);
+    ForwardTemplateRefs.push_back(
+        static_cast<ForwardTemplateReference *>(ForwardRef));
+    return ForwardRef;
   }
 
   if (Index >= TemplateParams.size())
@@ -4792,7 +5731,7 @@
 //                ::= <expr-primary>            # simple expressions
 //                ::= J <template-arg>* E       # argument pack
 //                ::= LZ <encoding> E           # extension
-Node *Db::parseTemplateArg() {
+template<typename Alloc> Node *Db<Alloc>::parseTemplateArg() {
   switch (look()) {
   case 'X': {
     ++First;
@@ -4832,7 +5771,8 @@
 
 // <template-args> ::= I <template-arg>* E
 //     extension, the abi says <template-arg>+
-Node *Db::parseTemplateArgs(bool TagTemplates) {
+template <typename Alloc>
+Node *Db<Alloc>::parseTemplateArgs(bool TagTemplates) {
   if (!consumeIf('I'))
     return nullptr;
 
@@ -4854,6 +5794,8 @@
       if (Arg->getKind() == Node::KTemplateArgumentPack) {
         TableEntry = make<ParameterPack>(
             static_cast<TemplateArgumentPack*>(TableEntry)->getElements());
+        if (!TableEntry)
+          return nullptr;
       }
       TemplateParams.push_back(TableEntry);
     } else {
@@ -4909,7 +5851,7 @@
 // extension      ::= ___Z <encoding> _block_invoke
 // extension      ::= ___Z <encoding> _block_invoke<decimal-digit>+
 // extension      ::= ___Z <encoding> _block_invoke_<decimal-digit>+
-Node *Db::parse() {
+template<typename Alloc> Node *Db<Alloc>::parse() {
   if (consumeIf("_Z")) {
     Node *Encoding = parseEncoding();
     if (Encoding == nullptr)
@@ -4969,7 +5911,7 @@
   }
 
   int InternalStatus = demangle_success;
-  Db Parser(MangledName, MangledName + std::strlen(MangledName));
+  Db<> Parser(MangledName, MangledName + std::strlen(MangledName));
   OutputStream S;
 
   Node *AST = Parser.parse();
@@ -4995,7 +5937,7 @@
 bool llvm::itaniumFindTypesInMangledName(const char *MangledName, void *Ctx,
                                          void (*Callback)(void *,
                                                           const char *)) {
-  Db Parser(MangledName, MangledName + std::strlen(MangledName));
+  Db<> Parser(MangledName, MangledName + std::strlen(MangledName));
   Parser.TypeCallback = Callback;
   Parser.TypeCallbackContext = Ctx;
   return Parser.parse() == nullptr;
@@ -5004,10 +5946,10 @@
 namespace llvm {
 
 ItaniumPartialDemangler::ItaniumPartialDemangler()
-    : RootNode(nullptr), Context(new Db{nullptr, nullptr}) {}
+    : RootNode(nullptr), Context(new Db<>{nullptr, nullptr}) {}
 
 ItaniumPartialDemangler::~ItaniumPartialDemangler() {
-  delete static_cast<Db *>(Context);
+  delete static_cast<Db<> *>(Context);
 }
 
 ItaniumPartialDemangler::ItaniumPartialDemangler(
@@ -5025,14 +5967,14 @@
 
 // Demangle MangledName into an AST, storing it into this->RootNode.
 bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
-  Db *Parser = static_cast<Db *>(Context);
+  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;
@@ -5047,24 +5989,21 @@
   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;
-      continue;
-    case Node::KStdQualifiedName:
-      Name = static_cast<StdQualifiedName *>(Name)->Child;
+      Name = static_cast<const AbiTagAttr *>(Name)->Base;
       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);
@@ -5076,7 +6015,7 @@
                                                           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))
@@ -5085,25 +6024,22 @@
  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;
@@ -5153,7 +6089,8 @@
   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';
@@ -5171,12 +6108,12 @@
   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:
@@ -5185,22 +6122,19 @@
       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;
-      break;
-    case Node::KStdQualifiedName:
-      N = static_cast<StdQualifiedName *>(N)->Child;
+      N = static_cast<const NestedName *>(N)->Name;
       break;
     }
   }
@@ -5209,16 +6143,161 @@
 
 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
+
+#ifndef STANDALONE_DEMANGLER
+namespace {
+class CanonicalizerAllocator : public FoldingNodeAllocator {
+  Node *MostRecentlyCreated = nullptr;
+  Node *TrackedNode = nullptr;
+  bool TrackedNodeIsUsed = false;
+  bool CreateNewNodes = true;
+  llvm::SmallDenseMap<Node*, Node*, 32> Remappings;
+
+public:
+  void reset() { MostRecentlyCreated = nullptr; }
+
+  void setCreateNewNodes(bool CNN) { CreateNewNodes = CNN; }
+
+  template<typename T, typename ...Args> Node *makeNode(Args &&...args) {
+    std::pair<Node *, bool> Result =
+        makeNodeImpl<T>(CreateNewNodes, std::forward<Args>(args)...);
+    if (Result.second) {
+      // Node is new. Make a note of that.
+      MostRecentlyCreated = Result.first;
+    } else if (Result.first) {
+      // Node is pre-existing; check if it's in our remapping table.
+      if (auto *N = Remappings.lookup(Result.first)) {
+        Result.first = N;
+        assert(Remappings.find(Result.first) == Remappings.end() &&
+               "should never need multiple remap steps");
+      }
+      if (Result.first == TrackedNode)
+        TrackedNodeIsUsed = true;
+    }
+    return Result.first;
+  }
+
+  void addRemapping(Node *A, Node *B) {
+    // Note, we don't need to check whether B is also remapped, because if it
+    // was we would have already remapped it when building it.
+    Remappings.insert(std::make_pair(A, B));
+  }
+
+  bool isMostRecentlyCreated(Node *N) const { return MostRecentlyCreated == N; }
+
+  void trackUsesOf(Node *N) {
+    TrackedNode = N;
+    TrackedNodeIsUsed = false;
+  }
+  bool trackedNodeIsUsed() const { return TrackedNodeIsUsed; }
+};
 }
+
+namespace llvm {
+struct ItaniumManglingCanonicalizer::Impl {
+  Db<CanonicalizerAllocator> Demangler = {nullptr, nullptr};
+};
+
+ItaniumManglingCanonicalizer::ItaniumManglingCanonicalizer() : P(new Impl) {}
+ItaniumManglingCanonicalizer::~ItaniumManglingCanonicalizer() { delete P; }
+
+ItaniumManglingCanonicalizer::EquivalenceError
+ItaniumManglingCanonicalizer::addEquivalence(FragmentKind Kind, StringRef First,
+                                             StringRef Second) {
+  auto &Alloc = P->Demangler.ASTAllocator;
+  Alloc.setCreateNewNodes(true);
+
+  auto Parse = [&](StringRef Str) {
+    P->Demangler.reset(Str.begin(), Str.end());
+    Node *N = nullptr;
+    switch (Kind) {
+      // A <name>, with minor extensions to allow arbitrary namespace and
+      // template names that can't easily be written as <name>s.
+    case FragmentKind::Name:
+      // Very special case: allow "St" as a shorthand for "3std". It's not
+      // valid as a <name> mangling, but is nonetheless the most natural
+      // way to name the 'std' namespace.
+      if (Str.size() == 2 && P->Demangler.consumeIf("St"))
+        N = P->Demangler.make<NameType>("std");
+      // We permit substitutions to name templates without their template
+      // arguments. This mostly just falls out, as almost all template names
+      // are valid as <name>s, but we also want to parse <substitution>s as
+      // <name>s, even though they're not.
+      else if (Str.startswith("S"))
+        // Parse the substitution and optional following template arguments.
+        N = P->Demangler.parseType();
+      else
+        N = P->Demangler.parseName();
+      break;
+
+      // A <type>.
+    case FragmentKind::Type:
+      N = P->Demangler.parseType();
+      break;
+
+      // An <encoding>.
+    case FragmentKind::Encoding:
+      N = P->Demangler.parseEncoding();
+      break;
+    }
+
+    // If we have trailing junk, the mangling is invalid.
+    if (P->Demangler.numLeft() != 0)
+      N = nullptr;
+
+    // If any node was created after N, then we cannot safely remap it because
+    // it might already be in use by another node.
+    return std::make_pair(N, Alloc.isMostRecentlyCreated(N));
+  };
+
+  Node *FirstNode, *SecondNode;
+  bool FirstIsNew, SecondIsNew;
+
+  std::tie(FirstNode, FirstIsNew) = Parse(First);
+  if (!FirstNode)
+    return EquivalenceError::InvalidFirstMangling;
+
+  Alloc.trackUsesOf(FirstNode);
+  std::tie(SecondNode, SecondIsNew) = Parse(Second);
+  if (!SecondNode)
+    return EquivalenceError::InvalidSecondMangling;
+
+  if (FirstIsNew && !Alloc.trackedNodeIsUsed())
+    Alloc.addRemapping(FirstNode, SecondNode);
+  else if (SecondIsNew)
+    Alloc.addRemapping(SecondNode, FirstNode);
+  else
+    return EquivalenceError::ManglingAlreadyUsed;
+
+  return EquivalenceError::Success;
+}
+
+ItaniumManglingCanonicalizer::Key
+ItaniumManglingCanonicalizer::canonicalize(StringRef Mangling) {
+  P->Demangler.ASTAllocator.setCreateNewNodes(true);
+  P->Demangler.reset(Mangling.begin(), Mangling.end());
+  return reinterpret_cast<Key>(P->Demangler.parse());
+}
+
+ItaniumManglingCanonicalizer::Key
+ItaniumManglingCanonicalizer::lookup(StringRef Mangling) {
+  P->Demangler.ASTAllocator.setCreateNewNodes(false);
+  P->Demangler.reset(Mangling.begin(), Mangling.end());
+  return reinterpret_cast<Key>(P->Demangler.parse());
+}
+} // namespace llvm
+#endif
Index: lib/LTO/LTO.cpp
===================================================================
--- lib/LTO/LTO.cpp
+++ lib/LTO/LTO.cpp
@@ -271,8 +271,15 @@
 
   if (!Conf.SampleProfile.empty()) {
     auto FileOrErr = MemoryBuffer::getFile(Conf.SampleProfile);
-    if (FileOrErr)
+    if (FileOrErr) {
       Hasher.update(FileOrErr.get()->getBuffer());
+
+      if (!Conf.ProfileRemapping.empty()) {
+        FileOrErr = MemoryBuffer::getFile(Conf.ProfileRemapping);
+        if (FileOrErr)
+          Hasher.update(FileOrErr.get()->getBuffer());
+      }
+    }
   }
 
   Key = toHex(Hasher.result());
Index: lib/LTO/LTOBackend.cpp
===================================================================
--- lib/LTO/LTOBackend.cpp
+++ lib/LTO/LTOBackend.cpp
@@ -149,7 +149,8 @@
                            const ModuleSummaryIndex *ImportSummary) {
   Optional<PGOOptions> PGOOpt;
   if (!Conf.SampleProfile.empty())
-    PGOOpt = PGOOptions("", "", Conf.SampleProfile, false, true);
+    PGOOpt = PGOOptions("", "", Conf.SampleProfile, Conf.ProfileRemapping,
+                        false, true);
 
   PassBuilder PB(TM, PGOOpt);
   AAManager AA;
Index: lib/Passes/PassBuilder.cpp
===================================================================
--- lib/Passes/PassBuilder.cpp
+++ lib/Passes/PassBuilder.cpp
@@ -493,7 +493,8 @@
                                     PassBuilder::OptimizationLevel Level,
                                     bool RunProfileGen,
                                     std::string ProfileGenFile,
-                                    std::string ProfileUseFile) {
+                                    std::string ProfileUseFile,
+                                    std::string ProfileRemappingFile) {
   // Generally running simplification passes and the inliner with an high
   // threshold results in smaller executables, but there may be cases where
   // the size grows, so let's be conservative here and skip this simplification
@@ -547,7 +548,7 @@
   }
 
   if (!ProfileUseFile.empty())
-    MPM.addPass(PGOInstrumentationUse(ProfileUseFile));
+    MPM.addPass(PGOInstrumentationUse(ProfileUseFile, ProfileRemappingFile));
 }
 
 static InlineParams
@@ -593,6 +594,7 @@
     // Annotate sample profile right after early FPM to ensure freshness of
     // the debug info.
     MPM.addPass(SampleProfileLoaderPass(PGOOpt->SampleProfileFile,
+                                        PGOOpt->ProfileRemappingFile,
                                         Phase == ThinLTOPhase::PreLink));
     // Do not invoke ICP in the ThinLTOPrelink phase as it makes it hard
     // for the profile annotation to be accurate in the ThinLTO backend.
@@ -642,7 +644,8 @@
   if (PGOOpt && Phase != ThinLTOPhase::PostLink &&
       (!PGOOpt->ProfileGenFile.empty() || !PGOOpt->ProfileUseFile.empty())) {
     addPGOInstrPasses(MPM, DebugLogging, Level, PGOOpt->RunProfileGen,
-                      PGOOpt->ProfileGenFile, PGOOpt->ProfileUseFile);
+                      PGOOpt->ProfileGenFile, PGOOpt->ProfileUseFile,
+                      PGOOpt->ProfileRemappingFile);
     MPM.addPass(PGOIndirectCallPromotion(false, false));
   }
 
Index: lib/ProfileData/CMakeLists.txt
===================================================================
--- lib/ProfileData/CMakeLists.txt
+++ lib/ProfileData/CMakeLists.txt
@@ -4,6 +4,7 @@
   InstrProfReader.cpp
   InstrProfWriter.cpp
   ProfileSummaryBuilder.cpp
+  ProfRemappingReader.cpp
   SampleProf.cpp
   SampleProfReader.cpp
   SampleProfWriter.cpp
Index: lib/ProfileData/InstrProfReader.cpp
===================================================================
--- lib/ProfileData/InstrProfReader.cpp
+++ lib/ProfileData/InstrProfReader.cpp
@@ -19,6 +19,7 @@
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/ProfileData/ProfileCommon.h"
+#include "llvm/ProfileData/ProfRemappingReader.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
@@ -88,16 +89,29 @@
 }
 
 Expected<std::unique_ptr<IndexedInstrProfReader>>
-IndexedInstrProfReader::create(const Twine &Path) {
+IndexedInstrProfReader::create(const Twine &Path, const Twine &RemappingPath) {
   // Set up the buffer to read.
   auto BufferOrError = setupMemoryBuffer(Path);
   if (Error E = BufferOrError.takeError())
     return std::move(E);
-  return IndexedInstrProfReader::create(std::move(BufferOrError.get()));
+
+  // Set up the remapping buffer if requested.
+  std::unique_ptr<MemoryBuffer> RemappingBuffer;
+  std::string RemappingPathStr = RemappingPath.str();
+  if (!RemappingPathStr.empty()) {
+    auto RemappingBufferOrError = setupMemoryBuffer(RemappingPathStr);
+    if (Error E = RemappingBufferOrError.takeError())
+      return std::move(E);
+    RemappingBuffer = std::move(RemappingBufferOrError.get());
+  }
+
+  return IndexedInstrProfReader::create(std::move(BufferOrError.get()),
+                                        std::move(RemappingBuffer));
 }
 
 Expected<std::unique_ptr<IndexedInstrProfReader>>
-IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
+IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer,
+                               std::unique_ptr<MemoryBuffer> RemappingBuffer) {
   // Sanity check the buffer.
   if (uint64_t(Buffer->getBufferSize()) > std::numeric_limits<unsigned>::max())
     return make_error<InstrProfError>(instrprof_error::too_large);
@@ -105,7 +119,8 @@
   // Create the reader.
   if (!IndexedInstrProfReader::hasFormat(*Buffer))
     return make_error<InstrProfError>(instrprof_error::bad_magic);
-  auto Result = llvm::make_unique<IndexedInstrProfReader>(std::move(Buffer));
+  auto Result = llvm::make_unique<IndexedInstrProfReader>(
+      std::move(Buffer), std::move(RemappingBuffer));
 
   // Initialize the reader and return the result.
   if (Error E = initializeReader(*Result))
@@ -587,6 +602,70 @@
   RecordIterator = HashTable->data_begin();
 }
 
+template<typename HashTableImpl>
+class llvm::InstrProfReaderItaniumRemapper : public InstrProfReaderIndexBase {
+public:
+  InstrProfReaderItaniumRemapper(
+      std::unique_ptr<MemoryBuffer> RemapBuffer,
+      std::unique_ptr<InstrProfReaderIndex<HashTableImpl>> Underlying)
+      : RemapBuffer(std::move(RemapBuffer)), Underlying(std::move(Underlying)) {
+  }
+
+  Error populateRemappings() {
+    if (Error E = Remappings.read(*RemapBuffer))
+      return E;
+    for (StringRef Name : Underlying->HashTable->keys()) {
+      if (auto Key = Remappings.remap(Name))
+        MappedNames.insert({Key, Name});
+    }
+    return Error::success();
+  }
+
+  Error getRecords(StringRef FuncName,
+                   ArrayRef<NamedInstrProfRecord> &Data) override {
+    if (auto Key = Remappings.lookup(FuncName)) {
+      StringRef Remapped = MappedNames.lookup(Key);
+      if (!Remapped.empty())
+        FuncName = Remapped;
+    }
+    return Underlying->getRecords(FuncName, Data);
+  }
+
+  Error getRecords(ArrayRef<NamedInstrProfRecord> &Data) override {
+    return Underlying->getRecords(Data);
+  }
+  void advanceToNextKey() override { return Underlying->advanceToNextKey(); }
+  bool atEnd() const override { return Underlying->atEnd(); }
+  void setValueProfDataEndianness(support::endianness Endianness) override {
+    return Underlying->setValueProfDataEndianness(Endianness);
+  }
+  uint64_t getVersion() const override {
+    return Underlying->getVersion();
+  }
+  bool isIRLevelProfile() const override {
+    return Underlying->isIRLevelProfile();
+  }
+  Error populateSymtab(InstrProfSymtab &Symtab) override {
+    return Underlying->populateSymtab(Symtab);
+  }
+
+private:
+  /// The memory buffer containing the remapping configuration. Remappings
+  /// holds pointers into this buffer.
+  std::unique_ptr<MemoryBuffer> RemapBuffer;
+
+  /// The mangling remapper.
+  ItaniumProfileRemappingReader Remappings;
+
+  /// Mapping from mangled name keys to the name used for the key in the
+  /// profile data.
+  /// FIXME: Can we store a hashtable iterator instead of redoing lookup?
+  llvm::DenseMap<ItaniumProfileRemappingReader::Key, StringRef> MappedNames;
+
+  /// The real profile data reader.
+  std::unique_ptr<InstrProfReaderIndex<HashTableImpl>> Underlying;
+};
+
 bool IndexedInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
   using namespace support;
 
@@ -683,10 +762,22 @@
   uint64_t HashOffset = endian::byte_swap<uint64_t, little>(Header->HashOffset);
 
   // The rest of the file is an on disk hash table.
-  InstrProfReaderIndexBase *IndexPtr = nullptr;
-  IndexPtr = new InstrProfReaderIndex<OnDiskHashTableImplV3>(
-      Start + HashOffset, Cur, Start, HashType, FormatVersion);
-  Index.reset(IndexPtr);
+  auto IndexPtr =
+      llvm::make_unique<InstrProfReaderIndex<OnDiskHashTableImplV3>>(
+          Start + HashOffset, Cur, Start, HashType, FormatVersion);
+
+  // Load the remapping table now if requested.
+  if (RemappingBuffer) {
+    auto Remapper = llvm::make_unique<
+        InstrProfReaderItaniumRemapper<OnDiskHashTableImplV3>>(
+        std::move(RemappingBuffer), std::move(IndexPtr));
+    if (Error E = Remapper->populateRemappings())
+      return E;
+    Index = std::move(Remapper);
+  } else {
+    Index = std::move(IndexPtr);
+  }
+
   return success();
 }
 
Index: lib/ProfileData/ProfRemappingReader.cpp
===================================================================
--- /dev/null
+++ lib/ProfileData/ProfRemappingReader.cpp
@@ -0,0 +1,83 @@
+//===- ProfRemappingReader.cpp - Read profile remapping file --------------===//
+//
+//                      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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ProfileData/ProfRemappingReader.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/Support/LineIterator.h"
+
+using namespace llvm;
+
+char ProfileRemappingParseError::ID;
+
+/// Load a set of name remappings from a text file.
+///
+/// See the documentation at the top of the file for an explanation of
+/// the expected format.
+Error ItaniumProfileRemappingReader::read(MemoryBuffer &B) {
+  line_iterator LineIt(B, /*SkipBlanks=*/true, '#');
+
+  auto ReportError = [&](Twine Msg) {
+    return llvm::make_error<ProfileRemappingParseError>(
+        B.getBufferIdentifier(), LineIt.line_number(), Msg);
+  };
+
+  for (; !LineIt.is_at_eof(); ++LineIt) {
+    StringRef Line = *LineIt;
+    Line = Line.ltrim(' ');
+    // line_iterator only detects comments starting in column 1.
+    if (Line.startswith("#") || Line.empty())
+      continue;
+
+    SmallVector<StringRef, 4> Parts;
+    Line.split(Parts, ' ', /*MaxSplits*/-1, /*KeepEmpty*/false);
+
+    if (Parts.size() != 3)
+      return ReportError("Expected 'kind mangled_name mangled_name', "
+                         "found '" + Line + "'");
+
+    using FK = ItaniumManglingCanonicalizer::FragmentKind;
+    Optional<FK> FragmentKind = StringSwitch<Optional<FK>>(Parts[0])
+                                    .Case("name", FK::Name)
+                                    .Case("type", FK::Type)
+                                    .Case("encoding", FK::Encoding)
+                                    .Default(None);
+    if (!FragmentKind)
+      return ReportError("Invalid kind, expected 'name', 'type', or 'encoding',"
+                         " found '" + Parts[0] + "'");
+
+    using EE = ItaniumManglingCanonicalizer::EquivalenceError;
+    switch (Canonicalizer.addEquivalence(*FragmentKind, Parts[1], Parts[2])) {
+    case EE::Success:
+      break;
+
+    case EE::ManglingAlreadyUsed:
+      return ReportError("Manglings '" + Parts[1] + "' and '" + Parts[2] + "' "
+                         "have both been used in prior remappings. Move this "
+                         "remapping earlier in the file.");
+
+    case EE::InvalidFirstMangling:
+      return ReportError("Could not demangle '" + Parts[1] + "' "
+                         "as a <" + Parts[0] + ">; invalid mangling?");
+
+    case EE::InvalidSecondMangling:
+      return ReportError("Could not demangle '" + Parts[2] + "' "
+                         "as a <" + Parts[0] + ">; invalid mangling?");
+    }
+  }
+
+  return Error::success();
+}
Index: lib/ProfileData/SampleProfReader.cpp
===================================================================
--- lib/ProfileData/SampleProfReader.cpp
+++ lib/ProfileData/SampleProfReader.cpp
@@ -827,6 +827,40 @@
   return Magic == "adcg*704";
 }
 
+std::error_code SampleProfileReaderItaniumRemapper::read() {
+  // If the underlying data is in compact format, we can't remap it because
+  // we don't know what the original function names were.
+  if (getFormat() == SPF_Compact_Binary) {
+    Ctx.diagnose(DiagnosticInfoSampleProfile(
+        Buffer->getBufferIdentifier(),
+        "Profile data remapping cannot be applied to profile data "
+        "in compact format (original mangled names are not available).",
+        DS_Warning));
+    return sampleprof_error::success;
+  }
+
+  if (Error E = Remappings.read(*Buffer)) {
+    handleAllErrors(
+        std::move(E), [&](const ProfileRemappingParseError &ParseError) {
+          reportError(ParseError.getLineNum(), ParseError.getMessage());
+        });
+    return sampleprof_error::malformed;
+  }
+
+  for (auto &Sample : getProfiles())
+    if (auto Key = Remappings.remap(Sample.first()))
+      SampleMap.insert({Key, &Sample.second});
+
+  return sampleprof_error::success;
+}
+
+FunctionSamples *
+SampleProfileReaderItaniumRemapper::getSamplesFor(StringRef Fname) {
+  if (auto Key = Remappings.lookup(Fname))
+    return SampleMap.lookup(Key);
+  return SampleProfileReader::getSamplesFor(Fname);
+}
+
 /// Prepare a memory buffer for the contents of \p Filename.
 ///
 /// \returns an error code indicating the status of the buffer.
@@ -859,6 +893,27 @@
   return create(BufferOrError.get(), C);
 }
 
+/// Create a sample profile remapper from the given input, to remap the
+/// function names in the given profile data.
+///
+/// \param Filename The file to open.
+///
+/// \param C The LLVM context to use to emit diagnostics.
+///
+/// \param Underlying The underlying profile data reader to remap.
+///
+/// \returns an error code indicating the status of the created reader.
+ErrorOr<std::unique_ptr<SampleProfileReader>>
+SampleProfileReaderItaniumRemapper::create(
+    const Twine &Filename, LLVMContext &C,
+    std::unique_ptr<SampleProfileReader> Underlying) {
+  auto BufferOrError = setupMemoryBuffer(Filename);
+  if (std::error_code EC = BufferOrError.getError())
+    return EC;
+  return llvm::make_unique<SampleProfileReaderItaniumRemapper>(
+      std::move(BufferOrError.get()), C, std::move(Underlying));
+}
+
 /// Create a sample profile reader based on the format of the input data.
 ///
 /// \param B The memory buffer to create the reader from (assumes ownership).
Index: lib/Transforms/IPO/SampleProfile.cpp
===================================================================
--- lib/Transforms/IPO/SampleProfile.cpp
+++ lib/Transforms/IPO/SampleProfile.cpp
@@ -96,6 +96,10 @@
     "sample-profile-file", cl::init(""), cl::value_desc("filename"),
     cl::desc("Profile file loaded by -sample-profile"), cl::Hidden);
 
+static cl::opt<std::string> SampleProfileRemappingFile(
+    "sample-profile-remapping-file", cl::init(""), cl::value_desc("filename"),
+    cl::desc("Profile remapping file loaded by -sample-profile"), cl::Hidden);
+
 static cl::opt<unsigned> SampleProfileMaxPropagateIterations(
     "sample-profile-max-propagate-iterations", cl::init(100),
     cl::desc("Maximum number of iterations to go through when propagating "
@@ -183,12 +187,12 @@
 class SampleProfileLoader {
 public:
   SampleProfileLoader(
-      StringRef Name, bool IsThinLTOPreLink,
+      StringRef Name, StringRef RemapName, bool IsThinLTOPreLink,
       std::function<AssumptionCache &(Function &)> GetAssumptionCache,
       std::function<TargetTransformInfo &(Function &)> GetTargetTransformInfo)
       : GetAC(std::move(GetAssumptionCache)),
         GetTTI(std::move(GetTargetTransformInfo)), Filename(Name),
-        IsThinLTOPreLink(IsThinLTOPreLink) {}
+        RemappingFilename(RemapName), IsThinLTOPreLink(IsThinLTOPreLink) {}
 
   bool doInitialization(Module &M);
   bool runOnModule(Module &M, ModuleAnalysisManager *AM,
@@ -282,6 +286,9 @@
   /// Name of the profile file to load.
   std::string Filename;
 
+  /// Name of the profile remapping file to load.
+  std::string RemappingFilename;
+
   /// Flag indicating whether the profile input loaded successfully.
   bool ProfileIsValid = false;
 
@@ -311,13 +318,14 @@
 
   SampleProfileLoaderLegacyPass(StringRef Name = SampleProfileFile,
                                 bool IsThinLTOPreLink = false)
-      : ModulePass(ID), SampleLoader(Name, IsThinLTOPreLink,
-                                     [&](Function &F) -> AssumptionCache & {
-                                       return ACT->getAssumptionCache(F);
-                                     },
-                                     [&](Function &F) -> TargetTransformInfo & {
-                                       return TTIWP->getTTI(F);
-                                     }) {
+      : ModulePass(ID),
+        SampleLoader(Name, SampleProfileRemappingFile, IsThinLTOPreLink,
+                     [&](Function &F) -> AssumptionCache & {
+                       return ACT->getAssumptionCache(F);
+                     },
+                     [&](Function &F) -> TargetTransformInfo & {
+                       return TTIWP->getTTI(F);
+                     }) {
     initializeSampleProfileLoaderLegacyPassPass(
         *PassRegistry::getPassRegistry());
   }
@@ -1520,11 +1528,23 @@
   }
   Reader = std::move(ReaderOrErr.get());
   ProfileIsValid = (Reader->read() == sampleprof_error::success);
+
+  if (!RemappingFilename.empty()) {
+    ReaderOrErr = SampleProfileReaderItaniumRemapper::create(
+        RemappingFilename, Ctx, std::move(Reader));
+    if (std::error_code EC = ReaderOrErr.getError()) {
+      std::string Msg = "Could not open profile remapping file: " + EC.message();
+      Ctx.diagnose(DiagnosticInfoSampleProfile(Filename, Msg));
+      return false;
+    }
+    Reader = std::move(ReaderOrErr.get());
+    ProfileIsValid = (Reader->read() == sampleprof_error::success);
+  }
   return true;
 }
 
 ModulePass *llvm::createSampleProfileLoaderPass() {
-  return new SampleProfileLoaderLegacyPass(SampleProfileFile);
+  return new SampleProfileLoaderLegacyPass();
 }
 
 ModulePass *llvm::createSampleProfileLoaderPass(StringRef Name) {
@@ -1616,6 +1636,8 @@
 
   SampleProfileLoader SampleLoader(
       ProfileFileName.empty() ? SampleProfileFile : ProfileFileName,
+      ProfileRemappingFileName.empty() ? SampleProfileRemappingFile
+                                       : ProfileRemappingFileName,
       IsThinLTOPreLink, GetAssumptionCache, GetTTI);
 
   SampleLoader.doInitialization(M);
Index: lib/Transforms/Instrumentation/PGOInstrumentation.cpp
===================================================================
--- lib/Transforms/Instrumentation/PGOInstrumentation.cpp
+++ lib/Transforms/Instrumentation/PGOInstrumentation.cpp
@@ -141,6 +141,11 @@
                        cl::value_desc("filename"),
                        cl::desc("Specify the path of profile data file. This is"
                                 "mainly for test purpose."));
+static cl::opt<std::string> PGOTestProfileRemappingFile(
+    "pgo-test-profile-remapping-file", cl::init(""), cl::Hidden,
+    cl::value_desc("filename"),
+    cl::desc("Specify the path of profile remapping file. This is mainly for "
+             "test purpose."));
 
 // Command line option to disable value profiling. The default is false:
 // i.e. value profiling is enabled by default. This is for debug purpose.
@@ -1429,13 +1434,14 @@
 }
 
 static bool annotateAllFunctions(
-    Module &M, StringRef ProfileFileName,
+    Module &M, StringRef ProfileFileName, StringRef ProfileRemappingFileName,
     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
   LLVM_DEBUG(dbgs() << "Read in profile counters: ");
   auto &Ctx = M.getContext();
   // Read the counter array from file.
-  auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName);
+  auto ReaderOrErr =
+      IndexedInstrProfReader::create(ProfileFileName, ProfileRemappingFileName);
   if (Error E = ReaderOrErr.takeError()) {
     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
       Ctx.diagnose(
@@ -1529,10 +1535,14 @@
   return true;
 }
 
-PGOInstrumentationUse::PGOInstrumentationUse(std::string Filename)
-    : ProfileFileName(std::move(Filename)) {
+PGOInstrumentationUse::PGOInstrumentationUse(std::string Filename,
+                                             std::string RemappingFilename)
+    : ProfileFileName(std::move(Filename)),
+      ProfileRemappingFileName(std::move(RemappingFilename)) {
   if (!PGOTestProfileFile.empty())
     ProfileFileName = PGOTestProfileFile;
+  if (!PGOTestProfileRemappingFile.empty())
+    ProfileRemappingFileName = PGOTestProfileRemappingFile;
 }
 
 PreservedAnalyses PGOInstrumentationUse::run(Module &M,
@@ -1547,7 +1557,8 @@
     return &FAM.getResult<BlockFrequencyAnalysis>(F);
   };
 
-  if (!annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI))
+  if (!annotateAllFunctions(M, ProfileFileName, ProfileRemappingFileName,
+                            LookupBPI, LookupBFI))
     return PreservedAnalyses::all();
 
   return PreservedAnalyses::none();
@@ -1564,7 +1575,7 @@
     return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
   };
 
-  return annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI);
+  return annotateAllFunctions(M, ProfileFileName, "", LookupBPI, LookupBFI);
 }
 
 static std::string getSimpleNodeName(const BasicBlock *Node) {
Index: test/Transforms/PGOProfile/Inputs/remap.map
===================================================================
--- /dev/null
+++ test/Transforms/PGOProfile/Inputs/remap.map
@@ -0,0 +1,8 @@
+# foo:: and foo::detail:: are equivalent
+name 3foo N3foo6detailE
+
+# foo::qux and foo::quux are equivalent
+type N3foo3quxE N3foo4quuxE
+
+# N::X and M::X are equivalent
+name N1N1XE N1M1XE
Index: test/Transforms/PGOProfile/Inputs/remap.proftext
===================================================================
--- /dev/null
+++ test/Transforms/PGOProfile/Inputs/remap.proftext
@@ -0,0 +1,8 @@
+# :ir is the flag to indicate this is IR level profile.
+:ir
+_ZN3foo3barERKN1N1XINS_4quuxEEE
+25571299074
+2
+3
+2
+
Index: test/Transforms/PGOProfile/remap.ll
===================================================================
--- /dev/null
+++ test/Transforms/PGOProfile/remap.ll
@@ -0,0 +1,28 @@
+; RUN: llvm-profdata merge %S/Inputs/remap.proftext -o %t.profdata
+; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -pgo-test-profile-remapping-file=%S/Inputs/remap.map -S | FileCheck %s --check-prefix=USE
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define i32 @_ZN3foo3barERKN1M1XINS_6detail3quxEEE(i32 %i) {
+; USE-LABEL: @_ZN3foo3barERKN1M1XINS_6detail3quxEEE
+; USE-SAME: !prof ![[FUNC_ENTRY_COUNT:[0-9]+]]
+entry:
+  %cmp = icmp sgt i32 %i, 0
+  br i1 %cmp, label %if.then, label %if.end
+; USE: br i1 %cmp, label %if.then, label %if.end
+; USE-SAME: !prof ![[BW_ENTRY:[0-9]+]]
+
+if.then:
+  %add = add nsw i32 %i, 2
+  br label %if.end
+
+if.end:
+  %retv = phi i32 [ %add, %if.then ], [ %i, %entry ]
+  ret i32 %retv
+}
+
+; USE-DAG: {{![0-9]+}} = !{i32 1, !"ProfileSummary", {{![0-9]+}}}
+; USE-DAG: {{![0-9]+}} = !{!"DetailedSummary", {{![0-9]+}}}
+; USE-DAG: ![[FUNC_ENTRY_COUNT]] = !{!"function_entry_count", i64 3}
+; USE-DAG: ![[BW_ENTRY]] = !{!"branch_weights", i32 2, i32 1}
Index: test/Transforms/SampleProfile/Inputs/remap.map
===================================================================
--- /dev/null
+++ test/Transforms/SampleProfile/Inputs/remap.map
@@ -0,0 +1,8 @@
+# foo:: and foo::detail:: are equivalent
+name 3foo N3foo6detailE
+
+# foo::qux and foo::quux are equivalent
+type N3foo3quxE N3foo4quuxE
+
+# N::X and M::X are equivalent
+name N1N1XE N1M1XE
Index: test/Transforms/SampleProfile/Inputs/remap.prof
===================================================================
--- /dev/null
+++ test/Transforms/SampleProfile/Inputs/remap.prof
@@ -0,0 +1,10 @@
+_ZN3foo3barERKN1N1XINS_4quuxEEE:15680:2500
+ 1: 2500
+ 4: 1000
+ 5: 1000
+ 6: 800
+ 7: 500
+ 9: 10226
+ 10: 2243
+ 16: 0
+ 18: 0
Index: test/Transforms/SampleProfile/remap.ll
===================================================================
--- /dev/null
+++ test/Transforms/SampleProfile/remap.ll
@@ -0,0 +1,60 @@
+; RUN: opt %s -passes=sample-profile -sample-profile-file=%S/Inputs/remap.prof -sample-profile-remapping-file=%S/Inputs/remap.map | opt -analyze -branch-prob | FileCheck %s
+
+; Reduced from branch.ll
+
+declare i1 @foo()
+
+define void @_ZN3foo3barERKN1M1XINS_6detail3quxEEE() !dbg !2 {
+; CHECK: Printing analysis 'Branch Probability Analysis' for function '_ZN3foo3barERKN1M1XINS_6detail3quxEEE':
+
+entry:
+  %cmp = call i1 @foo(), !dbg !6
+  br i1 %cmp, label %if.then, label %if.end
+; CHECK:  edge entry -> if.then probability is 0x4ccf6b16 / 0x80000000 = 60.01%
+; CHECK:  edge entry -> if.end probability is 0x333094ea / 0x80000000 = 39.99%
+
+if.then:
+  br label %return
+
+if.end:
+  %cmp1 = call i1 @foo(), !dbg !7
+  br i1 %cmp1, label %if.then.2, label %if.else
+; CHECK: edge if.end -> if.then.2 probability is 0x6652c748 / 0x80000000 = 79.94%
+; CHECK: edge if.end -> if.else probability is 0x19ad38b8 / 0x80000000 = 20.06%
+
+if.then.2:
+  call i1 @foo(), !dbg !8
+  br label %for.cond
+
+for.cond:
+  %cmp5 = call i1 @foo()
+  br i1 %cmp5, label %for.body, label %for.end, !prof !9
+; CHECK: edge for.cond -> for.body probability is 0x73333333 / 0x80000000 = 90.00%
+; CHECK: edge for.cond -> for.end probability is 0x0ccccccd / 0x80000000 = 10.00%
+
+for.body:
+  br label %for.cond
+
+for.end:
+  br label %return
+
+if.else:
+  br label %return
+
+return:
+  ret void
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!4, !5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "foo++", isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug, enums: !{}, retainedTypes: !{})
+!1 = !DIFile(filename: "test.cc", directory: "/foo/bar")
+!2 = distinct !DISubprogram(name: "_ZN3foo3barERKN1M1XINS_6detail3quxEEE", scope: !1, file: !1, line: 4, type: !3, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !{})
+!3 = !DISubroutineType(types: !{})
+!4 = !{i32 2, !"Dwarf Version", i32 4}
+!5 = !{i32 2, !"Debug Info Version", i32 3}
+!6 = !DILocation(line: 5, column: 8, scope: !2)
+!7 = !DILocation(line: 8, column: 6, scope: !2)
+!8 = !DILocation(line: 10, column: 11, scope: !2)
+!9 = !{!"branch_weights", i32 90, i32 10}
Index: tools/opt/NewPMDriver.cpp
===================================================================
--- tools/opt/NewPMDriver.cpp
+++ tools/opt/NewPMDriver.cpp
@@ -107,6 +107,10 @@
                           "Use sampled profile to guide PGO.")));
 static cl::opt<std::string> ProfileFile(
     "profile-file", cl::desc("Path to the profile."), cl::Hidden);
+static cl::opt<std::string>
+    ProfileRemappingFile("profile-remapping-file",
+                         cl::desc("Path to the profile remapping file."),
+                         cl::Hidden);
 static cl::opt<bool> DebugInfoForProfiling(
     "new-pm-debug-info-for-profiling", cl::init(false), cl::Hidden,
     cl::desc("Emit special debug info to enable PGO profile generation."));
@@ -199,17 +203,17 @@
   Optional<PGOOptions> P;
   switch (PGOKindFlag) {
     case InstrGen:
-      P = PGOOptions(ProfileFile, "", "", true);
+      P = PGOOptions(ProfileFile, "", "", "", true);
       break;
     case InstrUse:
-      P = PGOOptions("", ProfileFile, "", false);
+      P = PGOOptions("", ProfileFile, "", ProfileRemappingFile, false);
       break;
     case SampleUse:
-      P = PGOOptions("", "", ProfileFile, false);
+      P = PGOOptions("", "", ProfileFile, ProfileRemappingFile, false);
       break;
     case NoPGO:
       if (DebugInfoForProfiling)
-        P = PGOOptions("", "", "", false, true);
+        P = PGOOptions("", "", "", "", false, true);
       else
         P = None;
   }
Index: unittests/Demangle/CMakeLists.txt
===================================================================
--- unittests/Demangle/CMakeLists.txt
+++ unittests/Demangle/CMakeLists.txt
@@ -3,6 +3,7 @@
 )
 
 add_llvm_unittest(DemangleTests
+  CanonicalizeTest.cpp
   PartialDemangleTest.cpp
   FindTypesInMangledNameTest.cpp
 )
Index: unittests/Demangle/CanonicalizeTest.cpp
===================================================================
--- /dev/null
+++ unittests/Demangle/CanonicalizeTest.cpp
@@ -0,0 +1,288 @@
+//===----------------------- CanonicalizeTest.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstdlib>
+#include <map>
+#include "llvm/Demangle/Canonicalize.h"
+#include "gtest/gtest.h"
+
+using EquivalenceError = llvm::ItaniumManglingCanonicalizer::EquivalenceError;
+using FragmentKind = llvm::ItaniumManglingCanonicalizer::FragmentKind;
+
+struct Equivalence {
+  FragmentKind Kind;
+  llvm::StringRef First;
+  llvm::StringRef Second;
+};
+
+// A set of manglings that should all be considered equivalent.
+using EquivalenceClass = std::initializer_list<llvm::StringRef>;
+
+struct Testcase {
+  // A set of equivalences to register.
+  std::initializer_list<Equivalence> Equivalences;
+  // A set of distinct equivalence classes created by registering the
+  // equivalences.
+  std::initializer_list<EquivalenceClass> Classes;
+};
+
+static std::initializer_list<Testcase> Testcases = {
+  // Three different manglings for std::string (old libstdc++, new libstdc++,
+  // libc++).
+  {
+    {
+      {FragmentKind::Type, "Ss",
+       "NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE"},
+      {FragmentKind::Type, "Ss",
+       "NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+    },
+    {
+      {"_Z1fv"},
+      {"_Z1fSs",
+       "_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
+       "_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+      {"_ZNKSs4sizeEv",
+       "_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv",
+       "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4sizeEv"},
+    }
+  },
+
+  // Check that substitutions are properly handled.
+  {
+    {
+      // ::X <-> ::N::X<int>
+      {FragmentKind::Type, "1X", "N1N1XIiEE"},
+      // ::T<T<int, int>, T<int, int>> <-> T<int>
+      {FragmentKind::Type, "1TIS_IiiES0_E", "1TIiE"},
+      // A::B::foo <-> AB::foo
+      {FragmentKind::Name, "N1A1B3fooE", "N2AB3fooE"},
+    },
+    {
+      {"_Z1f1XPS_RS_", "_Z1fN1N1XIiEEPS1_RS1_"},
+      {"_ZN1A1B3fooE1TIS1_IiiES2_EPS3_RS3_", "_ZN2AB3fooE1TIiEPS1_RS1_"},
+    }
+  },
+
+  // Check that nested equivalences are properly handled.
+  {
+    {
+      // std::__1::char_traits == std::__cxx11::char_traits
+      // (Note that this is unused and should make no difference,
+      // but it should not cause us to fail to match up the cases
+      // below.)
+      {FragmentKind::Name,
+       "NSt3__111char_traitsE",
+       "NSt7__cxx1111char_traitsE"},
+      // std::__1::allocator == std::allocator
+      {FragmentKind::Name,
+       "NSt3__19allocatorE",
+       "Sa"}, // "Sa" is not strictly a <name> but we accept it as one.
+      // std::__1::vector == std::vector
+      {FragmentKind::Name,
+       "St6vector",
+       "NSt3__16vectorE"},
+      // std::__1::basic_string<
+      //   char
+      //   std::__1::char_traits<char>,
+      //   std::__1::allocator<char>> ==
+      // std::__cxx11::basic_string<
+      //   char,
+      //   std::char_traits<char>,
+      //   std::allocator<char>>
+      {FragmentKind::Type,
+       "NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
+       "NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+      // X<A> <-> X<B>
+      {FragmentKind::Type, "1XI1AE", "1XI1BE"},
+      // X <-> Y
+      {FragmentKind::Name, "1X", "1Y"},
+    },
+    {
+      // f(std::string)
+      {"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
+       "_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+      // f(std::vector<int>)
+      {"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
+      // f(X<A>), f(X<B>), f(Y<A>), f(Y<B>)
+      {"_Z1f1XI1AE", "_Z1f1XI1BE", "_Z1f1YI1AE", "_Z1f1YI1BE"},
+      // f(X<C>), f(Y<C>)
+      {"_Z1f1XI1CE", "_Z1f1YI1CE"},
+    }
+  },
+
+  // Check namespace equivalences.
+  {
+    {
+      // std::__1 == std::__cxx11
+      {FragmentKind::Name, "St3__1", "St7__cxx11"},
+      // std::__1::allocator == std::allocator
+      {FragmentKind::Name, "NSt3__19allocatorE", "Sa"},
+      // std::vector == std::__1::vector
+      {FragmentKind::Name, "St6vector", "NSt3__16vectorE"},
+      // std::__cxx11::char_traits == std::char_traits
+      // (This indirectly means that std::__1::char_traits == std::char_traits,
+      // due to the std::__cxx11 == std::__1 equivalence, which is what we rely
+      // on below.)
+      {FragmentKind::Name, "NSt7__cxx1111char_traitsE", "St11char_traits"},
+    },
+    {
+      // f(std::foo)
+      {"_Z1fNSt7__cxx113fooE",
+       "_Z1fNSt3__13fooE"},
+      // f(std::string)
+      {"_Z1fNSt7__cxx1111char_traitsIcEE",
+       "_Z1fNSt3__111char_traitsIcEE",
+       "_Z1fSt11char_traitsIcE"},
+      // f(std::string)
+      {"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
+       "_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+      // f(std::vector<int>)
+      {"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
+    }
+  },
+
+  // Check namespace equivalences for namespace 'std'. We support using 'St'
+  // for this, despite it not technically being a <name>.
+  {
+    {
+      // std::__1 == std
+      {FragmentKind::Name, "St3__1", "St"},
+      // std::__1 == std::__cxx11
+      {FragmentKind::Name, "St3__1", "St7__cxx11"},
+      // FIXME: Should a 'std' equivalence also cover the predefined
+      // substitutions?
+      // std::__1::allocator == std::allocator
+      {FragmentKind::Name, "NSt3__19allocatorE", "Sa"},
+    },
+    {
+      {"_Z1fSt3foo", "_Z1fNSt3__13fooE", "_Z1fNSt7__cxx113fooE"},
+      {"_Z1fNSt3bar3bazE", "_Z1fNSt3__13bar3bazE"},
+      // f(std::string)
+      {"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
+       "_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
+      // f(std::vector<int>)
+      {"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
+    }
+  },
+
+  // Check mutually-recursive equivalences.
+  {
+    {
+      {FragmentKind::Type, "1A", "1B"},
+      {FragmentKind::Type, "1A", "1C"},
+      {FragmentKind::Type, "1D", "1B"},
+      {FragmentKind::Type, "1C", "1E"},
+    },
+    {
+      {"_Z1f1A", "_Z1f1B", "_Z1f1C", "_Z1f1D", "_Z1f1E"},
+      {"_Z1f1F"},
+    }
+  },
+
+  // Check <encoding>s.
+  {
+    {
+      {FragmentKind::Encoding, "1fv", "1gv"},
+    },
+    {
+      // f(void) -> g(void)
+      {"_Z1fv", "_Z1gv"},
+      // static local 'n' in f(void) -> static local 'n' in g(void)
+      {"_ZZ1fvE1n", "_ZZ1gvE1n"},
+    }
+  },
+
+  // Corner case: the substitution can appear within its own expansion.
+  {
+    {
+      // X <-> Y<X>
+      {FragmentKind::Type, "1X", "1YI1XE"},
+      // A<B> <-> B
+      {FragmentKind::Type, "1AI1BE", "1B"},
+    },
+    {
+      // f(X) == f(Y<X>) == f(Y<Y<X>>) == f(Y<Y<Y<X>>>)
+      {"_Z1f1X", "_Z1f1YI1XE", "_Z1f1YIS_I1XEE", "_Z1f1YIS_IS_I1XEEE"},
+      // f(B) == f(A<B>) == f(A<A<B>>) == f(A<A<A<B>>>)
+      {"_Z1f1B", "_Z1f1AI1BE", "_Z1f1AIS_I1BEE", "_Z1f1AIS_IS_I1BEEE"},
+    }
+  },
+};
+
+template<bool CanonicalizeFirst>
+static void testTestcases() {
+  for (const auto &Testcase : Testcases) {
+    llvm::ItaniumManglingCanonicalizer Canonicalizer;
+    for (const auto &Equiv : Testcase.Equivalences) {
+      auto Result =
+          Canonicalizer.addEquivalence(Equiv.Kind, Equiv.First, Equiv.Second);
+      EXPECT_EQ(Result, EquivalenceError::Success)
+          << "couldn't add equivalence between " << Equiv.First << " and "
+          << Equiv.Second;
+    }
+
+    using CanonKey = llvm::ItaniumManglingCanonicalizer::Key;
+
+    std::map<const EquivalenceClass*, CanonKey> Keys;
+    if (CanonicalizeFirst)
+      for (const auto &Class : Testcase.Classes)
+        Keys.insert({&Class, Canonicalizer.canonicalize(*Class.begin())});
+
+    std::map<CanonKey, llvm::StringRef> Found;
+    for (const auto &Class : Testcase.Classes) {
+      CanonKey ClassKey = Keys[&Class];
+      for (llvm::StringRef Str : Class) {
+        // Force a copy to be made when calling lookup to test that it doesn't
+        // retain any part of the provided string.
+        CanonKey ThisKey = CanonicalizeFirst
+                               ? Canonicalizer.lookup(std::string(Str))
+                               : Canonicalizer.canonicalize(Str);
+        EXPECT_NE(ThisKey, CanonKey()) << "couldn't canonicalize " << Str;
+        if (ClassKey) {
+          EXPECT_EQ(ThisKey, ClassKey)
+              << Str << " not in the same class as " << *Class.begin();
+        } else {
+          ClassKey = ThisKey;
+        }
+      }
+      EXPECT_TRUE(Found.insert({ClassKey, *Class.begin()}).second)
+          << *Class.begin() << " is in the same class as " << Found[ClassKey];
+    }
+  }
+}
+
+TEST(CanonicalizeTest, TestCanonicalize) {
+  testTestcases<false>();
+}
+
+TEST(CanonicalizeTest, TestLookup) {
+  testTestcases<true>();
+}
+
+TEST(CanonicalizeTest, TestInvalidManglings) {
+  llvm::ItaniumManglingCanonicalizer Canonicalizer;
+  EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "", "1X"),
+            EquivalenceError::InvalidFirstMangling);
+  EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1X", "1ab"),
+            EquivalenceError::InvalidSecondMangling);
+  EXPECT_EQ(Canonicalizer.canonicalize("_Z3fooE"),
+            llvm::ItaniumManglingCanonicalizer::Key());
+  EXPECT_EQ(Canonicalizer.canonicalize("foo"),
+            llvm::ItaniumManglingCanonicalizer::Key());
+}
+
+TEST(CanonicalizeTest, TestBadEquivalenceOrder) {
+  llvm::ItaniumManglingCanonicalizer Canonicalizer;
+  EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1A", "1B"),
+            EquivalenceError::Success);
+  EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1B", "1C"),
+            EquivalenceError::Success);
+  EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1C", "1A"),
+            EquivalenceError::ManglingAlreadyUsed);
+}
Index: unittests/ProfileData/InstrProfTest.cpp
===================================================================
--- unittests/ProfileData/InstrProfTest.cpp
+++ unittests/ProfileData/InstrProfTest.cpp
@@ -42,8 +42,10 @@
 
   void SetUp() { Writer.setOutputSparse(false); }
 
-  void readProfile(std::unique_ptr<MemoryBuffer> Profile) {
-    auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
+  void readProfile(std::unique_ptr<MemoryBuffer> Profile,
+                   std::unique_ptr<MemoryBuffer> Remapping = nullptr) {
+    auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile),
+                                                      std::move(Remapping));
     EXPECT_THAT_ERROR(ReaderOrErr.takeError(), Succeeded());
     Reader = std::move(ReaderOrErr.get());
   }
@@ -990,6 +992,43 @@
   }
 }
 
+TEST_P(MaybeSparseInstrProfTest, remapping_test) {
+  Writer.addRecord({"_Z3fooi", 0x1234, {1, 2, 3, 4}}, Err);
+  Writer.addRecord({"_Z3barf", 0x567, {5, 6, 7}}, Err);
+  auto Profile = Writer.writeBuffer();
+  readProfile(std::move(Profile), llvm::MemoryBuffer::getMemBuffer(R"(
+    type i l
+    name 3bar 4quux
+  )"));
+
+  std::vector<uint64_t> Counts;
+  for (StringRef FooName : {"_Z3fooi", "_Z3fool"}) {
+    EXPECT_THAT_ERROR(Reader->getFunctionCounts(FooName, 0x1234, Counts),
+                      Succeeded());
+    ASSERT_EQ(4u, Counts.size());
+    EXPECT_EQ(1u, Counts[0]);
+    EXPECT_EQ(2u, Counts[1]);
+    EXPECT_EQ(3u, Counts[2]);
+    EXPECT_EQ(4u, Counts[3]);
+  }
+
+  for (StringRef BarName : {"_Z3barf", "_Z4quuxf"}) {
+    EXPECT_THAT_ERROR(Reader->getFunctionCounts(BarName, 0x567, Counts),
+                      Succeeded());
+    ASSERT_EQ(3u, Counts.size());
+    EXPECT_EQ(5u, Counts[0]);
+    EXPECT_EQ(6u, Counts[1]);
+    EXPECT_EQ(7u, Counts[2]);
+  }
+
+  for (StringRef BadName : {"_Z3foof", "_Z4quuxi", "_Z3barl", "", "_ZZZ"}) {
+    EXPECT_THAT_ERROR(Reader->getFunctionCounts(BadName, 0x1234, Counts),
+                      Failed());
+    EXPECT_THAT_ERROR(Reader->getFunctionCounts(BadName, 0x567, Counts),
+                      Failed());
+  }
+}
+
 TEST_F(SparseInstrProfTest, preserve_no_records) {
   Writer.addRecord({"foo", 0x1234, {0}}, Err);
   Writer.addRecord({"bar", 0x4321, {0, 0}}, Err);
Index: unittests/ProfileData/SampleProfTest.cpp
===================================================================
--- unittests/ProfileData/SampleProfTest.cpp
+++ unittests/ProfileData/SampleProfTest.cpp
@@ -57,7 +57,7 @@
     Reader = std::move(ReaderOrErr.get());
   }
 
-  void testRoundTrip(SampleProfileFormat Format) {
+  void testRoundTrip(SampleProfileFormat Format, bool Remap) {
     createWriter(Format);
 
     StringRef FooName("_Z3fooi");
@@ -99,22 +99,35 @@
     EC = Reader->read();
     ASSERT_TRUE(NoError(EC));
 
-    StringMap<FunctionSamples> &ReadProfiles = Reader->getProfiles();
-    ASSERT_EQ(2u, ReadProfiles.size());
-
-    std::string FooGUID;
-    StringRef FooRep = getRepInFormat(FooName, Format, FooGUID);
-    FunctionSamples &ReadFooSamples = ReadProfiles[FooRep];
-    ASSERT_EQ(7711u, ReadFooSamples.getTotalSamples());
-    ASSERT_EQ(610u, ReadFooSamples.getHeadSamples());
-
-    std::string BarGUID;
-    StringRef BarRep = getRepInFormat(BarName, Format, BarGUID);
-    FunctionSamples &ReadBarSamples = ReadProfiles[BarRep];
-    ASSERT_EQ(20301u, ReadBarSamples.getTotalSamples());
-    ASSERT_EQ(1437u, ReadBarSamples.getHeadSamples());
+    if (Remap) {
+      auto MemBuffer = llvm::MemoryBuffer::getMemBuffer(R"(
+        # Types 'int' and 'long' are equivalent
+        type i l
+        # Function names 'foo' and 'faux' are equivalent
+        name 3foo 4faux
+      )");
+      Reader.reset(new SampleProfileReaderItaniumRemapper(
+          std::move(MemBuffer), Context, std::move(Reader)));
+      FooName = "_Z4fauxi";
+      BarName = "_Z3barl";
+
+      EC = Reader->read();
+      ASSERT_TRUE(NoError(EC));
+    }
+
+    ASSERT_EQ(2u, Reader->getProfiles().size());
+
+    FunctionSamples *ReadFooSamples = Reader->getSamplesFor(FooName);
+    ASSERT_TRUE(ReadFooSamples != nullptr);
+    ASSERT_EQ(7711u, ReadFooSamples->getTotalSamples());
+    ASSERT_EQ(610u, ReadFooSamples->getHeadSamples());
+
+    FunctionSamples *ReadBarSamples = Reader->getSamplesFor(BarName);
+    ASSERT_TRUE(ReadBarSamples != nullptr);
+    ASSERT_EQ(20301u, ReadBarSamples->getTotalSamples());
+    ASSERT_EQ(1437u, ReadBarSamples->getHeadSamples());
     ErrorOr<SampleRecord::CallTargetMap> CTMap =
-        ReadBarSamples.findCallTargetMapAt(1, 0);
+        ReadBarSamples->findCallTargetMapAt(1, 0);
     ASSERT_FALSE(CTMap.getError());
 
     std::string MconstructGUID;
@@ -176,15 +189,19 @@
 };
 
 TEST_F(SampleProfTest, roundtrip_text_profile) {
-  testRoundTrip(SampleProfileFormat::SPF_Text);
+  testRoundTrip(SampleProfileFormat::SPF_Text, false);
 }
 
 TEST_F(SampleProfTest, roundtrip_raw_binary_profile) {
-  testRoundTrip(SampleProfileFormat::SPF_Binary);
+  testRoundTrip(SampleProfileFormat::SPF_Binary, false);
 }
 
 TEST_F(SampleProfTest, roundtrip_compact_binary_profile) {
-  testRoundTrip(SampleProfileFormat::SPF_Compact_Binary);
+  testRoundTrip(SampleProfileFormat::SPF_Compact_Binary, false);
+}
+
+TEST_F(SampleProfTest, remap_text_profile) {
+  testRoundTrip(SampleProfileFormat::SPF_Text, true);
 }
 
 TEST_F(SampleProfTest, sample_overflow_saturation) {