Move Microsoft Demangler to Support

[zturner]

Summary

It seems like people feel that Demangler logically belongs in Support *anyway*, but for logistical reasons (such as libcxxabi needing to use the itanium demangler), it can't yet go there.

The Microsoft demangler doesn't have the same restrictions, and doesn't make sense to ever be part of libcxxabi either. So while it's nice from a layering perspective to put all demanglers the same place, it comes with the downside of impeding the development and making the code worse.

The MS Demangler is mostly complete, but I'd like to take some time to make it not just work, but also be clean. Having access to some Support classes (Casting.h, StringRef.h, SmallVector.h, raw_ostream.h, etc) would really help clean up a lot of the code (as well as making it more efficient in some cases).

Currently there's no use case for a standalone Microsoft demangler, and supporting standalone versions of all of the various things LLVM can do seems like a non-goal anyway so I think this is a win.

[rnk]

Won't this make tablegen rebuild every time you change the demangler? Is that really necessary?

[zturner]

In D51174#1211241, @rnk wrote:

Won't this make tablegen rebuild every time you change the demangler? Is that really necessary?

Sure, but that's kind of the cost of doing business with our monolithic approach to Support. I've been making changes to Demangler a lot recently, but eventually it should get to the point where people rarely change anything.

[rnk]

In D51174#1211241, @rnk wrote:

Won't this make tablegen rebuild every time you change the demangler? Is that really necessary?

I guess that's not a concern. I forgot I had to go look in LLVMBuild.txt to see an LLVM libraries dependencies, not CMakeLists.txt like usual. =p

[rnk]

I guess I don't like this change because it makes our demanglers, which should ideally be super standalone, no STL usage code, more entangled with the rest of LLVM. It would be nice if, for example, we could compile this code into sanitizer libraries. Today we have a solution (llvm-symbolizer) that essentially pushes the symbolization work out of process into LLVM code, but you can imagine wanting to have a complete in-library solution.

[zturner]

In D51174#1211249, @rnk wrote:

I guess I don't like this change because it makes our demanglers, which should ideally be super standalone, no STL usage code, more entangled with the rest of LLVM. It would be nice if, for example, we could compile this code into sanitizer libraries. Today we have a solution (llvm-symbolizer) that essentially pushes the symbolization work out of process into LLVM code, but you can imagine wanting to have a complete in-library solution.

I don't know, we don't have these restrictions anywhere else in LLVM. Lots of things would be nice I guess, but unless anyone needs it today, I'd prefer to go with YAGNI and if we ever do, then we can do something like what Richard did with the Itanium demangler.

[thakis]

FWIW I'd like to use the new demangler in demumble [1], but if I need to pull in most of Support of it then I probably won't do that. I agree this shouldn't impact LLVM much (or at all), but having stand-alone-ish demangler code is probably nice for several other projects too. So since the itanium demangler is still in the other place and likely will stay there, maybe it's nice to keep the ms demangler next to it. (But as I said, don't weigh this feedback heavily.)

1: https://github.com/nico/demumble

[zturner]

What if we produced a .lib file that had only the minimal set of object
files needed to link this, and make MicrosoftDemangle.h not include other
llvm headers, then you could just link against that object file and it
should be effectively independent.

Would that work?

[thakis]

In D51174#1211835, @zturner wrote:

What if we produced a .lib file that had only the minimal set of object
files needed to link this, and make MicrosoftDemangle.h not include other
llvm headers, then you could just link against that object file and it
should be effectively independent.

Would that work?

I copy over the source files I need, so .lib files wouldn't help me. Right now, it's "copy 1 file" and it's fairly easy to rev. It'd become "figure out subset of Support currently needed", which will likely be different each time. Keeping things in their own project does keep this more manageable (which is why this how it's done for the itanium mangler).

llvm/include/llvm/Demangle/Demangle.h

char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
                       int *status);
 
 /// Calls the callback \c Callback with \c Ctx as an argument whenever a type is
 /// encountered. Returns true if \c MangledName couldn't be parsed.
 bool itaniumFindTypesInMangledName(const char *MangledName, void *Ctx,
                                    void (*Callback)(void *, const char *));
 
 
-enum MSDemangleFlags { MSDF_None = 0, MSDF_DumpBackrefs = 1 << 0 };
-char *microsoftDemangle(const char *mangled_name, char *buf, size_t *n,
-                        int *status, MSDemangleFlags Flags = MSDF_None);
-
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.
 struct ItaniumPartialDemangler {
   ItaniumPartialDemangler();
 
   ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
   ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);

llvm/include/llvm/Support/MicrosoftDemangle.h

+//===--- Demangle.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_SUPPORT_MICROSOFT_DEMANGLE_H
+#define LLVM_SUPPORT_MICROSOFT_DEMANGLE_H
+
+#include "llvm/ADT/StringRef.h"
+
+#include <cstddef>
+#include <string>
+
+namespace llvm {
+  enum MSDemangleFlags {
+    MSDF_None = 0,
+    MSDF_DumpBackrefs = 1 << 0
+  };
+
+  std::string microsoftDemangle(StringRef MangledName, int *status, MSDemangleFlags Flags = MSDF_None);
+
+} // namespace llvm
+
+#endif

llvm/lib/Demangle/CMakeLists.txt

 add_llvm_library(LLVMDemangle
   ItaniumDemangle.cpp
-  MicrosoftDemangle.cpp
 
   ADDITIONAL_HEADER_DIRS
   "${LLVM_MAIN_INCLUDE_DIR}/llvm/Demangle"
 )

llvm/lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp
   LowLevelType.cpp
   ManagedStatic.cpp
   MathExtras.cpp
   MemoryBuffer.cpp
   MD5.cpp
+  MicrosoftDemangle.cpp
   NativeFormatting.cpp
   Options.cpp
   Parallel.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
   ScaledNumber.cpp

llvm/lib/Support/MicrosoftDemangle.cpp

 //===- MicrosoftDemangle.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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a demangler for MSVC-style mangled symbols.
 //
 // This file has no dependencies on the rest of LLVM so that it can be
 // easily reused in other programs such as libcxxabi.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Demangle/Demangle.h"
+#include "llvm/Support/MicrosoftDemangle.h"
 
-#include "llvm/Demangle/Compiler.h"
-#include "llvm/Demangle/StringView.h"
-#include "llvm/Demangle/Utility.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/StringSaver.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/Compiler.h"
 
 #include <array>
 #include <cctype>
 #include <cstdio>
 #include <tuple>
 
-// This memory allocator is extremely fast, but it doesn't call dtors
-// for allocated objects. That means you can't use STL containers
-// (such as std::vector) with this allocator. But it pays off --
-// the demangler is 3x faster with this allocator compared to one with
-// STL containers.
-namespace {
-  constexpr size_t AllocUnit = 4096;
+using namespace llvm;
 
-class ArenaAllocator {
-  struct AllocatorNode {
-    uint8_t *Buf = nullptr;
-    size_t Used = 0;
-    size_t Capacity = 0;
-    AllocatorNode *Next = nullptr;
-  };
-
-  void addNode(size_t Capacity) {
-    AllocatorNode *NewHead = new AllocatorNode;
-    NewHead->Buf = new uint8_t[Capacity];
-    NewHead->Next = Head;
-    NewHead->Capacity = Capacity;
-    Head = NewHead;
-    NewHead->Used = 0;
-  }
+template<typename T, typename ...Args> static T *allocate(BumpPtrAllocator &Allocator, Args &&... CtorArgs) {
+  void *V = Allocator.Allocate(sizeof(T), alignof(T));
+  return new (V) T(std::forward<Args>(CtorArgs)...);
 
-public:
-  ArenaAllocator() { addNode(AllocUnit); }
 
-  ~ArenaAllocator() {
-    while (Head) {
-      assert(Head->Buf);
-      delete[] Head->Buf;
-      AllocatorNode *Next = Head->Next;
-      delete Head;
-      Head = Next;
-    }
-  }
+static char pop(StringRef &S) {
+  char C = S.front();
+  S = S.drop_front();
+  return C;
 
-  char *allocUnalignedBuffer(size_t Length) {
-    uint8_t *Buf = Head->Buf + Head->Used;
-
-    Head->Used += Length;
-    if (Head->Used > Head->Capacity) {
-      // It's possible we need a buffer which is larger than our default unit
-      // size, so we need to be careful to add a node with capacity that is at
-      // least as large as what we need.
-      addNode(std::max(AllocUnit, Length));
-      Head->Used = Length;
-      Buf = Head->Buf;
-    }
+static bool startswithDigit(StringRef S) {
+  return !S.empty() && std::isdigit(S.front());
 
-    return reinterpret_cast<char *>(Buf);
+class peekable_raw_ostream : public raw_ostream {
+public:
+  explicit peekable_raw_ostream(raw_ostream &OS)
+    : OS(OS) {
+    SetUnbuffered();
   }
   
-  template <typename T, typename... Args> T *alloc(Args &&... ConstructorArgs) {
-
-    size_t Size = sizeof(T);
-    assert(Head && Head->Buf);
+  bool empty() const { return !LastChar.hasValue(); }
 
-    size_t P = (size_t)Head->Buf + Head->Used;
-    uintptr_t AlignedP =
-        (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
-    uint8_t *PP = (uint8_t *)AlignedP;
-    size_t Adjustment = AlignedP - P;
+  char peek() const { return *LastChar; }
 
-    Head->Used += Size + Adjustment;
-    if (Head->Used < Head->Capacity)
-      return new (PP) T(std::forward<Args>(ConstructorArgs)...);
-
-    addNode(AllocUnit);
-    Head->Used = Size;
-    return new (Head->Buf) T(std::forward<Args>(ConstructorArgs)...);
+private:
+  void write_impl(const char *Ptr, size_t N) override {
+    OS.write(Ptr, N);
+    OS.flush();
+    if (N > 0)
+      LastChar = Ptr[N - 1];
   }
 
-private:
-  AllocatorNode *Head = nullptr;
-};
-} // namespace
+  uint64_t current_pos() const override { return OS.tell(); }
 
-static bool startsWithDigit(StringView S) {
-  return !S.empty() && std::isdigit(S.front());
-}
+  Optional<char> LastChar;
+  raw_ostream &OS;
+};
 
 // Writes a space if the last token does not end with a punctuation.
-static void outputSpaceIfNecessary(OutputStream &OS) {
+static void outputSpaceIfNecessary(peekable_raw_ostream &OS) {
   if (OS.empty())
     return;
 
-  char C = OS.back();
+  char C = OS.peek();
   if (isalnum(C) || C == '>')
     OS << " ";
 }
 
 // Storage classes
 enum Qualifiers : uint8_t {
   Q_None = 0,
   Q_Const = 1 << 0,
enum class OperatorTy : uint8_t {
   BitwiseAndEqual,         // ?_4 operator&=
   BitwiseOrEqual,          // ?_5 operator|=
   BitwiseXorEqual,         // ?_6 operator^=
   Vftable,                 // ?_7 # vftable
   Vbtable,                 // ?_8 # vbtable
   Vcall,                   // ?_9 # vcall
   Typeof,                  // ?_A # typeof
   LocalStaticGuard,        // ?_B # local static guard
-  StringLiteral,           // ?_C # string literal
+  StringLiteralSymbol,           // ?_C # string literal
   VbaseDtor,               // ?_D # vbase destructor
   VecDelDtor,              // ?_E # vector deleting destructor
   DefaultCtorClosure,      // ?_F # default constructor closure
   ScalarDelDtor,           // ?_G # scalar deleting destructor
   VecCtorIter,             // ?_H # vector constructor iterator
   VecDtorIter,             // ?_I # vector destructor iterator
   VecVbaseCtorIter,        // ?_J # vector vbase constructor iterator
   VdispMap,                // ?_K # virtual displacement map
enum class OperatorTy : uint8_t {
   LocalStaticThreadGuard,       // ?__J local static thread guard
   LiteralOperator,              // ?__K operator ""_name
   CoAwait,                      // ?__L co_await
   Spaceship,                    // operator<=>
 };
 
 // A map to translate from operator prefix to operator type.
 struct OperatorMapEntry {
-  StringView Prefix;
-  StringView Name;
+  StringRef Prefix;
+  StringRef Name;
   OperatorTy Operator;
 };
 
 // The entries here must be in the same order as the enumeration so that it can
 // be indexed by enum value.
 OperatorMapEntry OperatorMap[] = {
     {"0", " <ctor>", OperatorTy::Ctor},
     {"1", " <dtor>", OperatorTy::Dtor},
OperatorMapEntry OperatorMap[] = {
     {"_4", "operator&=", OperatorTy::BitwiseAndEqual},
     {"_5", "operator|=", OperatorTy::BitwiseOrEqual},
     {"_6", "operator^=", OperatorTy::BitwiseXorEqual},
     {"_7", "`vftable'", OperatorTy::Vftable},
     {"_8", "`vbtable'", OperatorTy::Vbtable},
     {"_9", "`vcall'", OperatorTy::Vcall},
     {"_A", "`typeof'", OperatorTy::Typeof},
     {"_B", "`local static guard'", OperatorTy::LocalStaticGuard},
-    {"_C", "`string'", OperatorTy::StringLiteral},
+    {"_C", "`string'", OperatorTy::StringLiteralSymbol},
     {"_D", "`vbase dtor'", OperatorTy::VbaseDtor},
     {"_E", "`vector deleting dtor'", OperatorTy::VecDelDtor},
     {"_F", "`default ctor closure'", OperatorTy::DefaultCtorClosure},
     {"_G", "`scalar deleting dtor'", OperatorTy::ScalarDelDtor},
     {"_H", "`vector ctor iterator'", OperatorTy::VecCtorIter},
     {"_I", "`vector dtor iterator'", OperatorTy::VecDtorIter},
     {"_J", "`vector vbase ctor iterator'", OperatorTy::VecVbaseCtorIter},
     {"_K", "`virtual displacement map'", OperatorTy::VdispMap},
struct TemplateParams {
   TemplateParams *Next = nullptr;
 };
 
 // The type class. Mangled symbols are first parsed and converted to
 // this type and then converted to string.
 struct Type {
   virtual ~Type() {}
 
-  virtual Type *clone(ArenaAllocator &Arena) const;
+  virtual Type *clone(BumpPtrAllocator &Arena) const;
 
   // Write the "first half" of a given type.  This is a static functions to
   // give the code a chance to do processing that is common to a subset of
   // subclasses
-  static void outputPre(OutputStream &OS, Type &Ty);
+  static void outputPre(peekable_raw_ostream &OS, Type &Ty);
 
   // Write the "second half" of a given type.  This is a static functions to
   // give the code a chance to do processing that is common to a subset of
   // subclasses
-  static void outputPost(OutputStream &OS, Type &Ty);
+  static void outputPost(peekable_raw_ostream &OS, Type &Ty);
 
-  virtual void outputPre(OutputStream &OS);
-  virtual void outputPost(OutputStream &OS);
+  virtual void outputPre(peekable_raw_ostream &OS);
+  virtual void outputPost(peekable_raw_ostream &OS);
 
   // Primitive type such as Int.
   PrimTy Prim = PrimTy::Unknown;
 
   Qualifiers Quals = Q_None;
-  StringView Custom;
+  StringRef Custom;
   StorageClass Storage = StorageClass::None; // storage class
 };
 
 // Represents an identifier which may be a template.
 struct Name {
   virtual ~Name() = default;
 
   bool IsTemplateInstantiation = false;
   bool IsOperator = false;
   bool IsBackReference = false;
 
-  bool isStringLiteralOperatorInfo() const;
+  bool isStringLiteralSymbolOperatorInfo() const;
 
   // Name read from an MangledName string.
-  StringView Str;
+  StringRef Str;
 
   // Template parameters. Only valid if IsTemplateInstantiation is true.
   TemplateParams *TParams = nullptr;
 
   // Nested BackReferences (e.g. "A::B::C") are represented as a linked list.
   Name *Next = nullptr;
 };
 
struct IndirectTable : public OperatorInfo {
   }
   explicit IndirectTable(OperatorTy OpType)
       : IndirectTable(OperatorMap[(int)OpType]) {}
 
   const Name *TableLocation = nullptr;
   const Name *TableTarget = nullptr;
 };
 
-struct StringLiteral : public OperatorInfo {
-  StringLiteral() : OperatorInfo(OperatorTy::StringLiteral) {}
+struct StringLiteralSymbol : public OperatorInfo {
+  StringLiteralSymbol() : OperatorInfo(OperatorTy::StringLiteralSymbol) {}
 
   PrimTy CharType;
   bool IsTruncated = false;
 };
 
 struct RttiBaseClassDescriptor : public OperatorInfo {
   RttiBaseClassDescriptor()
       : OperatorInfo(OperatorTy::RttiBaseClassDescriptor) {}

 struct VirtualMemberPtrThunk : public OperatorInfo {
   VirtualMemberPtrThunk() : OperatorInfo(OperatorTy::Vcall) {}
 
   uint64_t OffsetInVTable = 0;
   CallingConv CC = CallingConv::Cdecl;
 };
 
 struct PointerType : public Type {
-  Type *clone(ArenaAllocator &Arena) const override;
-  void outputPre(OutputStream &OS) override;
-  void outputPost(OutputStream &OS) override;
+  Type *clone(BumpPtrAllocator &Arena) const override;
+  void outputPre(peekable_raw_ostream &OS) override;
+  void outputPost(peekable_raw_ostream &OS) override;
 
   PointerAffinity Affinity;
 
   // Represents a type X in "a pointer to X", "a reference to X",
   // "an array of X", or "a function returning X".
   Type *Pointee = nullptr;
 };
 
 struct MemberPointerType : public Type {
-  Type *clone(ArenaAllocator &Arena) const override;
-  void outputPre(OutputStream &OS) override;
-  void outputPost(OutputStream &OS) override;
+  Type *clone(BumpPtrAllocator &Arena) const override;
+  void outputPre(peekable_raw_ostream &OS) override;
+  void outputPost(peekable_raw_ostream &OS) override;
 
   Name *MemberName = nullptr;
 
   // Represents a type X in "a pointer to X", "a reference to X",
   // "an array of X", or "a function returning X".
   Type *Pointee = nullptr;
 };
 
 struct FunctionType : public Type {
   struct ThisAdjustor {
     uint32_t StaticOffset = 0;
     int32_t VBPtrOffset = 0;
     int32_t VBOffsetOffset = 0;
     int32_t VtordispOffset = 0;
   };
 
-  Type *clone(ArenaAllocator &Arena) const override;
-  void outputPre(OutputStream &OS) override;
-  void outputPost(OutputStream &OS) override;
+  Type *clone(BumpPtrAllocator &Arena) const override;
+  void outputPre(peekable_raw_ostream &OS) override;
+  void outputPost(peekable_raw_ostream &OS) override;
 
   // True if this FunctionType instance is the Pointee of a PointerType or
   // MemberPointerType.
   bool IsFunctionPointer = false;
   bool IsThunk = false;
 
   Type *ReturnType = nullptr;
   // If this is a reference, the type of reference.
   ReferenceKind RefKind;
 
   CallingConv CallConvention;
   FuncClass FunctionClass;
 
   // Valid if IsThunk is true.
   ThisAdjustor *ThisAdjust = nullptr;
 
   FunctionParams Params;
 };
 
 struct UdtType : public Type {
-  Type *clone(ArenaAllocator &Arena) const override;
-  void outputPre(OutputStream &OS) override;
+  Type *clone(BumpPtrAllocator &Arena) const override;
+  void outputPre(peekable_raw_ostream &OS) override;
 
   Name *UdtName = nullptr;
 };
 
 struct ArrayDimension {
   uint64_t Dim = 0;
   ArrayDimension *Next = nullptr;
 };
 
 struct ArrayType : public Type {
-  Type *clone(ArenaAllocator &Arena) const override;
-  void outputPre(OutputStream &OS) override;
-  void outputPost(OutputStream &OS) override;
+  Type *clone(BumpPtrAllocator &Arena) const override;
+  void outputPre(peekable_raw_ostream &OS) override;
+  void outputPost(peekable_raw_ostream &OS) override;
 
   // Either NextDimension or ElementType will be valid.
   ArrayDimension *Dims = nullptr;
 
   Type *ElementType = nullptr;
 };
 
 } // namespace
 
-static bool isMemberPointer(StringView MangledName) {
-  switch (MangledName.popFront()) {
+static bool isMemberPointer(StringRef MangledName) {
+  switch (MangledName.front()) {
   case '$':
     // This is probably an rvalue reference (e.g. $$Q), and you cannot have an
     // rvalue reference to a member.
     return false;
   case 'A':
     // 'A' indicates a reference, and you cannot have a reference to a member
     // function or member.
     return false;
   case 'P':
   case 'Q':
   case 'R':
   case 'S':
     // These 4 values indicate some kind of pointer, but we still don't know
     // what.
     break;
   default:
     assert(false && "Ty is not a pointer type!");
   }
+  MangledName = MangledName.drop_front();
 
   // If it starts with a number, then 6 indicates a non-member function
   // pointer, and 8 indicates a member function pointer.
-  if (startsWithDigit(MangledName)) {
+  if (startswithDigit(MangledName)) {
     assert(MangledName[0] == '6' || MangledName[0] == '8');
     return (MangledName[0] == '8');
   }
 
   // Remove ext qualifiers since those can appear on either type and are
   // therefore not indicative.
-  MangledName.consumeFront('E'); // 64-bit
-  MangledName.consumeFront('I'); // restrict
-  MangledName.consumeFront('F'); // unaligned
+  MangledName.consume_front("E"); // 64-bit
+  MangledName.consume_front("I"); // restrict
+  MangledName.consume_front("F"); // unaligned
 
   assert(!MangledName.empty());
 
   // The next value should be either ABCD (non-member) or QRST (member).
   switch (MangledName.front()) {
   case 'A':
   case 'B':
   case 'C':
   case 'D':
     return false;
   case 'Q':
   case 'R':
   case 'S':
   case 'T':
     return true;
   default:
     assert(false);
   }
   return false;
 }
 
-static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
+static void outputCallingConvention(peekable_raw_ostream &OS, CallingConv CC) {
   outputSpaceIfNecessary(OS);
 
   switch (CC) {
   case CallingConv::Cdecl:
     OS << "__cdecl";
     break;
   case CallingConv::Fastcall:
     OS << "__fastcall";
static void outputCallingConvention(peekable_raw_ostream &OS, CallingConv CC) {
   case CallingConv::Clrcall:
     OS << "__clrcall";
     break;
   default:
     break;
   }
 }
 
-static bool startsWithLocalScopePattern(StringView S) {
-  if (!S.consumeFront('?'))
+static bool startswithLocalScopePattern(StringRef S) {
+  if (!S.consume_front("?"))
     return false;
   if (S.size() < 2)
     return false;
 
   size_t End = S.find('?');
-  if (End == StringView::npos)
+  if (End == StringRef::npos)
     return false;
-  StringView Candidate = S.substr(0, End);
+  StringRef Candidate = S.substr(0, End);
   if (Candidate.empty())
     return false;
 
   // \?[0-9]\?
   // ?@? is the discriminator 0.
   if (Candidate.size() == 1)
     return Candidate[0] == '@' || (Candidate[0] >= '0' && Candidate[0] <= '9');
 
   // If it's not 0-9, then it's an encoded number terminated with an @
   if (Candidate.back() != '@')
     return false;
-  Candidate = Candidate.dropBack();
+  Candidate = Candidate.drop_back();
 
   // An encoded number starts with B-P and all subsequent digits are in A-P.
   // Note that the reason the first digit cannot be A is two fold.  First, it
   // would create an ambiguity with ?A which delimits the beginning of an
   // anonymous namespace.  Second, A represents 0, and you don't start a multi
   // digit number with a leading 0.  Presumably the anonymous namespace
   // ambiguity is also why single digit encoded numbers use 0-9 rather than A-J.
   if (Candidate[0] < 'B' || Candidate[0] > 'P')
     return false;
-  Candidate = Candidate.dropFront();
+  Candidate = Candidate.drop_front();
   while (!Candidate.empty()) {
     if (Candidate[0] < 'A' || Candidate[0] > 'P')
       return false;
-    Candidate = Candidate.dropFront();
+    Candidate = Candidate.drop_front();
   }
 
   return true;
 }
 
 // Write a function or template parameter list.
-static void outputParameterList(OutputStream &OS,
+static void outputParameterList(peekable_raw_ostream &OS,
                                 const FunctionParams &Params) {
   if (!Params.Current) {
     OS << "void";
     return;
   }
 
   const FunctionParams *Head = &Params;
   while (Head) {
     Type::outputPre(OS, *Head->Current);
     Type::outputPost(OS, *Head->Current);
 
     Head = Head->Next;
 
     if (Head)
       OS << ", ";
   }
 }
 
-static void outputStringLiteral(OutputStream &OS, const StringLiteral &Str) {
+static void outputStringLiteralSymbol(peekable_raw_ostream &OS, const StringLiteralSymbol &Str) {
   switch (Str.CharType) {
   case PrimTy::Wchar:
     OS << "const wchar_t * {L\"";
     break;
   case PrimTy::Char:
     OS << "const char * {\"";
     break;
   case PrimTy::Char16:
     OS << "const char16_t * {u\"";
     break;
   case PrimTy::Char32:
     OS << "const char32_t * {U\"";
     break;
   default:
     LLVM_BUILTIN_UNREACHABLE;
   }
   OS << Str.Str << "\"";
   if (Str.IsTruncated)
     OS << "...";
   OS << "}";
 }
 
-static void outputName(OutputStream &OS, const Name *TheName, const Type *Ty);
+static void outputName(peekable_raw_ostream &OS, const Name *TheName, const Type *Ty);
 
-static void outputParameterList(OutputStream &OS,
+static void outputParameterList(peekable_raw_ostream &OS,
                                 const TemplateParams &Params) {
   if (Params.IsEmptyParameterPack) {
     OS << "<>";
     return;
   }
 
   OS << "<";
   const TemplateParams *Head = &Params;
while (Head) {
     Head = Head->Next;
 
     if (Head)
       OS << ", ";
   }
   OS << ">";
 }
 
-static void outputQualifiers(OutputStream &OS, Qualifiers Q) {
+static void outputQualifiers(peekable_raw_ostream &OS, Qualifiers Q) {
   if (Q & Q_Const) {
     outputSpaceIfNecessary(OS);
     OS << "const";
   }
 
   if (Q & Q_Volatile) {
     outputSpaceIfNecessary(OS);
     OS << "volatile";
   }
 
   if (Q & Q_Restrict) {
     outputSpaceIfNecessary(OS);
     OS << "__restrict";
   }
 }
 
-static void outputNameComponent(OutputStream &OS, const Name &N) {
+static void outputNameComponent(peekable_raw_ostream &OS, const Name &N) {
   OS << N.Str;
 
   if (N.IsTemplateInstantiation && N.TParams)
     outputParameterList(OS, *N.TParams);
 }
 
 static const OperatorInfo *lastComponentAsOperator(const Name *TheName) {
   if (!TheName)
     return nullptr;
   while (TheName->Next)
     TheName = TheName->Next;
   if (TheName->IsOperator)
     return static_cast<const OperatorInfo *>(TheName);
   return nullptr;
 }
 
-static void outputName(OutputStream &OS, const Name *TheName, const Type *Ty) {
+static void outputName(peekable_raw_ostream &OS, const Name *TheName, const Type *Ty) {
   if (!TheName)
     return;
 
   outputSpaceIfNecessary(OS);
 
   const OperatorInfo *Operator = lastComponentAsOperator(TheName);
   const VirtualMemberPtrThunk *Thunk = nullptr;
   bool PrintLastScopeSeparator = true;
static void outputName(peekable_raw_ostream &OS, const Name *TheName, const Type *Ty) {
   default:
     OS << Operator->Info->Name;
     if (Operator->IsTemplateInstantiation)
       outputParameterList(OS, *Operator->TParams);
     break;
   }
 }
 
-static void outputSpecialOperator(OutputStream &OS, const Name *OuterName) {
+static void outputSpecialOperator(peekable_raw_ostream &OS, const Name *OuterName) {
   assert(OuterName);
   // The last component should be an operator.
   const OperatorInfo *Operator = lastComponentAsOperator(OuterName);
 
   assert(Operator->IsOperator);
   const OperatorInfo &Oper = static_cast<const OperatorInfo &>(*Operator);
   switch (Oper.Info->Operator) {
-  case OperatorTy::StringLiteral: {
-    const StringLiteral &SL = static_cast<const StringLiteral &>(Oper);
-    outputStringLiteral(OS, SL);
+  case OperatorTy::StringLiteralSymbol: {
+    const StringLiteralSymbol &SL = static_cast<const StringLiteralSymbol &>(Oper);
+    outputStringLiteralSymbol(OS, SL);
     break;
   }
   case OperatorTy::Vcall: {
     const VirtualMemberPtrThunk &Thunk =
         static_cast<const VirtualMemberPtrThunk &>(Oper);
     OS << "[thunk]: ";
     outputCallingConvention(OS, Thunk.CC);
     OS << " ";
static void outputSpecialOperator(peekable_raw_ostream &OS, const Name *OuterName) {
   default:
     // There are no other special operator categories.
     LLVM_BUILTIN_UNREACHABLE;
   }
 }
 
 namespace {
 
-bool Name::isStringLiteralOperatorInfo() const {
+bool Name::isStringLiteralSymbolOperatorInfo() const {
   if (!IsOperator)
     return false;
   const OperatorInfo &O = static_cast<const OperatorInfo &>(*this);
-  return O.Info->Operator == OperatorTy::StringLiteral;
+  return O.Info->Operator == OperatorTy::StringLiteralSymbol;
 }
 
-Type *Type::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<Type>(*this);
+Type *Type::clone(BumpPtrAllocator &Arena) const {
+  return allocate<Type>(Arena, *this);
 }
 
 // Write the "first half" of a given type.
-void Type::outputPre(OutputStream &OS, Type &Ty) {
+void Type::outputPre(peekable_raw_ostream &OS, Type &Ty) {
   // Function types require custom handling of const and static so we
   // handle them separately.  All other types use the same decoration
   // for these modifiers, so handle them here in common code.
   if (Ty.Prim == PrimTy::Function) {
     Ty.outputPre(OS);
     return;
   }
 
   switch (Ty.Storage) {
   case StorageClass::PrivateStatic:
   case StorageClass::PublicStatic:
   case StorageClass::ProtectedStatic:
     OS << "static ";
   default:
     break;
   }
   Ty.outputPre(OS);
 
   outputQualifiers(OS, Ty.Quals);
 }
 
 // Write the "second half" of a given type.
-void Type::outputPost(OutputStream &OS, Type &Ty) { Ty.outputPost(OS); }
+void Type::outputPost(peekable_raw_ostream &OS, Type &Ty) { Ty.outputPost(OS); }
 
-void Type::outputPre(OutputStream &OS) {
+void Type::outputPre(peekable_raw_ostream &OS) {
   switch (Prim) {
   case PrimTy::Void:
     OS << "void";
     break;
   case PrimTy::Bool:
     OS << "bool";
     break;
   case PrimTy::Char:
case PrimTy::Custom:
     break;
   case PrimTy::Vbtable:
   case PrimTy::Vftable:
     break;
   default:
     assert(false && "Invalid primitive type!");
   }
 }
-void Type::outputPost(OutputStream &OS) {}
+void Type::outputPost(peekable_raw_ostream &OS) {}
 
-Type *PointerType::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<PointerType>(*this);
+Type *PointerType::clone(BumpPtrAllocator &Arena) const {
+  return allocate<PointerType>(Arena, *this);
 }
 
-static void outputPointerIndicator(OutputStream &OS, PointerAffinity Affinity,
+static void outputPointerIndicator(peekable_raw_ostream &OS, PointerAffinity Affinity,
                                    const Name *MemberName,
                                    const Type *Pointee) {
   // "[]" and "()" (for function parameters) take precedence over "*",
   // so "int *x(int)" means "x is a function returning int *". We need
   // parentheses to supercede the default precedence. (e.g. we want to
   // emit something like "int (*x)(int)".)
   if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array) {
     OS << "(";
static void outputPointerIndicator(peekable_raw_ostream &OS, PointerAffinity Affinity,
   if (Affinity == PointerAffinity::Pointer)
     OS << "*";
   else if (Affinity == PointerAffinity::Reference)
     OS << "&";
   else
     OS << "&&";
 }
 
-void PointerType::outputPre(OutputStream &OS) {
+void PointerType::outputPre(peekable_raw_ostream &OS) {
   Type::outputPre(OS, *Pointee);
 
   outputSpaceIfNecessary(OS);
 
   if (Quals & Q_Unaligned)
     OS << "__unaligned ";
 
   outputPointerIndicator(OS, Affinity, nullptr, Pointee);
 
   // FIXME: We should output this, but it requires updating lots of tests.
   // if (Ty.Quals & Q_Pointer64)
   //  OS << " __ptr64";
 }
 
-void PointerType::outputPost(OutputStream &OS) {
+void PointerType::outputPost(peekable_raw_ostream &OS) {
   if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array)
     OS << ")";
 
   Type::outputPost(OS, *Pointee);
 }
 
-Type *MemberPointerType::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<MemberPointerType>(*this);
+Type *MemberPointerType::clone(BumpPtrAllocator &Arena) const {
+  return allocate<MemberPointerType>(Arena, *this);
 }
 
-void MemberPointerType::outputPre(OutputStream &OS) {
+void MemberPointerType::outputPre(peekable_raw_ostream &OS) {
   Type::outputPre(OS, *Pointee);
 
   outputSpaceIfNecessary(OS);
 
   outputPointerIndicator(OS, PointerAffinity::Pointer, MemberName, Pointee);
 
   // FIXME: We should output this, but it requires updating lots of tests.
   // if (Ty.Quals & Q_Pointer64)
   //  OS << " __ptr64";
 }
 
-void MemberPointerType::outputPost(OutputStream &OS) {
+void MemberPointerType::outputPost(peekable_raw_ostream &OS) {
   if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array)
     OS << ")";
 
   Type::outputPost(OS, *Pointee);
 }
 
-Type *FunctionType::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<FunctionType>(*this);
+Type *FunctionType::clone(BumpPtrAllocator &Arena) const {
+  return allocate<FunctionType>(Arena, *this);
 }
 
-void FunctionType::outputPre(OutputStream &OS) {
+void FunctionType::outputPre(peekable_raw_ostream &OS) {
   if ((FunctionClass & StaticThisAdjust) || (FunctionClass & VirtualThisAdjust))
     OS << "[thunk]: ";
 
   if (!(FunctionClass & Global)) {
     if (FunctionClass & Static)
       OS << "static ";
   }
   if (FunctionClass & ExternC)
void FunctionType::outputPre(peekable_raw_ostream &OS) {
 
   // Function pointers print the calling convention as void (__cdecl *)(params)
   // rather than void __cdecl (*)(params).  So we need to let the PointerType
   // class handle this.
   if (!IsFunctionPointer)
     outputCallingConvention(OS, CallConvention);
 }
 
-void FunctionType::outputPost(OutputStream &OS) {
+void FunctionType::outputPost(peekable_raw_ostream &OS) {
   // extern "C" functions don't have a prototype.
   if (FunctionClass & NoPrototype)
     return;
 
   if (FunctionClass & StaticThisAdjust) {
     OS << "`adjustor{" << ThisAdjust->StaticOffset << "}'";
   } else if (FunctionClass & VirtualThisAdjust) {
     if (FunctionClass & VirtualThisAdjustEx) {
void FunctionType::outputPost(peekable_raw_ostream &OS) {
   else if (RefKind == ReferenceKind::RValueRef)
     OS << " &&";
 
   if (ReturnType)
     Type::outputPost(OS, *ReturnType);
   return;
 }
 
-Type *UdtType::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<UdtType>(*this);
+Type *UdtType::clone(BumpPtrAllocator &Arena) const {
+  return allocate<UdtType>(Arena, *this);
 }
 
-void UdtType::outputPre(OutputStream &OS) {
+void UdtType::outputPre(peekable_raw_ostream &OS) {
   switch (Prim) {
   case PrimTy::Class:
     OS << "class ";
     break;
   case PrimTy::Struct:
     OS << "struct ";
     break;
   case PrimTy::Union:
     OS << "union ";
     break;
   case PrimTy::Enum:
     OS << "enum ";
     break;
   default:
     assert(false && "Not a udt type!");
   }
 
   outputName(OS, UdtName, this);
 }
 
-Type *ArrayType::clone(ArenaAllocator &Arena) const {
-  return Arena.alloc<ArrayType>(*this);
+Type *ArrayType::clone(BumpPtrAllocator &Arena) const {
+  return allocate<ArrayType>(Arena, *this);
 }
 
-void ArrayType::outputPre(OutputStream &OS) {
+void ArrayType::outputPre(peekable_raw_ostream &OS) {
   Type::outputPre(OS, *ElementType);
 }
 
-void ArrayType::outputPost(OutputStream &OS) {
+void ArrayType::outputPost(peekable_raw_ostream &OS) {
   ArrayDimension *D = Dims;
   while (D) {
     OS << "[";
     if (D->Dim > 0)
       OS << D->Dim;
     OS << "]";
     D = D->Next;
   }

 struct BackrefContext {
   static constexpr size_t Max = 10;
 
   Type *FunctionParams[Max];
   size_t FunctionParamCount = 0;
 
   // The first 10 BackReferences in a mangled name can be back-referenced by
   // special name @[0-9]. This is a storage for the first 10 BackReferences.
-  StringView Names[Max];
+  StringRef Names[Max];
   size_t NamesCount = 0;
 };
 
 // Demangler class takes the main role in demangling symbols.
 // It has a set of functions to parse mangled symbols into Type instances.
 // It also has a set of functions to cnovert Type instances to strings.
 class Demangler {
 public:
-  Demangler() = default;
+  Demangler() : Saver(Arena) {}
+
   virtual ~Demangler() = default;
 
   // You are supposed to call parse() first and then check if error is true.  If
   // it is false, call output() to write the formatted name to the given stream.
-  Symbol *parse(StringView &MangledName);
-  Symbol *parseOperator(StringView &MangledName);
+  Symbol *parse(StringRef &MangledName);
+  Symbol *parseOperator(StringRef &MangledName);
 
-  void output(const Symbol *S, OutputStream &OS);
+  void output(const Symbol *S, peekable_raw_ostream &OS);
 
   // True if an error occurred.
   bool Error = false;
 
   void dumpBackReferences();
 
 private:
   std::pair<SymbolCategory, Type *>
-  demangleSymbolCategoryAndType(StringView &MangledName);
+  demangleSymbolCategoryAndType(StringRef &MangledName);
 
-  Type *demangleVariableEncoding(StringView &MangledName, StorageClass SC);
-  Type *demangleFunctionEncoding(StringView &MangledName);
-  uint64_t demangleThunkThisAdjust(StringView &MangledName);
+  Type *demangleVariableEncoding(StringRef &MangledName, StorageClass SC);
+  Type *demangleFunctionEncoding(StringRef &MangledName);
+  uint64_t demangleThunkThisAdjust(StringRef &MangledName);
 
-  Qualifiers demanglePointerExtQualifiers(StringView &MangledName);
+  Qualifiers demanglePointerExtQualifiers(StringRef &MangledName);
 
   // Parser functions. This is a recursive-descent parser.
-  Type *demangleType(StringView &MangledName, QualifierMangleMode QMM);
-  Type *demangleBasicType(StringView &MangledName);
-  UdtType *demangleClassType(StringView &MangledName);
-  PointerType *demanglePointerType(StringView &MangledName);
-  MemberPointerType *demangleMemberPointerType(StringView &MangledName);
-  FunctionType *demangleFunctionType(StringView &MangledName, bool HasThisQuals,
+  Type *demangleType(StringRef &MangledName, QualifierMangleMode QMM);
+  Type *demangleBasicType(StringRef &MangledName);
+  UdtType *demangleClassType(StringRef &MangledName);
+  PointerType *demanglePointerType(StringRef &MangledName);
+  MemberPointerType *demangleMemberPointerType(StringRef &MangledName);
+  FunctionType *demangleFunctionType(StringRef &MangledName, bool HasThisQuals,
                                      bool IsFunctionPointer);
 
-  ArrayType *demangleArrayType(StringView &MangledName);
+  ArrayType *demangleArrayType(StringRef &MangledName);
 
-  TemplateParams *demangleTemplateParameterList(StringView &MangledName);
-  FunctionParams demangleFunctionParameterList(StringView &MangledName);
+  TemplateParams *demangleTemplateParameterList(StringRef &MangledName);
+  FunctionParams demangleFunctionParameterList(StringRef &MangledName);
 
-  std::pair<uint64_t, bool> demangleNumber(StringView &MangledName);
-  uint64_t demangleUnsigned(StringView &MangledName);
-  int64_t demangleSigned(StringView &MangledName);
+  std::pair<uint64_t, bool> demangleNumber(StringRef &MangledName);
+  uint64_t demangleUnsigned(StringRef &MangledName);
+  int64_t demangleSigned(StringRef &MangledName);
 
-  void memorizeString(StringView s);
+  void memorizeString(StringRef s);
 
   /// Allocate a copy of \p Borrowed into memory that we own.
-  StringView copyString(StringView Borrowed);
+  StringRef copyString(StringRef Borrowed);
 
-  Name *demangleFullyQualifiedTypeName(StringView &MangledName);
-  Name *demangleFullyQualifiedSymbolName(StringView &MangledName);
+  Name *demangleFullyQualifiedTypeName(StringRef &MangledName);
+  Name *demangleFullyQualifiedSymbolName(StringRef &MangledName);
 
-  Name *demangleUnqualifiedTypeName(StringView &MangledName, bool Memorize);
-  Name *demangleUnqualifiedSymbolName(StringView &MangledName,
+  Name *demangleUnqualifiedTypeName(StringRef &MangledName, bool Memorize);
+  Name *demangleUnqualifiedSymbolName(StringRef &MangledName,
                                       NameBackrefBehavior NBB);
 
-  Name *demangleNameScopeChain(StringView &MangledName, Name *UnqualifiedName);
-  Name *demangleNameScopePiece(StringView &MangledName);
+  Name *demangleNameScopeChain(StringRef &MangledName, Name *UnqualifiedName);
+  Name *demangleNameScopePiece(StringRef &MangledName);
 
-  Name *demangleBackRefName(StringView &MangledName);
-  Name *demangleTemplateInstantiationName(StringView &MangledName,
+  Name *demangleBackRefName(StringRef &MangledName);
+  Name *demangleTemplateInstantiationName(StringRef &MangledName,
                                           NameBackrefBehavior NBB);
-  std::pair<OperatorTy, Name *> demangleOperatorName(StringView &MangledName,
+  std::pair<OperatorTy, Name *> demangleOperatorName(StringRef &MangledName,
                                                      bool FullyQualified);
-  Name *demangleSimpleName(StringView &MangledName, bool Memorize);
-  Name *demangleAnonymousNamespaceName(StringView &MangledName);
-  Name *demangleLocallyScopedNamePiece(StringView &MangledName);
-  StringLiteral *demangleStringLiteral(StringView &MangledName);
-
-  StringView demangleSimpleString(StringView &MangledName, bool Memorize);
-
-  FuncClass demangleFunctionClass(StringView &MangledName);
-  CallingConv demangleCallingConvention(StringView &MangledName);
-  StorageClass demangleVariableStorageClass(StringView &MangledName);
-  ReferenceKind demangleReferenceKind(StringView &MangledName);
-  void demangleThrowSpecification(StringView &MangledName);
-  wchar_t demangleWcharLiteral(StringView &MangledName);
-  uint8_t demangleCharLiteral(StringView &MangledName);
+  Name *demangleSimpleName(StringRef &MangledName, bool Memorize);
+  Name *demangleAnonymousNamespaceName(StringRef &MangledName);
+  Name *demangleLocallyScopedNamePiece(StringRef &MangledName);
+  StringLiteralSymbol *demangleStringLiteralSymbol(StringRef &MangledName);
+
+  StringRef demangleSimpleString(StringRef &MangledName, bool Memorize);
+
+  FuncClass demangleFunctionClass(StringRef &MangledName);
+  CallingConv demangleCallingConvention(StringRef &MangledName);
+  StorageClass demangleVariableStorageClass(StringRef &MangledName);
+  ReferenceKind demangleReferenceKind(StringRef &MangledName);
+  void demangleThrowSpecification(StringRef &MangledName);
+  wchar_t demangleWcharLiteral(StringRef &MangledName);
+  uint8_t demangleCharLiteral(StringRef &MangledName);
 
-  std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
+  std::pair<Qualifiers, bool> demangleQualifiers(StringRef &MangledName);
 
   // Memory allocator.
-  ArenaAllocator Arena;
+  BumpPtrAllocator Arena;
+
+  StringSaver Saver;
 
   // A single type uses one global back-ref table for all function params.
   // This means back-refs can even go "into" other types.  Examples:
   //
   //  // Second int* is a back-ref to first.
   //  void foo(int *, int*);
   //
   //  // Second int* is not a back-ref to first (first is not a function param).
   //  int* foo(int*);
   //
   //  // Second int* is a back-ref to first (ALL function types share the same
   //  // back-ref map.
   //  using F = void(*)(int*);
   //  F G(int *);
   BackrefContext Backrefs;
 };
 } // namespace
 
-StringView Demangler::copyString(StringView Borrowed) {
-  char *Stable = Arena.allocUnalignedBuffer(Borrowed.size() + 1);
-  std::strcpy(Stable, Borrowed.begin());
-
-  return {Stable, Borrowed.size()};
+StringRef Demangler::copyString(StringRef Borrowed) {
+  return Saver.save(Borrowed);
 }
 
-Symbol *Demangler::parseOperator(StringView &MangledName) {
-  Symbol *S = Arena.alloc<Symbol>();
+Symbol *Demangler::parseOperator(StringRef &MangledName) {
+  Symbol *S = allocate<Symbol>(Arena);
 
   bool IsMember = false;
   OperatorTy OTy;
   std::tie(OTy, S->SymbolName) = demangleOperatorName(MangledName, true);
   switch (OTy) {
-  case OperatorTy::StringLiteral:
+  case OperatorTy::StringLiteralSymbol:
     S->Category = SymbolCategory::SpecialOperator;
     break;
   case OperatorTy::Vcall:
     S->Category = SymbolCategory::UnnamedFunction;
     break;
   case OperatorTy::LocalStaticGuard:
     S->Category = SymbolCategory::UnnamedVariable;
     break;
   case OperatorTy::Vftable:                // Foo@@6B@
   case OperatorTy::LocalVftable:           // Foo@@6B@
   case OperatorTy::RttiCompleteObjLocator: // Foo@@6B@
   case OperatorTy::Vbtable:                // Foo@@7B@
     S->Category = SymbolCategory::UnnamedVariable;
-    switch (MangledName.popFront()) {
+    switch (pop(MangledName)) {
     case '6':
     case '7': {
       std::tie(S->SymbolQuals, IsMember) = demangleQualifiers(MangledName);
-      if (!MangledName.consumeFront('@')) {
-        IndirectTable *Table = Arena.alloc<IndirectTable>(OTy);
+      if (!MangledName.consume_front("@")) {
+        IndirectTable *Table = allocate<IndirectTable>(Arena, OTy);
         Table->TableTarget = demangleFullyQualifiedTypeName(MangledName);
         Table->TableLocation = S->SymbolName;
         S->SymbolName = Table;
       }
       break;
     }
     default:
       Error = true;
       break;
     }
     break;
   case OperatorTy::RttiTypeDescriptor: // <type>@@8
     S->Category = SymbolCategory::UnnamedVariable;
     S->SymbolType = demangleType(MangledName, QualifierMangleMode::Result);
     if (Error)
       break;
-    if (!MangledName.consumeFront("@8"))
+    if (!MangledName.consume_front("@8"))
       Error = true;
     if (!MangledName.empty())
       Error = true;
     break;
   default:
     if (!Error)
       std::tie(S->Category, S->SymbolType) =
           demangleSymbolCategoryAndType(MangledName);
     break;
   }
 
   return (Error) ? nullptr : S;
 }
 
 std::pair<SymbolCategory, Type *>
-Demangler::demangleSymbolCategoryAndType(StringView &MangledName) {
+Demangler::demangleSymbolCategoryAndType(StringRef &MangledName) {
   // Read a variable.
   switch (MangledName.front()) {
   case '0':
   case '1':
   case '2':
   case '3':
   case '4':
     return std::make_pair(
         SymbolCategory::NamedVariable,
         demangleVariableEncoding(MangledName,
                                  demangleVariableStorageClass(MangledName)));
   case '8':
-    MangledName.consumeFront('8');
+    MangledName.consume_front("8");
     return std::pair<SymbolCategory, Type *>(SymbolCategory::UnnamedVariable,
                                              nullptr);
   }
   return std::make_pair(SymbolCategory::NamedFunction,
                         demangleFunctionEncoding(MangledName));
 }
 
 // Parser entry point.
-Symbol *Demangler::parse(StringView &MangledName) {
+Symbol *Demangler::parse(StringRef &MangledName) {
   // We can't demangle MD5 names, just output them as-is.
   // Also, MSVC-style mangled symbols must start with '?'.
-  if (MangledName.startsWith("??@") || !MangledName.startsWith('?')) {
-    Symbol *S = Arena.alloc<Symbol>();
+  if (MangledName.startswith("??@") || !MangledName.startswith("?")) {
+    Symbol *S = allocate<Symbol>(Arena);
     S->Category = SymbolCategory::Unknown;
-    S->SymbolName = Arena.alloc<Name>();
+    S->SymbolName = allocate<Name>(Arena);
     S->SymbolName->Str = MangledName;
     S->SymbolType = nullptr;
-    MangledName = StringView();
+    MangledName = StringRef();
     return S;
   }
 
-  MangledName.consumeFront('?');
+  MangledName.consume_front("?");
 
   // ?$ is a template instantiation, but all other names that start with ? are
   // operators / special names.
-  if (MangledName.startsWith('?') && !MangledName.startsWith("?$"))
+  if (MangledName.startswith("?") && !MangledName.startswith("?$"))
     return parseOperator(MangledName);
 
-  Symbol *S = Arena.alloc<Symbol>();
+  Symbol *S = allocate<Symbol>(Arena);
   // What follows is a main symbol name. This may include namespaces or class
   // back references.
   S->SymbolName = demangleFullyQualifiedSymbolName(MangledName);
   if (Error)
     return nullptr;
 
   std::tie(S->Category, S->SymbolType) =
       demangleSymbolCategoryAndType(MangledName);
 
   if (Error)
     return nullptr;
 
   return S;
 }
 
 // <type-encoding> ::= <storage-class> <variable-type>
 // <storage-class> ::= 0  # private static member
 //                 ::= 1  # protected static member
 //                 ::= 2  # public static member
 //                 ::= 3  # global
 //                 ::= 4  # static local
 
-Type *Demangler::demangleVariableEncoding(StringView &MangledName,
+Type *Demangler::demangleVariableEncoding(StringRef &MangledName,
                                           StorageClass SC) {
   Type *Ty = demangleType(MangledName, QualifierMangleMode::Drop);
 
   Ty->Storage = SC;
 
   // <variable-type> ::= <type> <cvr-qualifiers>
   //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
   switch (Ty->Prim) {

 // This function parses it.
 //
 // <number>               ::= [?] <non-negative integer>
 //
 // <non-negative integer> ::= <decimal digit> # when 1 <= Number <= 10
 //                        ::= <hex digit>+ @  # when Numbrer == 0 or >= 10
 //
 // <hex-digit>            ::= [A-P]           # A = 0, B = 1, ...
-std::pair<uint64_t, bool> Demangler::demangleNumber(StringView &MangledName) {
-  bool IsNegative = MangledName.consumeFront('?');
+std::pair<uint64_t, bool> Demangler::demangleNumber(StringRef &MangledName) {
+  bool IsNegative = MangledName.consume_front("?");
 
-  if (startsWithDigit(MangledName)) {
+  if (startswithDigit(MangledName)) {
     uint64_t Ret = MangledName[0] - '0' + 1;
-    MangledName = MangledName.dropFront(1);
+    MangledName = MangledName.drop_front(1);
     return {Ret, IsNegative};
   }
 
   uint64_t Ret = 0;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     char C = MangledName[i];
     if (C == '@') {
-      MangledName = MangledName.dropFront(i + 1);
+      MangledName = MangledName.drop_front(i + 1);
       return {Ret, IsNegative};
     }
     if ('A' <= C && C <= 'P') {
       Ret = (Ret << 4) + (C - 'A');
       continue;
     }
     break;
   }
 
   Error = true;
   return {0ULL, false};
 }
 
-uint64_t Demangler::demangleUnsigned(StringView &MangledName) {
+uint64_t Demangler::demangleUnsigned(StringRef &MangledName) {
   bool IsNegative = false;
   uint64_t Number = 0;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   if (IsNegative)
     Error = true;
   return Number;
 }
 
-int64_t Demangler::demangleSigned(StringView &MangledName) {
+int64_t Demangler::demangleSigned(StringRef &MangledName) {
   bool IsNegative = false;
   uint64_t Number = 0;
   std::tie(Number, IsNegative) = demangleNumber(MangledName);
   if (Number > INT64_MAX)
     Error = true;
   int64_t I = static_cast<int64_t>(Number);
   return IsNegative ? -I : I;
 }
 
 // First 10 strings can be referenced by special BackReferences ?0, ?1, ..., ?9.
 // Memorize it.
-void Demangler::memorizeString(StringView S) {
+void Demangler::memorizeString(StringRef S) {
   if (Backrefs.NamesCount >= BackrefContext::Max)
     return;
   for (size_t i = 0; i < Backrefs.NamesCount; ++i)
     if (S == Backrefs.Names[i])
       return;
   Backrefs.Names[Backrefs.NamesCount++] = S;
 }
 
-Name *Demangler::demangleBackRefName(StringView &MangledName) {
-  assert(startsWithDigit(MangledName));
+Name *Demangler::demangleBackRefName(StringRef &MangledName) {
+  assert(startswithDigit(MangledName));
 
   size_t I = MangledName[0] - '0';
   if (I >= Backrefs.NamesCount) {
     Error = true;
     return nullptr;
   }
 
-  MangledName = MangledName.dropFront();
-  Name *Node = Arena.alloc<Name>();
+  MangledName = MangledName.drop_front();
+  Name *Node = allocate<Name>(Arena);
   Node->Str = Backrefs.Names[I];
   return Node;
 }
 
-Name *Demangler::demangleTemplateInstantiationName(StringView &MangledName,
+Name *Demangler::demangleTemplateInstantiationName(StringRef &MangledName,
                                                    NameBackrefBehavior NBB) {
-  assert(MangledName.startsWith("?$"));
-  MangledName.consumeFront("?$");
+  assert(MangledName.startswith("?$"));
+  MangledName.consume_front("?$");
 
   BackrefContext OuterContext;
   std::swap(OuterContext, Backrefs);
 
   Name *Node = demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (!Error)
     Node->TParams = demangleTemplateParameterList(MangledName);
 
   std::swap(OuterContext, Backrefs);
   if (Error)
     return nullptr;
 
   Node->IsTemplateInstantiation = true;
 
   if (NBB & NBB_Template) {
+    SmallString<128> Buffer;
+    raw_svector_ostream RawOS(Buffer);
+    peekable_raw_ostream OS(RawOS);
     // Render this class template name into a string buffer so that we can
     // memorize it for the purpose of back-referencing.
-    OutputStream OS = OutputStream::create(nullptr, nullptr, 1024);
     outputName(OS, Node, nullptr);
-    OS << '\0';
-    char *Name = OS.getBuffer();
 
-    StringView Owned = copyString(Name);
+    StringRef Owned = copyString(Buffer);
     memorizeString(Owned);
-    std::free(Name);
   }
 
   return Node;
 }
 
 std::pair<OperatorTy, Name *>
-Demangler::demangleOperatorName(StringView &MangledName, bool FullyQualified) {
-  assert(MangledName.startsWith('?'));
-  MangledName.consumeFront('?');
+Demangler::demangleOperatorName(StringRef &MangledName, bool FullyQualified) {
+  assert(MangledName.startswith("?"));
+  MangledName.consume_front("?");
 
   const OperatorMapEntry *Entry = nullptr;
   for (const auto &MapEntry : OperatorMap) {
-    if (!MangledName.consumeFront(MapEntry.Prefix))
+    if (!MangledName.consume_front(MapEntry.Prefix))
       continue;
     Entry = &MapEntry;
     break;
   }
   if (!Entry) {
     Error = true;
     return std::make_pair(OperatorTy::Unknown, nullptr);
   }
 
   Name *N = nullptr;
   switch (Entry->Operator) {
   case OperatorTy::Vftable:                // Foo@@6B@
   case OperatorTy::LocalVftable:           // Foo@@6B@
   case OperatorTy::RttiCompleteObjLocator: // Foo@@6B@
   case OperatorTy::Vbtable: {              // Foo@@7B@
-    N = Arena.alloc<OperatorInfo>(*Entry);
+    N = allocate<OperatorInfo>(Arena, *Entry);
     if (FullyQualified)
       N = demangleNameScopeChain(MangledName, N);
     break;
   }
 
-  case OperatorTy::StringLiteral:
-    N = demangleStringLiteral(MangledName);
+  case OperatorTy::StringLiteralSymbol:
+    N = demangleStringLiteralSymbol(MangledName);
     break;
   case OperatorTy::LiteralOperator:
-    N = Arena.alloc<OperatorInfo>(*Entry);
+    N = allocate<OperatorInfo>(Arena, *Entry);
     N->Str = demangleSimpleString(MangledName, false);
-    if (!MangledName.consumeFront('@'))
+    if (!MangledName.consume_front("@"))
       Error = true;
     break;
   case OperatorTy::RttiBaseClassDescriptor: {
-    RttiBaseClassDescriptor *Temp = Arena.alloc<RttiBaseClassDescriptor>();
+    RttiBaseClassDescriptor *Temp = allocate<RttiBaseClassDescriptor>(Arena);
     Temp->NVOffset = demangleUnsigned(MangledName);
     Temp->VBPtrOffset = demangleSigned(MangledName);
     Temp->VBTableOffset = demangleUnsigned(MangledName);
     Temp->Flags = demangleUnsigned(MangledName);
     N = (FullyQualified) ? demangleNameScopeChain(MangledName, Temp) : Temp;
     break;
   }
   case OperatorTy::Vcall: {
-    VirtualMemberPtrThunk *Temp = Arena.alloc<VirtualMemberPtrThunk>();
+    VirtualMemberPtrThunk *Temp = allocate<VirtualMemberPtrThunk>(Arena);
     N = demangleNameScopeChain(MangledName, Temp);
     if (Error)
       break;
-    if (!MangledName.consumeFront("$B"))
+    if (!MangledName.consume_front("$B"))
       Error = true;
     Temp->OffsetInVTable = demangleUnsigned(MangledName);
-    if (!MangledName.consumeFront('A'))
+    if (!MangledName.consume_front("A"))
       Error = true;
     Temp->CC = demangleCallingConvention(MangledName);
     break;
   }
   case OperatorTy::RttiTypeDescriptor:
     // This one is just followed by a type, not a name scope.
-    N = Arena.alloc<OperatorInfo>(*Entry);
+    N = allocate<OperatorInfo>(Arena, *Entry);
     break;
   case OperatorTy::LocalStaticGuard: {
-    LocalStaticGuardVariable *Temp = Arena.alloc<LocalStaticGuardVariable>();
+    LocalStaticGuardVariable *Temp = allocate<LocalStaticGuardVariable>(Arena);
     N = (FullyQualified) ? demangleNameScopeChain(MangledName, Temp) : Temp;
-    if (MangledName.consumeFront("4IA"))
+    if (MangledName.consume_front("4IA"))
       Temp->IsVisible = false;
-    else if (MangledName.consumeFront("5"))
+    else if (MangledName.consume_front("5"))
       Temp->IsVisible = true;
     else
       Error = true;
     if (!MangledName.empty())
       Temp->ScopeIndex = demangleUnsigned(MangledName);
     break;
   }
   default:
-    N = Arena.alloc<OperatorInfo>(*Entry);
+    N = allocate<OperatorInfo>(Arena, *Entry);
     N = (FullyQualified) ? demangleNameScopeChain(MangledName, N) : N;
     break;
   }
   if (Error)
     return std::make_pair(OperatorTy::Unknown, nullptr);
 
   return std::make_pair(Entry->Operator, N);
 }
 
-Name *Demangler::demangleSimpleName(StringView &MangledName, bool Memorize) {
-  StringView S = demangleSimpleString(MangledName, Memorize);
+Name *Demangler::demangleSimpleName(StringRef &MangledName, bool Memorize) {
+  StringRef S = demangleSimpleString(MangledName, Memorize);
   if (Error)
     return nullptr;
 
-  Name *Node = Arena.alloc<Name>();
+  Name *Node = allocate<Name>(Arena);
   Node->Str = S;
   return Node;
 }
 
 static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); }
 
 static uint8_t rebasedHexDigitToNumber(char C) {
   assert(isRebasedHexDigit(C));
   return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
 }
 
-uint8_t Demangler::demangleCharLiteral(StringView &MangledName) {
-  if (!MangledName.startsWith('?'))
-    return MangledName.popFront();
+uint8_t Demangler::demangleCharLiteral(StringRef &MangledName) {
+  if (!MangledName.startswith("?"))
+    return pop(MangledName);
 
-  MangledName = MangledName.dropFront();
+  MangledName = MangledName.drop_front();
   if (MangledName.empty())
     goto CharLiteralError;
 
-  if (MangledName.consumeFront('$')) {
+  if (MangledName.consume_front("$")) {
     // Two hex digits
     if (MangledName.size() < 2)
       goto CharLiteralError;
-    StringView Nibbles = MangledName.substr(0, 2);
+    StringRef Nibbles = MangledName.substr(0, 2);
     if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1]))
       goto CharLiteralError;
     // Don't append the null terminator.
     uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]);
     uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]);
-    MangledName = MangledName.dropFront(2);
+    MangledName = MangledName.drop_front(2);
     return (C1 << 4) | C2;
   }
 
-  if (startsWithDigit(MangledName)) {
+  if (startswithDigit(MangledName)) {
     const char *Lookup = ",/\\:. \n\t'-";
     char C = Lookup[MangledName[0] - '0'];
-    MangledName = MangledName.dropFront();
+    MangledName = MangledName.drop_front();
     return C;
   }
 
   if (MangledName[0] >= 'a' && MangledName[0] <= 'z') {
     char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7',
                        '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE',
                        '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5',
                        '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'};
     char C = Lookup[MangledName[0] - 'a'];
-    MangledName = MangledName.dropFront();
+    MangledName = MangledName.drop_front();
     return C;
   }
 
   if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
     char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7',
                        '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE',
                        '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5',
                        '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'};
     char C = Lookup[MangledName[0] - 'A'];
-    MangledName = MangledName.dropFront();
+    MangledName = MangledName.drop_front();
     return C;
   }
 
 CharLiteralError:
   Error = true;
   return '\0';
 }
 
-wchar_t Demangler::demangleWcharLiteral(StringView &MangledName) {
+wchar_t Demangler::demangleWcharLiteral(StringRef &MangledName) {
   uint8_t C1, C2;
 
   C1 = demangleCharLiteral(MangledName);
   if (Error)
     goto WCharLiteralError;
   C2 = demangleCharLiteral(MangledName);
   if (Error)
     goto WCharLiteralError;
 
   return ((wchar_t)C1 << 8) | (wchar_t)C2;
 
 WCharLiteralError:
   Error = true;
   return L'\0';
 }
 
 static void writeHexDigit(char *Buffer, uint8_t Digit) {
   assert(Digit <= 15);
   *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10);
 }
 
-static void outputHex(OutputStream &OS, unsigned C) {
+static void outputHex(peekable_raw_ostream &OS, unsigned C) {
   if (C == 0) {
     OS << "\\x00";
     return;
   }
   // It's easier to do the math if we can work from right to left, but we need
   // to print the numbers from left to right.  So render this into a temporary
   // buffer first, then output the temporary buffer.  Each byte is of the form
   // \xAB, which means that each byte needs 4 characters.  Since there are at
   // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer.
   char TempBuffer[17];
 
   ::memset(TempBuffer, 0, sizeof(TempBuffer));
   constexpr int MaxPos = 15;
 
   int Pos = MaxPos - 1;
   while (C != 0) {
     for (int I = 0; I < 2; ++I) {
       writeHexDigit(&TempBuffer[Pos--], C % 16);
       C /= 16;
     }
     TempBuffer[Pos--] = 'x';
     TempBuffer[Pos--] = '\\';
     assert(Pos >= 0);
   }
-  OS << StringView(&TempBuffer[Pos + 1]);
+  OS << StringRef(&TempBuffer[Pos + 1]);
 }
 
-static void outputEscapedChar(OutputStream &OS, unsigned C) {
+static void outputEscapedChar(peekable_raw_ostream &OS, unsigned C) {
   switch (C) {
   case '\'': // single quote
     OS << "\\\'";
     return;
   case '\"': // double quote
     OS << "\\\"";
     return;
   case '\\': // backslash
static unsigned decodeMultiByteChar(const uint8_t *StringBytes,
   StringBytes = StringBytes + Offset;
   for (unsigned I = 0; I < CharBytes; ++I) {
     unsigned C = static_cast<unsigned>(StringBytes[I]);
     Result |= C << (8 * I);
   }
   return Result;
 }
 
-StringLiteral *Demangler::demangleStringLiteral(StringView &MangledName) {
+StringLiteralSymbol *Demangler::demangleStringLiteralSymbol(StringRef &MangledName) {
   // This function uses goto, so declare all variables up front.
-  OutputStream OS;
-  StringView CRC;
+  SmallString<64> Buffer;
+  raw_svector_ostream RawOS(Buffer);
+  peekable_raw_ostream OS(RawOS);
+  StringRef CRC;
   uint64_t StringByteSize;
   bool IsWcharT = false;
   bool IsNegative = false;
   size_t CrcEndPos = 0;
-  char *ResultBuffer = nullptr;
 
-  StringLiteral *Result = Arena.alloc<StringLiteral>();
+  StringLiteralSymbol *Result = allocate<StringLiteralSymbol>(Arena);
 
   // Prefix indicating the beginning of a string literal
-  if (!MangledName.consumeFront("@_"))
-    goto StringLiteralError;
+  if (!MangledName.consume_front("@_"))
+    goto StringLiteralSymbolError;
   if (MangledName.empty())
-    goto StringLiteralError;
+    goto StringLiteralSymbolError;
 
   // Char Type (regular or wchar_t)
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   case '1':
     IsWcharT = true;
     LLVM_FALLTHROUGH;
   case '0':
     break;
   default:
-    goto StringLiteralError;
+    goto StringLiteralSymbolError;
   }
 
   // Encoded Length
   std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
   if (Error || IsNegative)
-    goto StringLiteralError;
+    goto StringLiteralSymbolError;
 
   // CRC 32 (always 8 characters plus a terminator)
   CrcEndPos = MangledName.find('@');
-  if (CrcEndPos == StringView::npos)
-    goto StringLiteralError;
+  if (CrcEndPos == StringRef::npos)
+    goto StringLiteralSymbolError;
   CRC = MangledName.substr(0, CrcEndPos);
-  MangledName = MangledName.dropFront(CrcEndPos + 1);
+  MangledName = MangledName.drop_front(CrcEndPos + 1);
   if (MangledName.empty())
-    goto StringLiteralError;
+    goto StringLiteralSymbolError;
 
-  OS = OutputStream::create(nullptr, nullptr, 1024);
   if (IsWcharT) {
     Result->CharType = PrimTy::Wchar;
     if (StringByteSize > 64)
       Result->IsTruncated = true;
 
-    while (!MangledName.consumeFront('@')) {
+    while (!MangledName.consume_front("@")) {
       assert(StringByteSize >= 2);
       wchar_t W = demangleWcharLiteral(MangledName);
       if (StringByteSize != 2 || Result->IsTruncated)
         outputEscapedChar(OS, W);
       StringByteSize -= 2;
       if (Error)
-        goto StringLiteralError;
+        goto StringLiteralSymbolError;
     }
   } else {
     if (StringByteSize > 32)
       Result->IsTruncated = true;
 
     constexpr unsigned MaxStringByteLength = 32;
     uint8_t StringBytes[MaxStringByteLength];
 
     unsigned BytesDecoded = 0;
-    while (!MangledName.consumeFront('@')) {
+    while (!MangledName.consume_front("@")) {
       assert(StringByteSize >= 1);
       StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
     }
 
     unsigned CharBytes =
         guessCharByteSize(StringBytes, BytesDecoded, StringByteSize);
     assert(StringByteSize % CharBytes == 0);
     switch (CharBytes) {
if (IsWcharT) {
     for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) {
       unsigned NextChar =
           decodeMultiByteChar(StringBytes, CharIndex, CharBytes);
       if (CharIndex + 1 < NumChars || Result->IsTruncated)
         outputEscapedChar(OS, NextChar);
     }
   }
 
-  OS << '\0';
-  ResultBuffer = OS.getBuffer();
-  Result->Str = copyString(ResultBuffer);
-  std::free(ResultBuffer);
+  Result->Str = copyString(Buffer);
   return Result;
 
-StringLiteralError:
+StringLiteralSymbolError:
   Error = true;
   return nullptr;
 }
 
-StringView Demangler::demangleSimpleString(StringView &MangledName,
+StringRef Demangler::demangleSimpleString(StringRef &MangledName,
                                            bool Memorize) {
-  StringView S;
+  StringRef S;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     if (MangledName[i] != '@')
       continue;
     S = MangledName.substr(0, i);
-    MangledName = MangledName.dropFront(i + 1);
+    MangledName = MangledName.drop_front(i + 1);
 
     if (Memorize)
       memorizeString(S);
     return S;
   }
 
   Error = true;
   return {};
 }
 
-Name *Demangler::demangleAnonymousNamespaceName(StringView &MangledName) {
-  assert(MangledName.startsWith("?A"));
-  MangledName.consumeFront("?A");
+Name *Demangler::demangleAnonymousNamespaceName(StringRef &MangledName) {
+  assert(MangledName.startswith("?A"));
+  MangledName.consume_front("?A");
 
-  Name *Node = Arena.alloc<Name>();
+  Name *Node = allocate<Name>(Arena);
   Node->Str = "`anonymous namespace'";
   size_t EndPos = MangledName.find('@');
-  if (EndPos == StringView::npos) {
+  if (EndPos == StringRef::npos) {
     Error = true;
     return nullptr;
   }
-  StringView NamespaceKey = MangledName.substr(0, EndPos);
+  StringRef NamespaceKey = MangledName.substr(0, EndPos);
   memorizeString(NamespaceKey);
   MangledName = MangledName.substr(EndPos + 1);
   return Node;
 }
 
-Name *Demangler::demangleLocallyScopedNamePiece(StringView &MangledName) {
-  assert(startsWithLocalScopePattern(MangledName));
+Name *Demangler::demangleLocallyScopedNamePiece(StringRef &MangledName) {
+  assert(startswithLocalScopePattern(MangledName));
 
-  Name *Node = Arena.alloc<Name>();
-  MangledName.consumeFront('?');
+  Name *Node = allocate<Name>(Arena);
+  MangledName.consume_front("?");
   auto Number = demangleNumber(MangledName);
   assert(!Number.second);
 
   // One ? to terminate the number
-  MangledName.consumeFront('?');
+  MangledName.consume_front("?");
 
   assert(!Error);
   Symbol *Scope = parse(MangledName);
   if (Error)
     return nullptr;
 
   // Render the parent symbol's name into a buffer.
-  OutputStream OS = OutputStream::create(nullptr, nullptr, 1024);
+  SmallString<128> Buffer;
+  raw_svector_ostream RawOS(Buffer);
+  peekable_raw_ostream OS(RawOS);
   OS << '`';
   output(Scope, OS);
   OS << '\'';
   OS << "::`" << Number.first << "'";
-  OS << '\0';
-  char *Result = OS.getBuffer();
-  Node->Str = copyString(Result);
-  std::free(Result);
+  Node->Str = copyString(Buffer);
   return Node;
 }
 
 // Parses a type name in the form of A@B@C@@ which represents C::B::A.
-Name *Demangler::demangleFullyQualifiedTypeName(StringView &MangledName) {
+Name *Demangler::demangleFullyQualifiedTypeName(StringRef &MangledName) {
   Name *TypeName = demangleUnqualifiedTypeName(MangledName, true);
   if (Error)
     return nullptr;
   assert(TypeName);
 
   Name *QualName = demangleNameScopeChain(MangledName, TypeName);
   if (Error)
     return nullptr;
   assert(QualName);
   return QualName;
 }
 
 // Parses a symbol name in the form of A@B@C@@ which represents C::B::A.
 // Symbol names have slightly different rules regarding what can appear
 // so we separate out the implementations for flexibility.
-Name *Demangler::demangleFullyQualifiedSymbolName(StringView &MangledName) {
+Name *Demangler::demangleFullyQualifiedSymbolName(StringRef &MangledName) {
   // This is the final component of a symbol name (i.e. the leftmost component
   // of a mangled name.  Since the only possible template instantiation that
   // can appear in this context is a function template, and since those are
   // not saved for the purposes of name backreferences, only backref simple
   // names.
   Name *SymbolName = demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (Error)
     return nullptr;
 
   Name *QualName = demangleNameScopeChain(MangledName, SymbolName);
   if (Error)
     return nullptr;
   assert(QualName);
   return QualName;
 }
 
-Name *Demangler::demangleUnqualifiedTypeName(StringView &MangledName,
+Name *Demangler::demangleUnqualifiedTypeName(StringRef &MangledName,
                                              bool Memorize) {
   // An inner-most name can be a back-reference, because a fully-qualified name
   // (e.g. Scope + Inner) can contain other fully qualified names inside of
   // them (for example template parameters), and these nested parameters can
   // refer to previously mangled types.
-  if (startsWithDigit(MangledName))
+  if (startswithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
-  if (MangledName.startsWith("?$"))
+  if (MangledName.startswith("?$"))
     return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
   return demangleSimpleName(MangledName, Memorize);
 }
 
-Name *Demangler::demangleUnqualifiedSymbolName(StringView &MangledName,
+Name *Demangler::demangleUnqualifiedSymbolName(StringRef &MangledName,
                                                NameBackrefBehavior NBB) {
-  if (startsWithDigit(MangledName))
+  if (startswithDigit(MangledName))
     return demangleBackRefName(MangledName);
-  if (MangledName.startsWith("?$"))
+  if (MangledName.startswith("?$"))
     return demangleTemplateInstantiationName(MangledName, NBB);
-  if (MangledName.startsWith('?'))
+  if (MangledName.startswith("?"))
     return demangleOperatorName(MangledName, false).second;
   return demangleSimpleName(MangledName, (NBB & NBB_Simple) != 0);
 }
 
-Name *Demangler::demangleNameScopePiece(StringView &MangledName) {
-  if (startsWithDigit(MangledName))
+Name *Demangler::demangleNameScopePiece(StringRef &MangledName) {
+  if (startswithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
-  if (MangledName.startsWith("?$"))
+  if (MangledName.startswith("?$"))
     return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
-  if (MangledName.startsWith("?A"))
+  if (MangledName.startswith("?A"))
     return demangleAnonymousNamespaceName(MangledName);
 
-  if (startsWithLocalScopePattern(MangledName))
+  if (startswithLocalScopePattern(MangledName))
     return demangleLocallyScopedNamePiece(MangledName);
 
   return demangleSimpleName(MangledName, true);
 }
 
-Name *Demangler::demangleNameScopeChain(StringView &MangledName,
+Name *Demangler::demangleNameScopeChain(StringRef &MangledName,
                                         Name *UnqualifiedName) {
   Name *Head = UnqualifiedName;
 
-  while (!MangledName.consumeFront("@")) {
+  while (!MangledName.consume_front("@")) {
     if (MangledName.empty()) {
       Error = true;
       return nullptr;
     }
 
     assert(!Error);
     Name *Elem = demangleNameScopePiece(MangledName);
     if (Error)
       return nullptr;
 
     Elem->Next = Head;
     Head = Elem;
   }
   return Head;
 }
 
-FuncClass Demangler::demangleFunctionClass(StringView &MangledName) {
-  SwapAndRestore<StringView> RestoreOnError(MangledName, MangledName);
-  RestoreOnError.shouldRestore(false);
-
-  switch (MangledName.popFront()) {
+FuncClass Demangler::demangleFunctionClass(StringRef &MangledName) {
+  switch (pop(MangledName)) {
   case '9':
     return FuncClass(ExternC | NoPrototype);
   case 'A':
     return Private;
   case 'B':
     return FuncClass(Private | Far);
   case 'C':
     return FuncClass(Private | Static);
FuncClass Demangler::demangleFunctionClass(StringRef &MangledName) {
   case 'X':
     return FuncClass(Public | Virtual | StaticThisAdjust | Far);
   case 'Y':
     return FuncClass(Global);
   case 'Z':
     return FuncClass(Global | Far);
   case '$': {
     FuncClass VFlag = VirtualThisAdjust;
-    if (MangledName.consumeFront('R'))
+    if (MangledName.consume_front("R"))
       VFlag = FuncClass(VFlag | VirtualThisAdjustEx);
 
-    switch (MangledName.popFront()) {
+    switch (pop(MangledName)) {
     case '0':
       return FuncClass(Private | Virtual | VFlag);
     case '1':
       return FuncClass(Private | Virtual | VFlag | Far);
     case '2':
       return FuncClass(Protected | Virtual | VFlag);
     case '3':
       return FuncClass(Protected | Virtual | VFlag | Far);
     case '4':
       return FuncClass(Public | Virtual | VFlag);
     case '5':
       return FuncClass(Public | Virtual | VFlag | Far);
     }
   }
   }
 
   Error = true;
-  RestoreOnError.shouldRestore(true);
   return Public;
 }
 
-CallingConv Demangler::demangleCallingConvention(StringView &MangledName) {
-  switch (MangledName.popFront()) {
+CallingConv Demangler::demangleCallingConvention(StringRef &MangledName) {
+  switch (pop(MangledName)) {
   case 'A':
   case 'B':
     return CallingConv::Cdecl;
   case 'C':
   case 'D':
     return CallingConv::Pascal;
   case 'E':
   case 'F':
case 'P':
     return CallingConv::Eabi;
   case 'Q':
     return CallingConv::Vectorcall;
   }
 
   return CallingConv::None;
 }
 
-StorageClass Demangler::demangleVariableStorageClass(StringView &MangledName) {
+StorageClass Demangler::demangleVariableStorageClass(StringRef &MangledName) {
   assert(std::isdigit(MangledName.front()));
 
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   case '0':
     return StorageClass::PrivateStatic;
   case '1':
     return StorageClass::ProtectedStatic;
   case '2':
     return StorageClass::PublicStatic;
   case '3':
     return StorageClass::Global;
   case '4':
     return StorageClass::FunctionLocalStatic;
   }
   Error = true;
   return StorageClass::None;
 }
 
 std::pair<Qualifiers, bool>
-Demangler::demangleQualifiers(StringView &MangledName) {
+Demangler::demangleQualifiers(StringRef &MangledName) {
 
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   // Member qualifiers
   case 'Q':
     return std::make_pair(Q_None, true);
   case 'R':
     return std::make_pair(Q_Const, true);
   case 'S':
     return std::make_pair(Q_Volatile, true);
   case 'T':
     return std::make_pair(Qualifiers(Q_Const | Q_Volatile), true);
   // Non-Member qualifiers
   case 'A':
     return std::make_pair(Q_None, false);
   case 'B':
     return std::make_pair(Q_Const, false);
   case 'C':
     return std::make_pair(Q_Volatile, false);
   case 'D':
     return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false);
   }
   Error = true;
   return std::make_pair(Q_None, false);
 }
 
-static bool isTagType(StringView S) {
+static bool isTagType(StringRef S) {
   switch (S.front()) {
   case 'T': // union
   case 'U': // struct
   case 'V': // class
   case 'W': // enum
     return true;
   }
   return false;
 }
 
-static bool isPointerType(StringView S) {
-  if (S.startsWith("$$Q")) // foo &&
+static bool isPointerType(StringRef S) {
+  if (S.startswith("$$Q")) // foo &&
     return true;
 
   switch (S.front()) {
   case 'A': // foo &
   case 'P': // foo *
   case 'Q': // foo *const
   case 'R': // foo *volatile
   case 'S': // foo *const volatile
     return true;
   }
   return false;
 }
 
-static bool isArrayType(StringView S) { return S[0] == 'Y'; }
+static bool isArrayType(StringRef S) { return S[0] == 'Y'; }
 
-static bool isFunctionType(StringView S) {
-  return S.startsWith("$$A8@@") || S.startsWith("$$A6");
+static bool isFunctionType(StringRef S) {
+  return S.startswith("$$A8@@") || S.startswith("$$A6");
 }
 
 // <variable-type> ::= <type> <cvr-qualifiers>
 //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
-Type *Demangler::demangleType(StringView &MangledName,
+Type *Demangler::demangleType(StringRef &MangledName,
                               QualifierMangleMode QMM) {
   Qualifiers Quals = Q_None;
   bool IsMember = false;
   if (QMM == QualifierMangleMode::Mangle) {
     std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
   } else if (QMM == QualifierMangleMode::Result) {
-    if (MangledName.consumeFront('?'))
+    if (MangledName.consume_front("?"))
       std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
   }
 
   Type *Ty = nullptr;
   if (isTagType(MangledName))
     Ty = demangleClassType(MangledName);
   else if (isPointerType(MangledName)) {
     if (isMemberPointer(MangledName))
       Ty = demangleMemberPointerType(MangledName);
     else
       Ty = demanglePointerType(MangledName);
   } else if (isArrayType(MangledName))
     Ty = demangleArrayType(MangledName);
   else if (isFunctionType(MangledName)) {
-    if (MangledName.consumeFront("$$A8@@"))
+    if (MangledName.consume_front("$$A8@@"))
       Ty = demangleFunctionType(MangledName, true, false);
     else {
-      assert(MangledName.startsWith("$$A6"));
-      MangledName.consumeFront("$$A6");
+      assert(MangledName.startswith("$$A6"));
+      MangledName.consume_front("$$A6");
       Ty = demangleFunctionType(MangledName, false, false);
     }
   } else {
     Ty = demangleBasicType(MangledName);
     assert(Ty && !Error);
     if (!Ty || Error)
       return Ty;
   }
 
   Ty->Quals = Qualifiers(Ty->Quals | Quals);
   return Ty;
 }
 
-ReferenceKind Demangler::demangleReferenceKind(StringView &MangledName) {
-  if (MangledName.consumeFront('G'))
+ReferenceKind Demangler::demangleReferenceKind(StringRef &MangledName) {
+  if (MangledName.consume_front("G"))
     return ReferenceKind::LValueRef;
-  else if (MangledName.consumeFront('H'))
+  else if (MangledName.consume_front("H"))
     return ReferenceKind::RValueRef;
   return ReferenceKind::None;
 }
 
-void Demangler::demangleThrowSpecification(StringView &MangledName) {
-  if (MangledName.consumeFront('Z'))
+void Demangler::demangleThrowSpecification(StringRef &MangledName) {
+  if (MangledName.consume_front("Z"))
     return;
 
   Error = true;
 }
 
-FunctionType *Demangler::demangleFunctionType(StringView &MangledName,
+FunctionType *Demangler::demangleFunctionType(StringRef &MangledName,
                                               bool HasThisQuals,
                                               bool IsFunctionPointer) {
-  FunctionType *FTy = Arena.alloc<FunctionType>();
+  FunctionType *FTy = allocate<FunctionType>(Arena);
   FTy->Prim = PrimTy::Function;
   FTy->IsFunctionPointer = IsFunctionPointer;
 
   if (HasThisQuals) {
     FTy->Quals = demanglePointerExtQualifiers(MangledName);
     FTy->RefKind = demangleReferenceKind(MangledName);
     FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
   }
 
   // Fields that appear on both member and non-member functions.
   FTy->CallConvention = demangleCallingConvention(MangledName);
 
   // <return-type> ::= <type>
   //               ::= @ # structors (they have no declared return type)
-  bool IsStructor = MangledName.consumeFront('@');
+  bool IsStructor = MangledName.consume_front("@");
   if (!IsStructor)
     FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result);
 
   FTy->Params = demangleFunctionParameterList(MangledName);
 
   demangleThrowSpecification(MangledName);
 
   return FTy;
 }
 
-Type *Demangler::demangleFunctionEncoding(StringView &MangledName) {
+Type *Demangler::demangleFunctionEncoding(StringRef &MangledName) {
   FuncClass ExtraFlags = FuncClass::None;
-  if (MangledName.consumeFront("$$J0"))
+  if (MangledName.consume_front("$$J0"))
     ExtraFlags = FuncClass::ExternC;
 
   FuncClass FC = demangleFunctionClass(MangledName);
   FC = FuncClass(ExtraFlags | FC);
 
   FunctionType::ThisAdjustor *Adjustor = nullptr;
   if (FC & FuncClass::StaticThisAdjust) {
-    Adjustor = Arena.alloc<FunctionType::ThisAdjustor>();
+    Adjustor = allocate<FunctionType::ThisAdjustor>(Arena);
     Adjustor->StaticOffset = demangleSigned(MangledName);
   } else if (FC & FuncClass::VirtualThisAdjust) {
-    Adjustor = Arena.alloc<FunctionType::ThisAdjustor>();
+    Adjustor = allocate<FunctionType::ThisAdjustor>(Arena);
     if (FC & FuncClass::VirtualThisAdjustEx) {
       Adjustor->VBPtrOffset = demangleSigned(MangledName);
       Adjustor->VBOffsetOffset = demangleSigned(MangledName);
     }
     Adjustor->VtordispOffset = demangleSigned(MangledName);
     Adjustor->StaticOffset = demangleSigned(MangledName);
   }
 
   FunctionType *FTy = nullptr;
   if (FC & NoPrototype) {
     // This is an extern "C" function whose full signature hasn't been mangled.
     // This happens when we need to mangle a local symbol inside of an extern
     // "C" function.
-    FTy = Arena.alloc<FunctionType>();
+    FTy = allocate<FunctionType>(Arena);
   } else {
     bool HasThisQuals = !(FC & (Global | Static));
     FTy = demangleFunctionType(MangledName, HasThisQuals, false);
   }
   FTy->ThisAdjust = Adjustor;
   FTy->FunctionClass = FC;
 
   return FTy;
 }
 
 // Reads a primitive type.
-Type *Demangler::demangleBasicType(StringView &MangledName) {
-  Type *Ty = Arena.alloc<Type>();
+Type *Demangler::demangleBasicType(StringRef &MangledName) {
+  Type *Ty = allocate<Type>(Arena);
 
-  if (MangledName.consumeFront("$$T")) {
+  if (MangledName.consume_front("$$T")) {
     Ty->Prim = PrimTy::Nullptr;
     return Ty;
   }
-  if (MangledName.consumeFront("?")) {
+  if (MangledName.consume_front("?")) {
     Ty->Prim = PrimTy::Custom;
     Ty->Custom = demangleSimpleString(MangledName, false);
-    if (!MangledName.consumeFront('@')) {
+    if (!MangledName.consume_front("@")) {
       Error = true;
       return nullptr;
     }
     return Ty;
   }
 
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   case 'X':
     Ty->Prim = PrimTy::Void;
     break;
   case 'D':
     Ty->Prim = PrimTy::Char;
     break;
   case 'C':
     Ty->Prim = PrimTy::Schar;
Type *Demangler::demangleBasicType(StringRef &MangledName) {
   case 'O':
     Ty->Prim = PrimTy::Ldouble;
     break;
   case '_': {
     if (MangledName.empty()) {
       Error = true;
       return nullptr;
     }
-    switch (MangledName.popFront()) {
+    switch (pop(MangledName)) {
     case 'N':
       Ty->Prim = PrimTy::Bool;
       break;
     case 'J':
       Ty->Prim = PrimTy::Int64;
       break;
     case 'K':
       Ty->Prim = PrimTy::Uint64;
Type *Demangler::demangleBasicType(StringRef &MangledName) {
   }
   default:
     Error = true;
     return nullptr;
   }
   return Ty;
 }
 
-UdtType *Demangler::demangleClassType(StringView &MangledName) {
-  UdtType *UTy = Arena.alloc<UdtType>();
+UdtType *Demangler::demangleClassType(StringRef &MangledName) {
+  UdtType *UTy = allocate<UdtType>(Arena);
 
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   case 'T':
     UTy->Prim = PrimTy::Union;
     break;
   case 'U':
     UTy->Prim = PrimTy::Struct;
     break;
   case 'V':
     UTy->Prim = PrimTy::Class;
     break;
   case 'W':
-    if (MangledName.popFront() != '4') {
+    if (pop(MangledName) != '4') {
       Error = true;
       return nullptr;
     }
     UTy->Prim = PrimTy::Enum;
     break;
   default:
     assert(false);
   }
 
   UTy->UdtName = demangleFullyQualifiedTypeName(MangledName);
   return UTy;
 }
 
 static std::pair<Qualifiers, PointerAffinity>
-demanglePointerCVQualifiers(StringView &MangledName) {
-  if (MangledName.consumeFront("$$Q"))
+demanglePointerCVQualifiers(StringRef &MangledName) {
+  if (MangledName.consume_front("$$Q"))
     return std::make_pair(Q_None, PointerAffinity::RValueReference);
 
-  switch (MangledName.popFront()) {
+  switch (pop(MangledName)) {
   case 'A':
     return std::make_pair(Q_None, PointerAffinity::Reference);
   case 'P':
     return std::make_pair(Q_None, PointerAffinity::Pointer);
   case 'Q':
     return std::make_pair(Q_Const, PointerAffinity::Pointer);
   case 'R':
     return std::make_pair(Q_Volatile, PointerAffinity::Pointer);
   case 'S':
     return std::make_pair(Qualifiers(Q_Const | Q_Volatile),
                           PointerAffinity::Pointer);
   default:
     assert(false && "Ty is not a pointer type!");
   }
   return std::make_pair(Q_None, PointerAffinity::Pointer);
 }
 
 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type>
 //                       # the E is required for 64-bit non-static pointers
-PointerType *Demangler::demanglePointerType(StringView &MangledName) {
-  PointerType *Pointer = Arena.alloc<PointerType>();
+PointerType *Demangler::demanglePointerType(StringRef &MangledName) {
+  PointerType *Pointer = allocate<PointerType>(Arena);
 
   std::tie(Pointer->Quals, Pointer->Affinity) =
       demanglePointerCVQualifiers(MangledName);
 
   Pointer->Prim = PrimTy::Ptr;
-  if (MangledName.consumeFront("6")) {
+  if (MangledName.consume_front("6")) {
     Pointer->Pointee = demangleFunctionType(MangledName, false, true);
     return Pointer;
   }
 
   Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
   Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
   Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle);
   return Pointer;
 }
 
 MemberPointerType *
-Demangler::demangleMemberPointerType(StringView &MangledName) {
-  MemberPointerType *Pointer = Arena.alloc<MemberPointerType>();
+Demangler::demangleMemberPointerType(StringRef &MangledName) {
+  MemberPointerType *Pointer = allocate<MemberPointerType>(Arena);
   Pointer->Prim = PrimTy::MemberPtr;
 
   PointerAffinity Affinity;
   std::tie(Pointer->Quals, Affinity) = demanglePointerCVQualifiers(MangledName);
   assert(Affinity == PointerAffinity::Pointer);
 
   Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
   Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
-  if (MangledName.consumeFront("8")) {
+  if (MangledName.consume_front("8")) {
     Pointer->MemberName = demangleFullyQualifiedSymbolName(MangledName);
     Pointer->Pointee = demangleFunctionType(MangledName, true, true);
   } else {
     Qualifiers PointeeQuals = Q_None;
     bool IsMember = false;
     std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName);
     assert(IsMember);
     Pointer->MemberName = demangleFullyQualifiedSymbolName(MangledName);
 
     Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop);
     Pointer->Pointee->Quals = PointeeQuals;
   }
 
   return Pointer;
 }
 
-Qualifiers Demangler::demanglePointerExtQualifiers(StringView &MangledName) {
+Qualifiers Demangler::demanglePointerExtQualifiers(StringRef &MangledName) {
   Qualifiers Quals = Q_None;
-  if (MangledName.consumeFront('E'))
+  if (MangledName.consume_front("E"))
     Quals = Qualifiers(Quals | Q_Pointer64);
-  if (MangledName.consumeFront('I'))
+  if (MangledName.consume_front("I"))
     Quals = Qualifiers(Quals | Q_Restrict);
-  if (MangledName.consumeFront('F'))
+  if (MangledName.consume_front("F"))
     Quals = Qualifiers(Quals | Q_Unaligned);
 
   return Quals;
 }
 
-ArrayType *Demangler::demangleArrayType(StringView &MangledName) {
+ArrayType *Demangler::demangleArrayType(StringRef &MangledName) {
   assert(MangledName.front() == 'Y');
-  MangledName.popFront();
+  pop(MangledName);
 
   uint64_t Rank = 0;
   bool IsNegative = false;
   std::tie(Rank, IsNegative) = demangleNumber(MangledName);
   if (IsNegative || Rank == 0) {
     Error = true;
     return nullptr;
   }
 
-  ArrayType *ATy = Arena.alloc<ArrayType>();
+  ArrayType *ATy = allocate<ArrayType>(Arena);
   ATy->Prim = PrimTy::Array;
-  ATy->Dims = Arena.alloc<ArrayDimension>();
+  ATy->Dims = allocate<ArrayDimension>(Arena);
   ArrayDimension *Dim = ATy->Dims;
   for (uint64_t I = 0; I < Rank; ++I) {
     std::tie(Dim->Dim, IsNegative) = demangleNumber(MangledName);
     if (IsNegative) {
       Error = true;
       return nullptr;
     }
     if (I + 1 < Rank) {
-      Dim->Next = Arena.alloc<ArrayDimension>();
+      Dim->Next = allocate<ArrayDimension>(Arena);
       Dim = Dim->Next;
     }
   }
 
-  if (MangledName.consumeFront("$$C")) {
+  if (MangledName.consume_front("$$C")) {
     bool IsMember = false;
     std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName);
     if (IsMember) {
       Error = true;
       return nullptr;
     }
   }
 
   ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop);
   return ATy;
 }
 
 // Reads a function or a template parameters.
 FunctionParams
-Demangler::demangleFunctionParameterList(StringView &MangledName) {
+Demangler::demangleFunctionParameterList(StringRef &MangledName) {
   // Empty parameter list.
-  if (MangledName.consumeFront('X'))
+  if (MangledName.consume_front("X"))
     return {};
 
   FunctionParams *Head;
   FunctionParams **Current = &Head;
-  while (!Error && !MangledName.startsWith('@') &&
-         !MangledName.startsWith('Z')) {
+  while (!Error && !MangledName.startswith("@") &&
+         !MangledName.startswith("Z")) {
 
-    if (startsWithDigit(MangledName)) {
+    if (startswithDigit(MangledName)) {
       size_t N = MangledName[0] - '0';
       if (N >= Backrefs.FunctionParamCount) {
         Error = true;
         return {};
       }
-      MangledName = MangledName.dropFront();
+      MangledName = MangledName.drop_front();
 
-      *Current = Arena.alloc<FunctionParams>();
+      *Current = allocate<FunctionParams>(Arena);
       (*Current)->Current = Backrefs.FunctionParams[N]->clone(Arena);
       Current = &(*Current)->Next;
       continue;
     }
 
     size_t OldSize = MangledName.size();
 
-    *Current = Arena.alloc<FunctionParams>();
+    *Current = allocate<FunctionParams>(Arena);
     (*Current)->Current = demangleType(MangledName, QualifierMangleMode::Drop);
 
     size_t CharsConsumed = OldSize - MangledName.size();
     assert(CharsConsumed != 0);
 
     // Single-letter types are ignored for backreferences because memorizing
     // them doesn't save anything.
     if (Backrefs.FunctionParamCount <= 9 && CharsConsumed > 1)
       Backrefs.FunctionParams[Backrefs.FunctionParamCount++] =
           (*Current)->Current;
 
     Current = &(*Current)->Next;
   }
 
   if (Error)
     return {};
 
   // A non-empty parameter list is terminated by either 'Z' (variadic) parameter
   // list or '@' (non variadic).  Careful not to consume "@Z", as in that case
   // the following Z could be a throw specifier.
-  if (MangledName.consumeFront('@'))
+  if (MangledName.consume_front("@"))
     return *Head;
 
-  if (MangledName.consumeFront('Z')) {
+  if (MangledName.consume_front("Z")) {
     Head->IsVariadic = true;
     return *Head;
   }
 
   Error = true;
   return {};
 }
 
 TemplateParams *
-Demangler::demangleTemplateParameterList(StringView &MangledName) {
+Demangler::demangleTemplateParameterList(StringRef &MangledName) {
   TemplateParams *Head;
   TemplateParams **Current = &Head;
-  while (!Error && !MangledName.startsWith('@')) {
+  while (!Error && !MangledName.startswith("@")) {
     // Template parameter lists don't participate in back-referencing.
-    *Current = Arena.alloc<TemplateParams>();
+    *Current = allocate<TemplateParams>(Arena);
 
     TemplateParams &TP = **Current;
 
     // Empty parameter pack.
-    if (MangledName.consumeFront("$S") || MangledName.consumeFront("$$V") ||
-        MangledName.consumeFront("$$$V")) {
+    if (MangledName.consume_front("$S") || MangledName.consume_front("$$V") ||
+        MangledName.consume_front("$$$V")) {
       TP.IsEmptyParameterPack = true;
-    } else if (MangledName.consumeFront("$$Y")) {
+    } else if (MangledName.consume_front("$$Y")) {
       // Template alias
       TP.IsTemplateTemplate = true;
       TP.IsAliasTemplate = true;
       TP.ParamName = demangleFullyQualifiedTypeName(MangledName);
-    } else if (MangledName.consumeFront("$$B")) {
+    } else if (MangledName.consume_front("$$B")) {
       // Array
       TP.ParamType = demangleType(MangledName, QualifierMangleMode::Drop);
-    } else if (MangledName.consumeFront("$$C")) {
+    } else if (MangledName.consume_front("$$C")) {
       // Type has qualifiers.
       TP.ParamType = demangleType(MangledName, QualifierMangleMode::Mangle);
-    } else if (MangledName.startsWith("$1") || MangledName.startsWith("$H") ||
-               MangledName.startsWith("$I") || MangledName.startsWith("$J")) {
-      MangledName = MangledName.dropFront();
+    } else if (MangledName.startswith("$1") || MangledName.startswith("$H") ||
+               MangledName.startswith("$I") || MangledName.startswith("$J")) {
+      MangledName = MangledName.drop_front();
       // 1 - single inheritance       <name>
       // H - multiple inheritance     <name> <number>
       // I - virtual inheritance      <name> <number> <number> <number>
       // J - unspecified inheritance  <name> <number> <number> <number>
-      char InheritanceSpecifier = MangledName.popFront();
+      char InheritanceSpecifier = pop(MangledName);
       // Pointer to member
-      Symbol *S = MangledName.startsWith('?') ? parse(MangledName) : nullptr;
+      Symbol *S = MangledName.startswith("?") ? parse(MangledName) : nullptr;
       switch (InheritanceSpecifier) {
       case 'J':
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         LLVM_FALLTHROUGH;
       case 'I':
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         LLVM_FALLTHROUGH;
       case 'H':
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         LLVM_FALLTHROUGH;
       case '1':
         break;
       default:
         Error = true;
         break;
       }
       TP.PointerToSymbol = true;
       if (S) {
         TP.ParamName = S->SymbolName;
         TP.ParamType = S->SymbolType;
       } else
         TP.NullptrLiteral = true;
-    } else if (MangledName.startsWith("$E?")) {
-      MangledName.consumeFront("$E");
+    } else if (MangledName.startswith("$E?")) {
+      MangledName.consume_front("$E");
       // Reference to symbol
       Symbol *S = parse(MangledName);
       TP.ParamName = S->SymbolName;
       TP.ParamType = S->SymbolType;
       TP.ReferenceToSymbol = true;
-    } else if (MangledName.startsWith("$F") || MangledName.startsWith("$G")) {
+    } else if (MangledName.startswith("$F") || MangledName.startswith("$G")) {
       // Data member pointer.
-      MangledName = MangledName.dropFront();
-      char InheritanceSpecifier = MangledName.popFront();
+      MangledName = MangledName.drop_front();
+      char InheritanceSpecifier = pop(MangledName);
 
       switch (InheritanceSpecifier) {
       case 'G':
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         LLVM_FALLTHROUGH;
       case 'F':
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         TP.ThunkOffsets[TP.ThunkOffsetCount++] = demangleSigned(MangledName);
         LLVM_FALLTHROUGH;
       case '0':
         break;
       default:
         Error = true;
         break;
       }
       TP.DataMemberPointer = true;
 
-    } else if (MangledName.consumeFront("$0")) {
+    } else if (MangledName.consume_front("$0")) {
       // Integral non-type template parameter
       bool IsNegative = false;
       uint64_t Value = 0;
       std::tie(Value, IsNegative) = demangleNumber(MangledName);
 
       TP.IsIntegerLiteral = true;
       TP.IntegerLiteralIsNegative = IsNegative;
       TP.IntegralValue = Value;
     } else {
       TP.ParamType = demangleType(MangledName, QualifierMangleMode::Drop);
     }
     if (Error)
       return nullptr;
 
     Current = &TP.Next;
   }
 
   if (Error)
     return nullptr;
 
   // Template parameter lists cannot be variadic, so it can only be terminated
   // by @.
-  if (MangledName.consumeFront('@'))
+  if (MangledName.consume_front("@"))
     return Head;
   Error = true;
   return nullptr;
 }
 
-void Demangler::output(const Symbol *S, OutputStream &OS) {
+void Demangler::output(const Symbol *S, peekable_raw_ostream &OS) {
   if (S->Category == SymbolCategory::Unknown) {
     outputName(OS, S->SymbolName, S->SymbolType);
     return;
   }
 
   if (S->Category == SymbolCategory::SpecialOperator) {
     outputSpecialOperator(OS, S->SymbolName);
     return;
void Demangler::output(const Symbol *S, peekable_raw_ostream &OS) {
   }
 }
 
 void Demangler::dumpBackReferences() {
   std::printf("%d function parameter backreferences\n",
               (int)Backrefs.FunctionParamCount);
 
   // Create an output stream so we can render each type.
-  OutputStream OS = OutputStream::create(nullptr, 0, 1024);
+  SmallString<64> Buffer;
   for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) {
-    OS.setCurrentPosition(0);
+    raw_svector_ostream RawOS(Buffer);
+    peekable_raw_ostream OS(RawOS);
 
     Type *T = Backrefs.FunctionParams[I];
     Type::outputPre(OS, *T);
     Type::outputPost(OS, *T);
-
-    std::printf("  [%d] - %.*s\n", (int)I, (int)OS.getCurrentPosition(),
-                OS.getBuffer());
+    llvm::outs() << "  [" << I << "] - " << Buffer << "\n";
   }
-  std::free(OS.getBuffer());
 
   if (Backrefs.FunctionParamCount > 0)
     std::printf("\n");
   std::printf("%d name backreferences\n", (int)Backrefs.NamesCount);
   for (size_t I = 0; I < Backrefs.NamesCount; ++I) {
     std::printf("  [%d] - %.*s\n", (int)I, (int)Backrefs.Names[I].size(),
                 Backrefs.Names[I].begin());
   }
   if (Backrefs.NamesCount > 0)
     std::printf("\n");
 }
 
-char *llvm::microsoftDemangle(const char *MangledName, char *Buf, size_t *N,
+std::string llvm::microsoftDemangle(StringRef MangledName, 
                               int *Status, MSDemangleFlags Flags) {
   Demangler D;
-  StringView Name{MangledName};
-  Symbol *S = D.parse(Name);
+  Symbol *S = D.parse(MangledName);
 
   if (Flags & MSDF_DumpBackrefs)
     D.dumpBackReferences();
-  OutputStream OS = OutputStream::create(Buf, N, 1024);
+  std::string Buffer;
+  raw_string_ostream RawOS(Buffer);
+  peekable_raw_ostream OS(RawOS);
   if (D.Error) {
     OS << MangledName;
-    *Status = llvm::demangle_invalid_mangled_name;
+    *Status = -1;
   } else {
     D.output(S, OS);
-    *Status = llvm::demangle_success;
+    *Status = 0;
   }
+  OS.flush();
 
-  OS << '\0';
-  return OS.getBuffer();
+  return Buffer;
 }

llvm/tools/llvm-undname/llvm-undname.cpp

-//===-- llvm-undname.cpp - Microsoft ABI name undecorator
-//------------------===//
+//===-- llvm-undname.cpp - Microsoft ABI name undecorator -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This utility works like the windows undname utility. It converts mangled
 // Microsoft symbol names into pretty C/C++ human-readable names.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/MicrosoftDemangle.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <string>
 
 using namespace llvm;
 
 cl::opt<bool> DumpBackReferences("backrefs", cl::Optional,
                                  cl::desc("dump backreferences"), cl::Hidden,
                                  cl::init(false));
 cl::list<std::string> Symbols(cl::Positional, cl::desc("<input symbols>"),
                               cl::ZeroOrMore);
 
 static void demangle(const std::string &S) {
   int Status;
   MSDemangleFlags Flags = MSDF_None;
   if (DumpBackReferences)
     Flags = MSDemangleFlags(Flags | MSDF_DumpBackrefs);
 
-  char *ResultBuf =
-      microsoftDemangle(S.c_str(), nullptr, nullptr, &Status, Flags);
-  if (Status == llvm::demangle_success) {
-    outs() << ResultBuf << "\n";
+  std::string Result = microsoftDemangle(S, &Status, Flags);
+  if (Status == 0) {
+    outs() << Result << "\n";
     outs().flush();
   } else {
     errs() << "Error: Invalid mangled name\n";
   }
-  std::free(ResultBuf);
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
 
   if (Symbols.empty()) {