<div dir="ltr">Builds were broken by this... I tried to fix the most obvious cause (broke my build) in r340721....</div><br><div class="gmail_quote"><div dir="ltr">On Sun, Aug 26, 2018 at 8:48 PM Zachary Turner via llvm-commits <<a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: zturner<br>
Date: Sun Aug 26 20:48:03 2018<br>
New Revision: 340710<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=340710&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project?rev=340710&view=rev</a><br>
Log:<br>
[MS Demangler] Re-write the Microsoft demangler.<br>
<br>
This is a pretty large refactor / re-write of the Microsoft<br>
demangler.  The previous one was a little hackish because it<br>
evolved as I was learning about all the various edge cases,<br>
exceptions, etc.  It didn't have a proper AST and so there was<br>
lots of custom handling of things that should have been much<br>
more clean.<br>
<br>
Taking what was learned from that experience, it's now<br>
re-written with a completely redesigned and much more sensible<br>
AST.  It's probably still not perfect, but at least it's<br>
comprehensible now to someone else who wants to come along<br>
and make some modifications or read the code.<br>
<br>
Incidentally, this fixed a couple of bugs, so I've enabled<br>
the tests which now pass.<br>
<br>
Added:<br>
  Â  llvm/trunk/lib/Demangle/MicrosoftDemangleNodes.cpp<br>
  Â  llvm/trunk/lib/Demangle/MicrosoftDemangleNodes.h<br>
Modified:<br>
  Â  llvm/trunk/lib/Demangle/CMakeLists.txt<br>
  Â  llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp<br>
  Â  llvm/trunk/test/Demangle/ms-basic.test<br>
  Â  llvm/trunk/test/Demangle/ms-operators.test<br>
  Â  llvm/trunk/test/Demangle/ms-templates-memptrs-2.test<br>
  Â  llvm/trunk/test/Demangle/ms-templates-memptrs.test<br>
<br>
Modified: llvm/trunk/lib/Demangle/CMakeLists.txt<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Demangle/CMakeLists.txt?rev=340710&r1=340709&r2=340710&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Demangle/CMakeLists.txt?rev=340710&r1=340709&r2=340710&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Demangle/CMakeLists.txt (original)<br>
+++ llvm/trunk/lib/Demangle/CMakeLists.txt Sun Aug 26 20:48:03 2018<br>
@@ -1,6 +1,7 @@<br>
 add_llvm_library(LLVMDemangle<br>
  Â ItaniumDemangle.cpp<br>
  Â MicrosoftDemangle.cpp<br>
+  MicrosoftDemangleNodes.cpp<br>
<br>
  Â ADDITIONAL_HEADER_DIRS<br>
  Â "${LLVM_MAIN_INCLUDE_DIR}/llvm/Demangle"<br>
<br>
Modified: llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp?rev=340710&r1=340709&r2=340710&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp?rev=340710&r1=340709&r2=340710&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp (original)<br>
+++ llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp Sun Aug 26 20:48:03 2018<br>
@@ -14,6 +14,7 @@<br>
 //<br>
 //===----------------------------------------------------------------------===//<br>
<br>
+#include "MicrosoftDemangleNodes.h"<br>
 #include "llvm/Demangle/Demangle.h"<br>
<br>
 #include "llvm/Demangle/Compiler.h"<br>
@@ -25,386 +26,21 @@<br>
 #include <cstdio><br>
 #include <tuple><br>
<br>
-// This memory allocator is extremely fast, but it doesn't call dtors<br>
-// for allocated objects. That means you can't use STL containers<br>
-// (such as std::vector) with this allocator. But it pays off --<br>
-// the demangler is 3x faster with this allocator compared to one with<br>
-// STL containers.<br>
-namespace {<br>
-  constexpr size_t AllocUnit = 4096;<br>
-<br>
-class ArenaAllocator {<br>
-  struct AllocatorNode {<br>
-  Â  uint8_t *Buf = nullptr;<br>
-  Â  size_t Used = 0;<br>
-  Â  size_t Capacity = 0;<br>
-  Â  AllocatorNode *Next = nullptr;<br>
-  };<br>
-<br>
-  void addNode(size_t Capacity) {<br>
-  Â  AllocatorNode *NewHead = new AllocatorNode;<br>
-  Â  NewHead->Buf = new uint8_t[Capacity];<br>
-  Â  NewHead->Next = Head;<br>
-  Â  NewHead->Capacity = Capacity;<br>
-  Â  Head = NewHead;<br>
-  Â  NewHead->Used = 0;<br>
-  }<br>
-<br>
-public:<br>
-  ArenaAllocator() { addNode(AllocUnit); }<br>
-<br>
-  ~ArenaAllocator() {<br>
-  Â  while (Head) {<br>
-  Â  Â  assert(Head->Buf);<br>
-  Â  Â  delete[] Head->Buf;<br>
-  Â  Â  AllocatorNode *Next = Head->Next;<br>
-  Â  Â  delete Head;<br>
-  Â  Â  Head = Next;<br>
-  Â  }<br>
-  }<br>
-<br>
-  char *allocUnalignedBuffer(size_t Length) {<br>
-  Â  uint8_t *Buf = Head->Buf + Head->Used;<br>
-<br>
-  Â  Head->Used += Length;<br>
-  Â  if (Head->Used > Head->Capacity) {<br>
-  Â  Â  // It's possible we need a buffer which is larger than our default unit<br>
-  Â  Â  // size, so we need to be careful to add a node with capacity that is at<br>
-  Â  Â  // least as large as what we need.<br>
-  Â  Â  addNode(std::max(AllocUnit, Length));<br>
-  Â  Â  Head->Used = Length;<br>
-  Â  Â  Buf = Head->Buf;<br>
-  Â  }<br>
-<br>
-  Â  return reinterpret_cast<char *>(Buf);<br>
-  }<br>
-<br>
-  template <typename T, typename... Args> T *alloc(Args &&... ConstructorArgs) {<br>
-<br>
-  Â  size_t Size = sizeof(T);<br>
-  Â  assert(Head && Head->Buf);<br>
-<br>
-  Â  size_t P = (size_t)Head->Buf + Head->Used;<br>
-  Â  uintptr_t AlignedP =<br>
-  Â  Â  Â  (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));<br>
-  Â  uint8_t *PP = (uint8_t *)AlignedP;<br>
-  Â  size_t Adjustment = AlignedP - P;<br>
-<br>
-  Â  Head->Used += Size + Adjustment;<br>
-  Â  if (Head->Used < Head->Capacity)<br>
-  Â  Â  return new (PP) T(std::forward<Args>(ConstructorArgs)...);<br>
-<br>
-  Â  addNode(AllocUnit);<br>
-  Â  Head->Used = Size;<br>
-  Â  return new (Head->Buf) T(std::forward<Args>(ConstructorArgs)...);<br>
-  }<br>
-<br>
-private:<br>
-  AllocatorNode *Head = nullptr;<br>
-};<br>
-} // namespace<br>
+using namespace llvm;<br>
+using namespace ms_demangle;<br>
<br>
 static bool startsWithDigit(StringView S) {<br>
  Â return !S.empty() && std::isdigit(S.front());<br>
 }<br>
<br>
-// Writes a space if the last token does not end with a punctuation.<br>
-static void outputSpaceIfNecessary(OutputStream &OS) {<br>
-  if (OS.empty())<br>
-  Â  return;<br>
-<br>
-  char C = OS.back();<br>
-  if (isalnum(C) || C == '>')<br>
-  Â  OS << " ";<br>
-}<br>
-<br>
-// Storage classes<br>
-enum Qualifiers : uint8_t {<br>
-  Q_None = 0,<br>
-  Q_Const = 1 << 0,<br>
-  Q_Volatile = 1 << 1,<br>
-  Q_Far = 1 << 2,<br>
-  Q_Huge = 1 << 3,<br>
-  Q_Unaligned = 1 << 4,<br>
-  Q_Restrict = 1 << 5,<br>
-  Q_Pointer64 = 1 << 6<br>
-};<br>
-<br>
-enum class StorageClass : uint8_t {<br>
-  None,<br>
-  PrivateStatic,<br>
-  ProtectedStatic,<br>
-  PublicStatic,<br>
-  Global,<br>
-  FunctionLocalStatic,<br>
-};<br>
-<br>
 enum class QualifierMangleMode { Drop, Mangle, Result };<br>
<br>
-enum class PointerAffinity { Pointer, Reference, RValueReference };<br>
-<br>
-// Calling conventions<br>
-enum class CallingConv : uint8_t {<br>
-  None,<br>
-  Cdecl,<br>
-  Pascal,<br>
-  Thiscall,<br>
-  Stdcall,<br>
-  Fastcall,<br>
-  Clrcall,<br>
-  Eabi,<br>
-  Vectorcall,<br>
-  Regcall,<br>
-};<br>
-<br>
-enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };<br>
-<br>
-// Types<br>
-enum class PrimTy : uint8_t {<br>
-  Unknown,<br>
-  None,<br>
-  Function,<br>
-  Ptr,<br>
-  MemberPtr,<br>
-  Array,<br>
-<br>
-  Struct,<br>
-  Union,<br>
-  Class,<br>
-  Enum,<br>
-<br>
-  Void,<br>
-  Bool,<br>
-  Char,<br>
-  Schar,<br>
-  Uchar,<br>
-  Char16,<br>
-  Char32,<br>
-  Short,<br>
-  Ushort,<br>
-  Int,<br>
-  Uint,<br>
-  Long,<br>
-  Ulong,<br>
-  Int64,<br>
-  Uint64,<br>
-  Wchar,<br>
-  Float,<br>
-  Double,<br>
-  Ldouble,<br>
-  Nullptr,<br>
-  Custom,<br>
-  Vftable,<br>
-  Vbtable,<br>
-  LocalStaticGuard<br>
+struct NodeList {<br>
+  Node *N = nullptr;<br>
+  NodeList *Next = nullptr;<br>
 };<br>
<br>
-enum class OperatorTy : uint8_t {<br>
-  Ctor,  Â  Â  Â  Â  Â  Â  Â  Â  Â  // ?0 # Foo::Foo()<br>
-  Dtor,  Â  Â  Â  Â  Â  Â  Â  Â  Â  // ?1 # Foo::~Foo()<br>
-  New,  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â // ?2 # operator new<br>
-  Delete,  Â  Â  Â  Â  Â  Â  Â  Â  // ?3 # operator delete<br>
-  Assign,  Â  Â  Â  Â  Â  Â  Â  Â  // ?4 # operator=<br>
-  RightShift,  Â  Â  Â  Â  Â  Â  // ?5 # operator>><br>
-  LeftShift,  Â  Â  Â  Â  Â  Â  Â // ?6 # operator<<<br>
-  LogicalNot,  Â  Â  Â  Â  Â  Â  // ?7 # operator!<br>
-  Equals,  Â  Â  Â  Â  Â  Â  Â  Â  // ?8 # operator==<br>
-  NotEquals,  Â  Â  Â  Â  Â  Â  Â // ?9 # operator!=<br>
-  ArraySubscript,  Â  Â  Â  Â  // ?A # operator[]<br>
-  Conversion,  Â  Â  Â  Â  Â  Â  // ?B # Foo::operator <type>()<br>
-  Pointer,  Â  Â  Â  Â  Â  Â  Â  Â // ?C # operator-><br>
-  Dereference,  Â  Â  Â  Â  Â  Â // ?D # operator*<br>
-  Increment,  Â  Â  Â  Â  Â  Â  Â // ?E # operator++<br>
-  Decrement,  Â  Â  Â  Â  Â  Â  Â // ?F # operator--<br>
-  Minus,  Â  Â  Â  Â  Â  Â  Â  Â  Â // ?G # operator-<br>
-  Plus,  Â  Â  Â  Â  Â  Â  Â  Â  Â  // ?H # operator+<br>
-  BitwiseAnd,  Â  Â  Â  Â  Â  Â  // ?I # operator&<br>
-  MemberPointer,  Â  Â  Â  Â  Â // ?J # operator->*<br>
-  Divide,  Â  Â  Â  Â  Â  Â  Â  Â  // ?K # operator/<br>
-  Modulus,  Â  Â  Â  Â  Â  Â  Â  Â // ?L # operator%<br>
-  LessThan,  Â  Â  Â  Â  Â  Â  Â  // ?M operator<<br>
-  LessThanEqual,  Â  Â  Â  Â  Â // ?N operator<=<br>
-  GreaterThan,  Â  Â  Â  Â  Â  Â // ?O operator><br>
-  GreaterThanEqual,  Â  Â  Â  // ?P operator>=<br>
-  Comma,  Â  Â  Â  Â  Â  Â  Â  Â  Â // ?Q operator,<br>
-  Parens,  Â  Â  Â  Â  Â  Â  Â  Â  // ?R operator()<br>
-  BitwiseNot,  Â  Â  Â  Â  Â  Â  // ?S operator~<br>
-  BitwiseXor,  Â  Â  Â  Â  Â  Â  // ?T operator^<br>
-  BitwiseOr,  Â  Â  Â  Â  Â  Â  Â // ?U operator|<br>
-  LogicalAnd,  Â  Â  Â  Â  Â  Â  // ?V operator&&<br>
-  LogicalOr,  Â  Â  Â  Â  Â  Â  Â // ?W operator||<br>
-  TimesEqual,  Â  Â  Â  Â  Â  Â  // ?X operator*=<br>
-  PlusEqual,  Â  Â  Â  Â  Â  Â  Â // ?Y operator+=<br>
-  MinusEqual,  Â  Â  Â  Â  Â  Â  // ?Z operator-=<br>
-  DivEqual,  Â  Â  Â  Â  Â  Â  Â  // ?_0 operator/=<br>
-  ModEqual,  Â  Â  Â  Â  Â  Â  Â  // ?_1 operator%=<br>
-  RshEqual,  Â  Â  Â  Â  Â  Â  Â  // ?_2 operator>>=<br>
-  LshEqual,  Â  Â  Â  Â  Â  Â  Â  // ?_3 operator<<=<br>
-  BitwiseAndEqual,  Â  Â  Â  Â // ?_4 operator&=<br>
-  BitwiseOrEqual,  Â  Â  Â  Â  // ?_5 operator|=<br>
-  BitwiseXorEqual,  Â  Â  Â  Â // ?_6 operator^=<br>
-  Vftable,  Â  Â  Â  Â  Â  Â  Â  Â // ?_7 # vftable<br>
-  Vbtable,  Â  Â  Â  Â  Â  Â  Â  Â // ?_8 # vbtable<br>
-  Vcall,  Â  Â  Â  Â  Â  Â  Â  Â  Â // ?_9 # vcall<br>
-  Typeof,  Â  Â  Â  Â  Â  Â  Â  Â  // ?_A # typeof<br>
-  LocalStaticGuard,  Â  Â  Â  // ?_B # local static guard<br>
-  StringLiteral,  Â  Â  Â  Â  Â // ?_C # string literal<br>
-  VbaseDtor,  Â  Â  Â  Â  Â  Â  Â // ?_D # vbase destructor<br>
-  VecDelDtor,  Â  Â  Â  Â  Â  Â  // ?_E # vector deleting destructor<br>
-  DefaultCtorClosure,  Â  Â  // ?_F # default constructor closure<br>
-  ScalarDelDtor,  Â  Â  Â  Â  Â // ?_G # scalar deleting destructor<br>
-  VecCtorIter,  Â  Â  Â  Â  Â  Â // ?_H # vector constructor iterator<br>
-  VecDtorIter,  Â  Â  Â  Â  Â  Â // ?_I # vector destructor iterator<br>
-  VecVbaseCtorIter,  Â  Â  Â  // ?_J # vector vbase constructor iterator<br>
-  VdispMap,  Â  Â  Â  Â  Â  Â  Â  // ?_K # virtual displacement map<br>
-  EHVecCtorIter,  Â  Â  Â  Â  Â // ?_L # eh vector constructor iterator<br>
-  EHVecDtorIter,  Â  Â  Â  Â  Â // ?_M # eh vector destructor iterator<br>
-  EHVecVbaseCtorIter,  Â  Â  // ?_N # eh vector vbase constructor iterator<br>
-  CopyCtorClosure,  Â  Â  Â  Â // ?_O # copy constructor closure<br>
-  UdtReturning,  Â  Â  Â  Â  Â  // ?_P<name> # udt returning <name><br>
-  Unknown,  Â  Â  Â  Â  Â  Â  Â  Â // ?_Q # <unknown><br>
-  RttiTypeDescriptor,  Â  Â  // ?_R0 # RTTI Type Descriptor<br>
-  RttiBaseClassDescriptor, // ?_R1 # RTTI Base Class Descriptor at (a,b,c,d)<br>
-  RttiBaseClassArray,  Â  Â  // ?_R2 # RTTI Base Class Array<br>
-  RttiClassHierarchyDescriptor, // ?_R3 # RTTI Class Hierarchy Descriptor<br>
-  RttiCompleteObjLocator,  Â  Â  Â // ?_R4 # RTTI Complete Object Locator<br>
-  LocalVftable,  Â  Â  Â  Â  Â  Â  Â  Â // ?_S # local vftable<br>
-  LocalVftableCtorClosure,  Â  Â  // ?_T # local vftable constructor closure<br>
-  ArrayNew,  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â // ?_U operator new[]<br>
-  ArrayDelete,  Â  Â  Â  Â  Â  Â  Â  Â  // ?_V operator delete[]<br>
-  ManVectorCtorIter,  Â  Â  Â  Â  Â  // ?__A managed vector ctor iterator<br>
-  ManVectorDtorIter,  Â  Â  Â  Â  Â  // ?__B managed vector dtor iterator<br>
-  EHVectorCopyCtorIter,  Â  Â  Â  Â // ?__C EH vector copy ctor iterator<br>
-  EHVectorVbaseCopyCtorIter,  Â  // ?__D EH vector vbase copy ctor iterator<br>
-  DynamicInitializer,  Â  Â  Â  Â  Â // ?__E dynamic initializer for `T'<br>
-  DynamicAtexitDestructor,  Â  Â  // ?__F dynamic atexit destructor for `T'<br>
-  VectorCopyCtorIter,  Â  Â  Â  Â  Â // ?__G vector copy constructor iterator<br>
-  VectorVbaseCopyCtorIter,  Â  Â  // ?__H vector vbase copy constructor iterator<br>
-  ManVectorVbaseCopyCtorIter,  Â // ?__I managed vector vbase copy constructor<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  // iterator<br>
-  LocalStaticThreadGuard,  Â  Â  Â // ?__J local static thread guard<br>
-  LiteralOperator,  Â  Â  Â  Â  Â  Â  // ?__K operator ""_name<br>
-  CoAwait,  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  // ?__L co_await<br>
-  Spaceship,  Â  Â  Â  Â  Â  Â  Â  Â  Â  // operator<=><br>
-};<br>
-<br>
-// A map to translate from operator prefix to operator type.<br>
-struct OperatorMapEntry {<br>
-  StringView Prefix;<br>
-  StringView Name;<br>
-  OperatorTy Operator;<br>
-};<br>
-<br>
-// The entries here must be in the same order as the enumeration so that it can<br>
-// be indexed by enum value.<br>
-OperatorMapEntry OperatorMap[] = {<br>
-  Â  {"0", " <ctor>", OperatorTy::Ctor},<br>
-  Â  {"1", " <dtor>", OperatorTy::Dtor},<br>
-  Â  {"2", "operator new", OperatorTy::New},<br>
-  Â  {"3", "operator delete", OperatorTy::Delete},<br>
-  Â  {"4", "operator=", OperatorTy::Assign},<br>
-  Â  {"5", "operator>>", OperatorTy::RightShift},<br>
-  Â  {"6", "operator<<", OperatorTy::LeftShift},<br>
-  Â  {"7", "operator!", OperatorTy::LogicalNot},<br>
-  Â  {"8", "operator==", OperatorTy::Equals},<br>
-  Â  {"9", "operator!=", OperatorTy::NotEquals},<br>
-  Â  {"A", "operator[]", OperatorTy::ArraySubscript},<br>
-  Â  {"B", "operator <conversion>", OperatorTy::Conversion},<br>
-  Â  {"C", "operator->", OperatorTy::Pointer},<br>
-  Â  {"D", "operator*", OperatorTy::Dereference},<br>
-  Â  {"E", "operator++", OperatorTy::Increment},<br>
-  Â  {"F", "operator--", OperatorTy::Decrement},<br>
-  Â  {"G", "operator-", OperatorTy::Minus},<br>
-  Â  {"H", "operator+", OperatorTy::Plus},<br>
-  Â  {"I", "operator&", OperatorTy::BitwiseAnd},<br>
-  Â  {"J", "operator->*", OperatorTy::MemberPointer},<br>
-  Â  {"K", "operator/", OperatorTy::Divide},<br>
-  Â  {"L", "operator%", OperatorTy::Modulus},<br>
-  Â  {"M", "operator<", OperatorTy::LessThan},<br>
-  Â  {"N", "operator<=", OperatorTy::LessThanEqual},<br>
-  Â  {"O", "operator>", OperatorTy::GreaterThan},<br>
-  Â  {"P", "operator>=", OperatorTy::GreaterThanEqual},<br>
-  Â  {"Q", "operator,", OperatorTy::Comma},<br>
-  Â  {"R", "operator()", OperatorTy::Parens},<br>
-  Â  {"S", "operator~", OperatorTy::BitwiseNot},<br>
-  Â  {"T", "operator^", OperatorTy::BitwiseXor},<br>
-  Â  {"U", "operator|", OperatorTy::BitwiseOr},<br>
-  Â  {"V", "operator&&", OperatorTy::LogicalAnd},<br>
-  Â  {"W", "operator||", OperatorTy::LogicalOr},<br>
-  Â  {"X", "operator*=", OperatorTy::TimesEqual},<br>
-  Â  {"Y", "operator+=", OperatorTy::PlusEqual},<br>
-  Â  {"Z", "operator-=", OperatorTy::MinusEqual},<br>
-  Â  {"_0", "operator/=", OperatorTy::DivEqual},<br>
-  Â  {"_1", "operator%=", OperatorTy::ModEqual},<br>
-  Â  {"_2", "operator>>=", OperatorTy::RshEqual},<br>
-  Â  {"_3", "operator<<=", OperatorTy::LshEqual},<br>
-  Â  {"_4", "operator&=", OperatorTy::BitwiseAndEqual},<br>
-  Â  {"_5", "operator|=", OperatorTy::BitwiseOrEqual},<br>
-  Â  {"_6", "operator^=", OperatorTy::BitwiseXorEqual},<br>
-  Â  {"_7", "`vftable'", OperatorTy::Vftable},<br>
-  Â  {"_8", "`vbtable'", OperatorTy::Vbtable},<br>
-  Â  {"_9", "`vcall'", OperatorTy::Vcall},<br>
-  Â  {"_A", "`typeof'", OperatorTy::Typeof},<br>
-  Â  {"_B", "`local static guard'", OperatorTy::LocalStaticGuard},<br>
-  Â  {"_C", "`string'", OperatorTy::StringLiteral},<br>
-  Â  {"_D", "`vbase dtor'", OperatorTy::VbaseDtor},<br>
-  Â  {"_E", "`vector deleting dtor'", OperatorTy::VecDelDtor},<br>
-  Â  {"_F", "`default ctor closure'", OperatorTy::DefaultCtorClosure},<br>
-  Â  {"_G", "`scalar deleting dtor'", OperatorTy::ScalarDelDtor},<br>
-  Â  {"_H", "`vector ctor iterator'", OperatorTy::VecCtorIter},<br>
-  Â  {"_I", "`vector dtor iterator'", OperatorTy::VecDtorIter},<br>
-  Â  {"_J", "`vector vbase ctor iterator'", OperatorTy::VecVbaseCtorIter},<br>
-  Â  {"_K", "`virtual displacement map'", OperatorTy::VdispMap},<br>
-  Â  {"_L", "`eh vector ctor iterator'", OperatorTy::EHVecCtorIter},<br>
-  Â  {"_M", "`eh vector dtor iterator'", OperatorTy::EHVecDtorIter},<br>
-  Â  {"_N", "`eh vector vbase ctor iterator'", OperatorTy::EHVecVbaseCtorIter},<br>
-  Â  {"_O", "`copy ctor closure'", OperatorTy::CopyCtorClosure},<br>
-  Â  {"_P", "`udt returning'", OperatorTy::UdtReturning},<br>
-  Â  {"_Q", "`unknown'", OperatorTy::Unknown},<br>
-  Â  {"_R0", "`RTTI Type Descriptor'", OperatorTy::RttiTypeDescriptor},<br>
-  Â  {"_R1", "RTTI Base Class Descriptor", OperatorTy::RttiBaseClassDescriptor},<br>
-  Â  {"_R2", "`RTTI Base Class Array'", OperatorTy::RttiBaseClassArray},<br>
-  Â  {"_R3", "`RTTI Class Hierarchy Descriptor'",<br>
-  Â  Â OperatorTy::RttiClassHierarchyDescriptor},<br>
-  Â  {"_R4", "`RTTI Complete Object Locator'",<br>
-  Â  Â OperatorTy::RttiCompleteObjLocator},<br>
-  Â  {"_S", "`local vftable'", OperatorTy::LocalVftable},<br>
-  Â  {"_T", "`local vftable ctor closure'", OperatorTy::LocalVftableCtorClosure},<br>
-  Â  {"_U", "operator new[]", OperatorTy::ArrayNew},<br>
-  Â  {"_V", "operator delete[]", OperatorTy::ArrayDelete},<br>
-  Â  {"__A", "managed vector ctor iterator", OperatorTy::ManVectorCtorIter},<br>
-  Â  {"__B", "managed vector dtor iterator", OperatorTy::ManVectorDtorIter},<br>
-  Â  {"__C", "EH vector copy ctor iterator", OperatorTy::EHVectorCopyCtorIter},<br>
-  Â  {"__D", "EH vector vbase copy ctor iterator",<br>
-  Â  Â OperatorTy::EHVectorVbaseCopyCtorIter},<br>
-  Â  {"__E", "dynamic initializer", OperatorTy::DynamicInitializer},<br>
-  Â  {"__F", "dynamic atexit destructor", OperatorTy::DynamicAtexitDestructor},<br>
-  Â  {"__G", "vector copy ctor iterator", OperatorTy::VectorCopyCtorIter},<br>
-  Â  {"__H", "vector vbase copy constructor iterator",<br>
-  Â  Â OperatorTy::VectorVbaseCopyCtorIter},<br>
-  Â  {"__I", "managed vector vbase copy constructor iterator",<br>
-  Â  Â OperatorTy::ManVectorVbaseCopyCtorIter},<br>
-  Â  {"__J", "local static thread guard", OperatorTy::LocalStaticThreadGuard},<br>
-  Â  {"__K", "operator \"\"", OperatorTy::LiteralOperator},<br>
-  Â  {"__L", "co_await", OperatorTy::CoAwait},<br>
-};<br>
-<br>
-// Function classes<br>
-enum FuncClass : uint16_t {<br>
-  None = 0,<br>
-  Public = 1 << 0,<br>
-  Protected = 1 << 1,<br>
-  Private = 1 << 2,<br>
-  Global = 1 << 3,<br>
-  Static = 1 << 4,<br>
-  Virtual = 1 << 5,<br>
-  Far = 1 << 6,<br>
-  ExternC = 1 << 7,<br>
-  NoPrototype = 1 << 8,<br>
-  VirtualThisAdjust = 1 << 9,<br>
-  VirtualThisAdjustEx = 1 << 10,<br>
-  StaticThisAdjust = 1 << 11<br>
-};<br>
+enum class FunctionIdentifierCodeGroup { Basic, Under, DoubleUnder };<br>
<br>
 enum NameBackrefBehavior : uint8_t {<br>
  Â NBB_None = 0,  Â  Â  Â  Â  // don't save any names as backrefs.<br>
@@ -412,237 +48,6 @@ enum NameBackrefBehavior : uint8_t {<br>
  Â NBB_Simple = 1 << 1,  Â // save simple names.<br>
 };<br>
<br>
-enum class SymbolCategory {<br>
-  Unknown,<br>
-  NamedFunction,<br>
-  NamedVariable,<br>
-  UnnamedFunction,<br>
-  UnnamedVariable,<br>
-  SpecialOperator<br>
-};<br>
-<br>
-namespace {<br>
-<br>
-struct Type;<br>
-struct Name;<br>
-<br>
-struct FunctionParams {<br>
-  bool IsVariadic = false;<br>
-<br>
-  Type *Current = nullptr;<br>
-<br>
-  FunctionParams *Next = nullptr;<br>
-};<br>
-<br>
-struct TemplateParams {<br>
-  bool IsTemplateTemplate = false;<br>
-  bool IsAliasTemplate = false;<br>
-  bool IsIntegerLiteral = false;<br>
-  bool IntegerLiteralIsNegative = false;<br>
-  bool IsEmptyParameterPack = false;<br>
-  bool PointerToSymbol = false;<br>
-  bool NullptrLiteral = false;<br>
-  bool DataMemberPointer = false;<br>
-  bool ReferenceToSymbol = false;<br>
-<br>
-  int ThunkOffsetCount = 0;<br>
-  std::array<int64_t, 3> ThunkOffsets;<br>
-<br>
-  // If IsIntegerLiteral is true, this is a non-type template parameter<br>
-  // whose value is contained in this field.<br>
-  uint64_t IntegralValue = 0;<br>
-<br>
-  // Type can be null if this is a template template parameter.  In that case<br>
-  // only Name will be valid.<br>
-  Type *ParamType = nullptr;<br>
-<br>
-  // Name can be valid if this is a template template parameter (see above) or<br>
-  // this is a function declaration (e.g. foo<&SomeFunc>).  In the latter case<br>
-  // Name contains the name of the function and Type contains the signature.<br>
-  Name *ParamName = nullptr;<br>
-<br>
-  TemplateParams *Next = nullptr;<br>
-};<br>
-<br>
-// The type class. Mangled symbols are first parsed and converted to<br>
-// this type and then converted to string.<br>
-struct Type {<br>
-  virtual ~Type() {}<br>
-<br>
-  virtual Type *clone(ArenaAllocator &Arena) const;<br>
-<br>
-  // Write the "first half" of a given type.  This is a static functions to<br>
-  // give the code a chance to do processing that is common to a subset of<br>
-  // subclasses<br>
-  static void outputPre(OutputStream &OS, Type &Ty);<br>
-<br>
-  // Write the "second half" of a given type.  This is a static functions to<br>
-  // give the code a chance to do processing that is common to a subset of<br>
-  // subclasses<br>
-  static void outputPost(OutputStream &OS, Type &Ty);<br>
-<br>
-  virtual void outputPre(OutputStream &OS);<br>
-  virtual void outputPost(OutputStream &OS);<br>
-<br>
-  // Primitive type such as Int.<br>
-  PrimTy Prim = PrimTy::Unknown;<br>
-<br>
-  Qualifiers Quals = Q_None;<br>
-  StringView Custom;<br>
-  StorageClass Storage = StorageClass::None; // storage class<br>
-};<br>
-<br>
-// Represents an identifier which may be a template.<br>
-struct Name {<br>
-  virtual ~Name() = default;<br>
-<br>
-  bool IsTemplateInstantiation = false;<br>
-  bool IsOperator = false;<br>
-  bool IsBackReference = false;<br>
-<br>
-  // Name read from an MangledName string.<br>
-  StringView Str;<br>
-<br>
-  // Template parameters. Only valid if IsTemplateInstantiation is true.<br>
-  TemplateParams *TParams = nullptr;<br>
-<br>
-  // Nested BackReferences (e.g. "A::B::C") are represented as a linked list.<br>
-  Name *Next = nullptr;<br>
-};<br>
-<br>
-struct OperatorInfo : public Name {<br>
-  explicit OperatorInfo(const OperatorMapEntry &Info) : Info(&Info) {<br>
-  Â  this->IsOperator = true;<br>
-  }<br>
-  explicit OperatorInfo(OperatorTy OpType)<br>
-  Â  Â  : OperatorInfo(OperatorMap[(int)OpType]) {}<br>
-<br>
-  const OperatorMapEntry *Info = nullptr;<br>
-  bool IsIndirectTable = false;<br>
-};<br>
-<br>
-struct IndirectTable : public OperatorInfo {<br>
-  explicit IndirectTable(const OperatorMapEntry &Info) : OperatorInfo(Info) {<br>
-  Â  this->IsOperator = true;<br>
-  Â  this->IsIndirectTable = true;<br>
-  }<br>
-  explicit IndirectTable(OperatorTy OpType)<br>
-  Â  Â  : IndirectTable(OperatorMap[(int)OpType]) {}<br>
-<br>
-  const Name *TableLocation = nullptr;<br>
-  const Name *TableTarget = nullptr;<br>
-};<br>
-<br>
-struct StringLiteral : public OperatorInfo {<br>
-  StringLiteral() : OperatorInfo(OperatorTy::StringLiteral) {}<br>
-<br>
-  PrimTy CharType;<br>
-  bool IsTruncated = false;<br>
-};<br>
-<br>
-struct RttiBaseClassDescriptor : public OperatorInfo {<br>
-  RttiBaseClassDescriptor()<br>
-  Â  Â  : OperatorInfo(OperatorTy::RttiBaseClassDescriptor) {}<br>
-<br>
-  uint32_t NVOffset = 0;<br>
-  int32_t VBPtrOffset = 0;<br>
-  uint32_t VBTableOffset = 0;<br>
-  uint32_t Flags = 0;<br>
-};<br>
-<br>
-struct LocalStaticGuardVariable : public OperatorInfo {<br>
-  LocalStaticGuardVariable() : OperatorInfo(OperatorTy::LocalStaticGuard) {}<br>
-<br>
-  uint32_t ScopeIndex = 0;<br>
-  bool IsVisible = false;<br>
-};<br>
-<br>
-struct VirtualMemberPtrThunk : public OperatorInfo {<br>
-  VirtualMemberPtrThunk() : OperatorInfo(OperatorTy::Vcall) {}<br>
-<br>
-  uint64_t OffsetInVTable = 0;<br>
-  CallingConv CC = CallingConv::Cdecl;<br>
-};<br>
-<br>
-struct PointerType : public Type {<br>
-  Type *clone(ArenaAllocator &Arena) const override;<br>
-  void outputPre(OutputStream &OS) override;<br>
-  void outputPost(OutputStream &OS) override;<br>
-<br>
-  PointerAffinity Affinity;<br>
-<br>
-  // Represents a type X in "a pointer to X", "a reference to X",<br>
-  // "an array of X", or "a function returning X".<br>
-  Type *Pointee = nullptr;<br>
-};<br>
-<br>
-struct MemberPointerType : public Type {<br>
-  Type *clone(ArenaAllocator &Arena) const override;<br>
-  void outputPre(OutputStream &OS) override;<br>
-  void outputPost(OutputStream &OS) override;<br>
-<br>
-  Name *MemberName = nullptr;<br>
-<br>
-  // Represents a type X in "a pointer to X", "a reference to X",<br>
-  // "an array of X", or "a function returning X".<br>
-  Type *Pointee = nullptr;<br>
-};<br>
-<br>
-struct FunctionType : public Type {<br>
-  struct ThisAdjustor {<br>
-  Â  uint32_t StaticOffset = 0;<br>
-  Â  int32_t VBPtrOffset = 0;<br>
-  Â  int32_t VBOffsetOffset = 0;<br>
-  Â  int32_t VtordispOffset = 0;<br>
-  };<br>
-<br>
-  Type *clone(ArenaAllocator &Arena) const override;<br>
-  void outputPre(OutputStream &OS) override;<br>
-  void outputPost(OutputStream &OS) override;<br>
-<br>
-  // True if this FunctionType instance is the Pointee of a PointerType or<br>
-  // MemberPointerType.<br>
-  bool IsFunctionPointer = false;<br>
-  bool IsThunk = false;<br>
-<br>
-  Type *ReturnType = nullptr;<br>
-  // If this is a reference, the type of reference.<br>
-  ReferenceKind RefKind;<br>
-<br>
-  CallingConv CallConvention;<br>
-  FuncClass FunctionClass;<br>
-<br>
-  // Valid if IsThunk is true.<br>
-  ThisAdjustor *ThisAdjust = nullptr;<br>
-<br>
-  FunctionParams Params;<br>
-};<br>
-<br>
-struct UdtType : public Type {<br>
-  Type *clone(ArenaAllocator &Arena) const override;<br>
-  void outputPre(OutputStream &OS) override;<br>
-<br>
-  Name *UdtName = nullptr;<br>
-};<br>
-<br>
-struct ArrayDimension {<br>
-  uint64_t Dim = 0;<br>
-  ArrayDimension *Next = nullptr;<br>
-};<br>
-<br>
-struct ArrayType : public Type {<br>
-  Type *clone(ArenaAllocator &Arena) const override;<br>
-  void outputPre(OutputStream &OS) override;<br>
-  void outputPost(OutputStream &OS) override;<br>
-<br>
-  // Either NextDimension or ElementType will be valid.<br>
-  ArrayDimension *Dims = nullptr;<br>
-<br>
-  Type *ElementType = nullptr;<br>
-};<br>
-<br>
-} // namespace<br>
-<br>
 static bool isMemberPointer(StringView MangledName) {<br>
  Â switch (MangledName.popFront()) {<br>
  Â case '$':<br>
@@ -697,40 +102,41 @@ static bool isMemberPointer(StringView M<br>
  Â return false;<br>
 }<br>
<br>
-static void outputCallingConvention(OutputStream &OS, CallingConv CC) {<br>
-  outputSpaceIfNecessary(OS);<br>
-<br>
-  switch (CC) {<br>
-  case CallingConv::Cdecl:<br>
-  Â  OS << "__cdecl";<br>
-  Â  break;<br>
-  case CallingConv::Fastcall:<br>
-  Â  OS << "__fastcall";<br>
-  Â  break;<br>
-  case CallingConv::Pascal:<br>
-  Â  OS << "__pascal";<br>
-  Â  break;<br>
-  case CallingConv::Regcall:<br>
-  Â  OS << "__regcall";<br>
-  Â  break;<br>
-  case CallingConv::Stdcall:<br>
-  Â  OS << "__stdcall";<br>
-  Â  break;<br>
-  case CallingConv::Thiscall:<br>
-  Â  OS << "__thiscall";<br>
-  Â  break;<br>
-  case CallingConv::Eabi:<br>
-  Â  OS << "__eabi";<br>
-  Â  break;<br>
-  case CallingConv::Vectorcall:<br>
-  Â  OS << "__vectorcall";<br>
-  Â  break;<br>
-  case CallingConv::Clrcall:<br>
-  Â  OS << "__clrcall";<br>
-  Â  break;<br>
-  default:<br>
-  Â  break;<br>
-  }<br>
+static SpecialIntrinsicKind<br>
+consumeSpecialIntrinsicKind(StringView &MangledName) {<br>
+  if (MangledName.consumeFront("?_7"))<br>
+  Â  return SpecialIntrinsicKind::Vftable;<br>
+  if (MangledName.consumeFront("?_8"))<br>
+  Â  return SpecialIntrinsicKind::Vbtable;<br>
+  if (MangledName.consumeFront("?_9"))<br>
+  Â  return SpecialIntrinsicKind::VcallThunk;<br>
+  if (MangledName.consumeFront("?_A"))<br>
+  Â  return SpecialIntrinsicKind::Typeof;<br>
+  if (MangledName.consumeFront("?_B"))<br>
+  Â  return SpecialIntrinsicKind::LocalStaticGuard;<br>
+  if (MangledName.consumeFront("?_C"))<br>
+  Â  return SpecialIntrinsicKind::StringLiteralSymbol;<br>
+  if (MangledName.consumeFront("?_P"))<br>
+  Â  return SpecialIntrinsicKind::UdtReturning;<br>
+  if (MangledName.consumeFront("?_R0"))<br>
+  Â  return SpecialIntrinsicKind::RttiTypeDescriptor;<br>
+  if (MangledName.consumeFront("?_R1"))<br>
+  Â  return SpecialIntrinsicKind::RttiBaseClassDescriptor;<br>
+  if (MangledName.consumeFront("?_R2"))<br>
+  Â  return SpecialIntrinsicKind::RttiBaseClassArray;<br>
+  if (MangledName.consumeFront("?_R3"))<br>
+  Â  return SpecialIntrinsicKind::RttiClassHierarchyDescriptor;<br>
+  if (MangledName.consumeFront("?_R4"))<br>
+  Â  return SpecialIntrinsicKind::RttiCompleteObjLocator;<br>
+  if (MangledName.consumeFront("?_S"))<br>
+  Â  return SpecialIntrinsicKind::LocalVftable;<br>
+  if (MangledName.consumeFront("?__E"))<br>
+  Â  return SpecialIntrinsicKind::DynamicInitializer;<br>
+  if (MangledName.consumeFront("?__F"))<br>
+  Â  return SpecialIntrinsicKind::DynamicAtexitDestructor;<br>
+  if (MangledName.consumeFront("?__J"))<br>
+  Â  return SpecialIntrinsicKind::LocalStaticThreadGuard;<br>
+  return SpecialIntrinsicKind::None;<br>
 }<br>
<br>
 static bool startsWithLocalScopePattern(StringView S) {<br>
@@ -774,623 +180,81 @@ static bool startsWithLocalScopePattern(<br>
  Â return true;<br>
 }<br>
<br>
-// Write a function or template parameter list.<br>
-static void outputParameterList(OutputStream &OS,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  const FunctionParams &Params) {<br>
-  if (!Params.Current) {<br>
-  Â  OS << "void";<br>
-  Â  return;<br>
-  }<br>
-<br>
-  const FunctionParams *Head = &Params;<br>
-  while (Head) {<br>
-  Â  Type::outputPre(OS, *Head->Current);<br>
-  Â  Type::outputPost(OS, *Head->Current);<br>
-<br>
-  Â  Head = Head->Next;<br>
-<br>
-  Â  if (Head)<br>
-  Â  Â  OS << ", ";<br>
-  }<br>
-}<br>
-<br>
-static void outputStringLiteral(OutputStream &OS, const StringLiteral &Str) {<br>
-  switch (Str.CharType) {<br>
-  case PrimTy::Wchar:<br>
-  Â  OS << "const wchar_t * {L\"";<br>
-  Â  break;<br>
-  case PrimTy::Char:<br>
-  Â  OS << "const char * {\"";<br>
-  Â  break;<br>
-  case PrimTy::Char16:<br>
-  Â  OS << "const char16_t * {u\"";<br>
-  Â  break;<br>
-  case PrimTy::Char32:<br>
-  Â  OS << "const char32_t * {U\"";<br>
-  Â  break;<br>
-  default:<br>
-  Â  LLVM_BUILTIN_UNREACHABLE;<br>
-  }<br>
-  OS << Str.Str << "\"";<br>
-  if (Str.IsTruncated)<br>
-  Â  OS << "...";<br>
-  OS << "}";<br>
-}<br>
-<br>
-static void outputName(OutputStream &OS, const Name *TheName, const Type *Ty);<br>
-<br>
-static void outputParameterList(OutputStream &OS,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  const TemplateParams &Params) {<br>
-  if (Params.IsEmptyParameterPack) {<br>
-  Â  OS << "<>";<br>
-  Â  return;<br>
-  }<br>
-<br>
-  OS << "<";<br>
-  const TemplateParams *Head = &Params;<br>
-  while (Head) {<br>
-  Â  // Type can be null if this is a template template parameter,<br>
-  Â  // and Name can be null if this is a simple type.<br>
-<br>
-  Â  if (Head->IsIntegerLiteral) {<br>
-  Â  Â  if (Head->IntegerLiteralIsNegative)<br>
-  Â  Â  Â  OS << '-';<br>
-  Â  Â  OS << Head->IntegralValue;<br>
-  Â  } else if (Head->PointerToSymbol || Head->ReferenceToSymbol) {<br>
-  Â  Â  if (Head->NullptrLiteral)<br>
-  Â  Â  Â  OS << "nullptr";<br>
-  Â  Â  else {<br>
-  Â  Â  Â  if (Head->ThunkOffsetCount > 0)<br>
-  Â  Â  Â  Â  OS << "{";<br>
-  Â  Â  Â  else if (Head->PointerToSymbol)<br>
-  Â  Â  Â  Â  OS << "&";<br>
-  Â  Â  Â  if (Head->ParamType)<br>
-  Â  Â  Â  Â  Type::outputPre(OS, *Head->ParamType);<br>
-  Â  Â  Â  outputName(OS, Head->ParamName, Head->ParamType);<br>
-  Â  Â  Â  if (Head->ParamType)<br>
-  Â  Â  Â  Â  Type::outputPost(OS, *Head->ParamType);<br>
-  Â  Â  Â  if (Head->ThunkOffsetCount > 0) {<br>
-  Â  Â  Â  Â  for (int I = 0; I < Head->ThunkOffsetCount; ++I) {<br>
-  Â  Â  Â  Â  Â  OS << ", " << Head->ThunkOffsets[I];<br>
-  Â  Â  Â  Â  }<br>
-  Â  Â  Â  Â  OS << "}";<br>
-  Â  Â  Â  }<br>
-  Â  Â  }<br>
-  Â  } else if (Head->DataMemberPointer) {<br>
-  Â  Â  OS << "{" << Head->ThunkOffsets[0];<br>
-  Â  Â  for (int I = 1; I < Head->ThunkOffsetCount; ++I)<br>
-  Â  Â  Â  OS << ", " << Head->ThunkOffsets[I];<br>
-  Â  Â  OS << "}";<br>
-  Â  } else if (Head->ParamType) {<br>
-  Â  Â  // simple type.<br>
-  Â  Â  Type::outputPre(OS, *Head->ParamType);<br>
-  Â  Â  Type::outputPost(OS, *Head->ParamType);<br>
-  Â  } else {<br>
-  Â  Â  // Template alias.<br>
-  Â  Â  outputName(OS, Head->ParamName, Head->ParamType);<br>
-  Â  }<br>
-<br>
-  Â  Head = Head->Next;<br>
-<br>
-  Â  if (Head)<br>
-  Â  Â  OS << ", ";<br>
-  }<br>
-  OS << ">";<br>
-}<br>
-<br>
-static void outputQualifiers(OutputStream &OS, Qualifiers Q) {<br>
-  if (Q & Q_Const) {<br>
-  Â  outputSpaceIfNecessary(OS);<br>
-  Â  OS << "const";<br>
-  }<br>
-<br>
-  if (Q & Q_Volatile) {<br>
-  Â  outputSpaceIfNecessary(OS);<br>
-  Â  OS << "volatile";<br>
-  }<br>
-<br>
-  if (Q & Q_Restrict) {<br>
-  Â  outputSpaceIfNecessary(OS);<br>
-  Â  OS << "__restrict";<br>
-  }<br>
-}<br>
-<br>
-static void outputNameComponent(OutputStream &OS, const Name &N) {<br>
-  OS << N.Str;<br>
-<br>
-  if (N.IsTemplateInstantiation && N.TParams)<br>
-  Â  outputParameterList(OS, *N.TParams);<br>
-}<br>
-<br>
-static const OperatorInfo *lastComponentAsOperator(const Name *TheName) {<br>
-  if (!TheName)<br>
-  Â  return nullptr;<br>
-  while (TheName->Next)<br>
-  Â  TheName = TheName->Next;<br>
-  if (TheName->IsOperator)<br>
-  Â  return static_cast<const OperatorInfo *>(TheName);<br>
-  return nullptr;<br>
-}<br>
-<br>
-static void outputName(OutputStream &OS, const Name *TheName, const Type *Ty) {<br>
-  if (!TheName)<br>
-  Â  return;<br>
-<br>
-  outputSpaceIfNecessary(OS);<br>
-<br>
-  const OperatorInfo *Operator = lastComponentAsOperator(TheName);<br>
-  const VirtualMemberPtrThunk *Thunk = nullptr;<br>
-  bool PrintLastScopeSeparator = true;<br>
-  if (Operator) {<br>
-  Â  if (Operator->IsIndirectTable) {<br>
-  Â  Â  const IndirectTable *Table = static_cast<const IndirectTable *>(Operator);<br>
-  Â  Â  outputName(OS, Table->TableLocation, nullptr);<br>
-  Â  Â  OS << "{for `";<br>
-  Â  Â  outputName(OS, Table->TableTarget, nullptr);<br>
-  Â  Â  OS << "'}";<br>
-  Â  Â  return;<br>
-  Â  }<br>
-  Â  if (Operator->Info->Operator == OperatorTy::Vcall) {<br>
-  Â  Â  Thunk = static_cast<const VirtualMemberPtrThunk *>(Operator);<br>
-  Â  Â  OS << "[thunk]: ";<br>
-  Â  Â  outputCallingConvention(OS, Thunk->CC);<br>
-  Â  Â  OS << " ";<br>
-  Â  } else if (Operator->Info->Operator == OperatorTy::DynamicInitializer) {<br>
-  Â  Â  OS << "`dynamic initializer for '";<br>
-  Â  Â  PrintLastScopeSeparator = false;<br>
-  Â  } else if (Operator->Info->Operator ==<br>
-  Â  Â  Â  Â  Â  Â  Â OperatorTy::DynamicAtexitDestructor) {<br>
-  Â  Â  OS << "`dynamic atexit destructor for '";<br>
-  Â  Â  PrintLastScopeSeparator = false;<br>
-  Â  }<br>
-  }<br>
-<br>
-  const Name *Previous = nullptr;<br>
-  // Print out namespaces or outer class BackReferences.<br>
-  for (; TheName->Next; TheName = TheName->Next) {<br>
-  Â  Previous = TheName;<br>
-  Â  outputNameComponent(OS, *TheName);<br>
-  Â  if (TheName->Next != Operator || PrintLastScopeSeparator)<br>
-  Â  Â  OS << "::";<br>
-  }<br>
-<br>
-  // Print out a regular name.<br>
-  if (!TheName->IsOperator) {<br>
-  Â  outputNameComponent(OS, *TheName);<br>
-  Â  return;<br>
-  }<br>
-<br>
-<br>
-  // Print out ctor or dtor.<br>
-  switch (Operator->Info->Operator) {<br>
-  case OperatorTy::Dtor:<br>
-  Â  OS << "~";<br>
-  Â  LLVM_FALLTHROUGH;<br>
-  case OperatorTy::Ctor:<br>
-  Â  // Output the class name with template arguments a second time.<br>
-  Â  outputNameComponent(OS, *Previous);<br>
-<br>
-  Â  // Structors don't have a name, so outputting the name here actually is a<br>
-  Â  // no-op.  But for template constructors, it needs to output the template<br>
-  Â  // argument list.  e.g.<br>
-  Â  //<br>
-  Â  // template<typename T><br>
-  Â  // struct Foo {<br>
-  Â  //  Â  template<typename U><br>
-  Â  //  Â  Foo(U);<br>
-  Â  // };<br>
-  Â  // should demangle as -- for example -- Foo<int><double>(double);<br>
-  Â  outputNameComponent(OS, *TheName);<br>
-  Â  break;<br>
-  case OperatorTy::Conversion:<br>
-  Â  OS << "operator";<br>
-  Â  if (TheName->IsTemplateInstantiation && TheName->TParams)<br>
-  Â  Â  outputParameterList(OS, *TheName->TParams);<br>
-  Â  OS << " ";<br>
-  Â  if (Ty) {<br>
-  Â  Â  const FunctionType *FTy = static_cast<const FunctionType *>(Ty);<br>
-  Â  Â  Type::outputPre(OS, *FTy->ReturnType);<br>
-  Â  Â  Type::outputPost(OS, *FTy->ReturnType);<br>
-  Â  } else {<br>
-  Â  Â  OS << "<conversion>";<br>
-  Â  }<br>
-  Â  break;<br>
-  case OperatorTy::LiteralOperator:<br>
-  Â  OS << Operator->Info->Name;<br>
-  Â  outputNameComponent(OS, *TheName);<br>
-  Â  break;<br>
-  case OperatorTy::RttiBaseClassDescriptor: {<br>
-  Â  const RttiBaseClassDescriptor &BCD =<br>
-  Â  Â  Â  static_cast<const RttiBaseClassDescriptor &>(*Operator);<br>
-  Â  OS << "`" << Operator->Info->Name << " at (";<br>
-  Â  OS << BCD.NVOffset << ", " << BCD.VBPtrOffset << ", " << BCD.VBTableOffset<br>
-  Â  Â  Â << ", " << BCD.Flags;<br>
-  Â  OS << ")'";<br>
-  Â  break;<br>
-  }<br>
-  case OperatorTy::Vcall: {<br>
-  Â  OS << "`vcall'{";<br>
-  Â  OS << Thunk->OffsetInVTable << ", {flat}}";<br>
-  Â  break;<br>
-  }<br>
-  case OperatorTy::DynamicInitializer:<br>
-  case OperatorTy::DynamicAtexitDestructor:<br>
-  Â  OS << "''";<br>
-  Â  break;<br>
-<br>
-  case OperatorTy::LocalStaticGuard: {<br>
-  Â  const LocalStaticGuardVariable &LSG =<br>
-  Â  Â  Â  static_cast<const LocalStaticGuardVariable &>(*Operator);<br>
-  Â  OS << Operator->Info->Name;<br>
-  Â  if (LSG.ScopeIndex > 0)<br>
-  Â  Â  OS << "{" << LSG.ScopeIndex << "}";<br>
-  Â  break;<br>
-  }<br>
-  default:<br>
-  Â  OS << Operator->Info->Name;<br>
-  Â  if (Operator->IsTemplateInstantiation)<br>
-  Â  Â  outputParameterList(OS, *Operator->TParams);<br>
-  Â  break;<br>
-  }<br>
-}<br>
-<br>
-static void outputSpecialOperator(OutputStream &OS, const Name *OuterName) {<br>
-  assert(OuterName);<br>
-  // The last component should be an operator.<br>
-  const OperatorInfo *Operator = lastComponentAsOperator(OuterName);<br>
-<br>
-  assert(Operator->IsOperator);<br>
-  const OperatorInfo &Oper = static_cast<const OperatorInfo &>(*Operator);<br>
-  switch (Oper.Info->Operator) {<br>
-  case OperatorTy::StringLiteral: {<br>
-  Â  const StringLiteral &SL = static_cast<const StringLiteral &>(Oper);<br>
-  Â  outputStringLiteral(OS, SL);<br>
-  Â  break;<br>
-  }<br>
-  case OperatorTy::Vcall: {<br>
-  Â  const VirtualMemberPtrThunk &Thunk =<br>
-  Â  Â  Â  static_cast<const VirtualMemberPtrThunk &>(Oper);<br>
-  Â  OS << "[thunk]: ";<br>
-  Â  outputCallingConvention(OS, Thunk.CC);<br>
-  Â  OS << " ";<br>
-  Â  // Print out namespaces or outer class BackReferences.<br>
-  Â  const Name *N = OuterName;<br>
-  Â  for (; N->Next; N = N->Next) {<br>
-  Â  Â  outputNameComponent(OS, *N);<br>
-  Â  Â  OS << "::";<br>
-  Â  }<br>
-  Â  OS << "`vcall'{";<br>
-  Â  OS << Thunk.OffsetInVTable << ", {flat}}";<br>
-  Â  break;<br>
-  }<br>
-  default:<br>
-  Â  // There are no other special operator categories.<br>
-  Â  LLVM_BUILTIN_UNREACHABLE;<br>
-  }<br>
-}<br>
-<br>
-namespace {<br>
-<br>
-Type *Type::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<Type>(*this);<br>
-}<br>
-<br>
-// Write the "first half" of a given type.<br>
-void Type::outputPre(OutputStream &OS, Type &Ty) {<br>
-  // Function types require custom handling of const and static so we<br>
-  // handle them separately.  All other types use the same decoration<br>
-  // for these modifiers, so handle them here in common code.<br>
-  if (Ty.Prim == PrimTy::Function) {<br>
-  Â  Ty.outputPre(OS);<br>
-  Â  return;<br>
-  }<br>
-<br>
-  switch (Ty.Storage) {<br>
-  case StorageClass::PrivateStatic:<br>
-  case StorageClass::PublicStatic:<br>
-  case StorageClass::ProtectedStatic:<br>
-  Â  OS << "static ";<br>
-  default:<br>
-  Â  break;<br>
-  }<br>
-  Ty.outputPre(OS);<br>
-<br>
-  outputQualifiers(OS, Ty.Quals);<br>
-}<br>
-<br>
-// Write the "second half" of a given type.<br>
-void Type::outputPost(OutputStream &OS, Type &Ty) { Ty.outputPost(OS); }<br>
-<br>
-void Type::outputPre(OutputStream &OS) {<br>
-  switch (Prim) {<br>
-  case PrimTy::Void:<br>
-  Â  OS << "void";<br>
-  Â  break;<br>
-  case PrimTy::Bool:<br>
-  Â  OS << "bool";<br>
-  Â  break;<br>
-  case PrimTy::Char:<br>
-  Â  OS << "char";<br>
-  Â  break;<br>
-  case PrimTy::Schar:<br>
-  Â  OS << "signed char";<br>
-  Â  break;<br>
-  case PrimTy::Uchar:<br>
-  Â  OS << "unsigned char";<br>
-  Â  break;<br>
-  case PrimTy::Char16:<br>
-  Â  OS << "char16_t";<br>
-  Â  break;<br>
-  case PrimTy::Char32:<br>
-  Â  OS << "char32_t";<br>
-  Â  break;<br>
-  case PrimTy::Short:<br>
-  Â  OS << "short";<br>
-  Â  break;<br>
-  case PrimTy::Ushort:<br>
-  Â  OS << "unsigned short";<br>
-  Â  break;<br>
-  case PrimTy::Int:<br>
-  Â  OS << "int";<br>
-  Â  break;<br>
-  case PrimTy::Uint:<br>
-  Â  OS << "unsigned int";<br>
-  Â  break;<br>
-  case PrimTy::Long:<br>
-  Â  OS << "long";<br>
-  Â  break;<br>
-  case PrimTy::Ulong:<br>
-  Â  OS << "unsigned long";<br>
-  Â  break;<br>
-  case PrimTy::Int64:<br>
-  Â  OS << "__int64";<br>
-  Â  break;<br>
-  case PrimTy::Uint64:<br>
-  Â  OS << "unsigned __int64";<br>
-  Â  break;<br>
-  case PrimTy::Wchar:<br>
-  Â  OS << "wchar_t";<br>
-  Â  break;<br>
-  case PrimTy::Float:<br>
-  Â  OS << "float";<br>
-  Â  break;<br>
-  case PrimTy::Double:<br>
-  Â  OS << "double";<br>
-  Â  break;<br>
-  case PrimTy::Ldouble:<br>
-  Â  OS << "long double";<br>
-  Â  break;<br>
-  case PrimTy::Nullptr:<br>
-  Â  OS << "std::nullptr_t";<br>
-  Â  break;<br>
-  case PrimTy::Custom:<br>
-  Â  OS << Custom;<br>
-  Â  break;<br>
-  case PrimTy::Vbtable:<br>
-  case PrimTy::Vftable:<br>
-  Â  break;<br>
-  default:<br>
-  Â  assert(false && "Invalid primitive type!");<br>
+static bool isTagType(StringView S) {<br>
+  switch (S.front()) {<br>
+  case 'T': // union<br>
+  case 'U': // struct<br>
+  case 'V': // class<br>
+  case 'W': // enum<br>
+  Â  return true;<br>
  Â }<br>
-}<br>
-void Type::outputPost(OutputStream &OS) {}<br>
-<br>
-Type *PointerType::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<PointerType>(*this);<br>
+  return false;<br>
 }<br>
<br>
-static void outputPointerIndicator(OutputStream &OS, PointerAffinity Affinity,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â const Name *MemberName,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â const Type *Pointee) {<br>
-  // "[]" and "()" (for function parameters) take precedence over "*",<br>
-  // so "int *x(int)" means "x is a function returning int *". We need<br>
-  // parentheses to supercede the default precedence. (e.g. we want to<br>
-  // emit something like "int (*x)(int)".)<br>
-  if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array) {<br>
-  Â  OS << "(";<br>
-  Â  if (Pointee->Prim == PrimTy::Function) {<br>
-  Â  Â  const FunctionType *FTy = static_cast<const FunctionType *>(Pointee);<br>
-  Â  Â  assert(FTy->IsFunctionPointer);<br>
-  Â  Â  outputCallingConvention(OS, FTy->CallConvention);<br>
-  Â  Â  OS << " ";<br>
-  Â  }<br>
-  }<br>
+static bool isPointerType(StringView S) {<br>
+  if (S.startsWith("$$Q")) // foo &&<br>
+  Â  return true;<br>
<br>
-  if (MemberName) {<br>
-  Â  outputName(OS, MemberName, Pointee);<br>
-  Â  OS << "::";<br>
+  switch (S.front()) {<br>
+  case 'A': // foo &<br>
+  case 'P': // foo *<br>
+  case 'Q': // foo *const<br>
+  case 'R': // foo *volatile<br>
+  case 'S': // foo *const volatile<br>
+  Â  return true;<br>
  Â }<br>
-<br>
-  if (Affinity == PointerAffinity::Pointer)<br>
-  Â  OS << "*";<br>
-  else if (Affinity == PointerAffinity::Reference)<br>
-  Â  OS << "&";<br>
-  else<br>
-  Â  OS << "&&";<br>
-}<br>
-<br>
-void PointerType::outputPre(OutputStream &OS) {<br>
-  Type::outputPre(OS, *Pointee);<br>
-<br>
-  outputSpaceIfNecessary(OS);<br>
-<br>
-  if (Quals & Q_Unaligned)<br>
-  Â  OS << "__unaligned ";<br>
-<br>
-  outputPointerIndicator(OS, Affinity, nullptr, Pointee);<br>
-<br>
-  // FIXME: We should output this, but it requires updating lots of tests.<br>
-  // if (Ty.Quals & Q_Pointer64)<br>
-  //  OS << " __ptr64";<br>
-}<br>
-<br>
-void PointerType::outputPost(OutputStream &OS) {<br>
-  if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array)<br>
-  Â  OS << ")";<br>
-<br>
-  Type::outputPost(OS, *Pointee);<br>
-}<br>
-<br>
-Type *MemberPointerType::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<MemberPointerType>(*this);<br>
-}<br>
-<br>
-void MemberPointerType::outputPre(OutputStream &OS) {<br>
-  Type::outputPre(OS, *Pointee);<br>
-<br>
-  outputSpaceIfNecessary(OS);<br>
-<br>
-  outputPointerIndicator(OS, PointerAffinity::Pointer, MemberName, Pointee);<br>
-<br>
-  // FIXME: We should output this, but it requires updating lots of tests.<br>
-  // if (Ty.Quals & Q_Pointer64)<br>
-  //  OS << " __ptr64";<br>
-}<br>
-<br>
-void MemberPointerType::outputPost(OutputStream &OS) {<br>
-  if (Pointee->Prim == PrimTy::Function || Pointee->Prim == PrimTy::Array)<br>
-  Â  OS << ")";<br>
-<br>
-  Type::outputPost(OS, *Pointee);<br>
-}<br>
-<br>
-Type *FunctionType::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<FunctionType>(*this);<br>
+  return false;<br>
 }<br>
<br>
-void FunctionType::outputPre(OutputStream &OS) {<br>
-  if ((FunctionClass & StaticThisAdjust) || (FunctionClass & VirtualThisAdjust))<br>
-  Â  OS << "[thunk]: ";<br>
-<br>
-  if (!(FunctionClass & Global)) {<br>
-  Â  if (FunctionClass & Static)<br>
-  Â  Â  OS << "static ";<br>
-  }<br>
-  if (FunctionClass & ExternC)<br>
-  Â  OS << "extern \"C\" ";<br>
-<br>
-  if (FunctionClass & Virtual)<br>
-  Â  OS << "virtual ";<br>
-<br>
-  if (ReturnType) {<br>
-  Â  Type::outputPre(OS, *ReturnType);<br>
-  Â  OS << " ";<br>
-  }<br>
+static bool isArrayType(StringView S) { return S[0] == 'Y'; }<br>
<br>
-  // Function pointers print the calling convention as void (__cdecl *)(params)<br>
-  // rather than void __cdecl (*)(params).  So we need to let the PointerType<br>
-  // class handle this.<br>
-  if (!IsFunctionPointer)<br>
-  Â  outputCallingConvention(OS, CallConvention);<br>
+static bool isFunctionType(StringView S) {<br>
+  return S.startsWith("$$A8@@") || S.startsWith("$$A6");<br>
 }<br>
<br>
-void FunctionType::outputPost(OutputStream &OS) {<br>
-  // extern "C" functions don't have a prototype.<br>
-  if (FunctionClass & NoPrototype)<br>
-  Â  return;<br>
-<br>
-  if (FunctionClass & StaticThisAdjust) {<br>
-  Â  OS << "`adjustor{" << ThisAdjust->StaticOffset << "}'";<br>
-  } else if (FunctionClass & VirtualThisAdjust) {<br>
-  Â  if (FunctionClass & VirtualThisAdjustEx) {<br>
-  Â  Â  OS << "`vtordispex{" << ThisAdjust->VBPtrOffset << ", "<br>
-  Â  Â  Â  Â << ThisAdjust->VBOffsetOffset << ", " << ThisAdjust->VtordispOffset<br>
-  Â  Â  Â  Â << ", " << ThisAdjust->StaticOffset << "}'";<br>
-  Â  } else {<br>
-  Â  Â  OS << "`vtordisp{" << ThisAdjust->VtordispOffset << ", "<br>
-  Â  Â  Â  Â << ThisAdjust->StaticOffset << "}'";<br>
-  Â  }<br>
-  }<br>
-<br>
-  OS << "(";<br>
-  outputParameterList(OS, Params);<br>
-  OS << ")";<br>
-  if (Quals & Q_Const)<br>
-  Â  OS << " const";<br>
-  if (Quals & Q_Volatile)<br>
-  Â  OS << " volatile";<br>
-  if (Quals & Q_Restrict)<br>
-  Â  OS << " __restrict";<br>
-  if (Quals & Q_Unaligned)<br>
-  Â  OS << " __unaligned";<br>
-<br>
-  if (RefKind == ReferenceKind::LValueRef)<br>
-  Â  OS << " &";<br>
-  else if (RefKind == ReferenceKind::RValueRef)<br>
-  Â  OS << " &&";<br>
-<br>
-  if (ReturnType)<br>
-  Â  Type::outputPost(OS, *ReturnType);<br>
-  return;<br>
+static FunctionRefQualifier<br>
+demangleFunctionRefQualifier(StringView &MangledName) {<br>
+  if (MangledName.consumeFront('G'))<br>
+  Â  return FunctionRefQualifier::Reference;<br>
+  else if (MangledName.consumeFront('H'))<br>
+  Â  return FunctionRefQualifier::RValueReference;<br>
+  return FunctionRefQualifier::None;<br>
 }<br>
<br>
-Type *UdtType::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<UdtType>(*this);<br>
-}<br>
+static std::pair<Qualifiers, PointerAffinity><br>
+demanglePointerCVQualifiers(StringView &MangledName) {<br>
+  if (MangledName.consumeFront("$$Q"))<br>
+  Â  return std::make_pair(Q_None, PointerAffinity::RValueReference);<br>
<br>
-void UdtType::outputPre(OutputStream &OS) {<br>
-  switch (Prim) {<br>
-  case PrimTy::Class:<br>
-  Â  OS << "class ";<br>
-  Â  break;<br>
-  case PrimTy::Struct:<br>
-  Â  OS << "struct ";<br>
-  Â  break;<br>
-  case PrimTy::Union:<br>
-  Â  OS << "union ";<br>
-  Â  break;<br>
-  case PrimTy::Enum:<br>
-  Â  OS << "enum ";<br>
-  Â  break;<br>
+  switch (MangledName.popFront()) {<br>
+  case 'A':<br>
+  Â  return std::make_pair(Q_None, PointerAffinity::Reference);<br>
+  case 'P':<br>
+  Â  return std::make_pair(Q_None, PointerAffinity::Pointer);<br>
+  case 'Q':<br>
+  Â  return std::make_pair(Q_Const, PointerAffinity::Pointer);<br>
+  case 'R':<br>
+  Â  return std::make_pair(Q_Volatile, PointerAffinity::Pointer);<br>
+  case 'S':<br>
+  Â  return std::make_pair(Qualifiers(Q_Const | Q_Volatile),<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  PointerAffinity::Pointer);<br>
  Â default:<br>
-  Â  assert(false && "Not a udt type!");<br>
-  }<br>
-<br>
-  outputName(OS, UdtName, this);<br>
-}<br>
-<br>
-Type *ArrayType::clone(ArenaAllocator &Arena) const {<br>
-  return Arena.alloc<ArrayType>(*this);<br>
-}<br>
-<br>
-void ArrayType::outputPre(OutputStream &OS) {<br>
-  Type::outputPre(OS, *ElementType);<br>
-}<br>
-<br>
-void ArrayType::outputPost(OutputStream &OS) {<br>
-  ArrayDimension *D = Dims;<br>
-  while (D) {<br>
-  Â  OS << "[";<br>
-  Â  if (D->Dim > 0)<br>
-  Â  Â  OS << D->Dim;<br>
-  Â  OS << "]";<br>
-  Â  D = D->Next;<br>
+  Â  assert(false && "Ty is not a pointer type!");<br>
  Â }<br>
-<br>
-  Type::outputPost(OS, *ElementType);<br>
+  return std::make_pair(Q_None, PointerAffinity::Pointer);<br>
 }<br>
<br>
-struct Symbol {<br>
-  SymbolCategory Category;<br>
-<br>
-  Qualifiers SymbolQuals = Q_None;<br>
-  Name *SymbolName = nullptr;<br>
-  Type *SymbolType = nullptr;<br>
-};<br>
-<br>
-} // namespace<br>
-<br>
 namespace {<br>
<br>
 struct BackrefContext {<br>
  Â static constexpr size_t Max = 10;<br>
<br>
-  Type *FunctionParams[Max];<br>
+  TypeNode *FunctionParams[Max];<br>
  Â size_t FunctionParamCount = 0;<br>
<br>
  Â // The first 10 BackReferences in a mangled name can be back-referenced by<br>
  Â // special name @[0-9]. This is a storage for the first 10 BackReferences.<br>
-  StringView Names[Max];<br>
+  NamedIdentifierNode *Names[Max];<br>
  Â size_t NamesCount = 0;<br>
 };<br>
<br>
@@ -1404,10 +268,7 @@ public:<br>
<br>
  Â // You are supposed to call parse() first and then check if error is true.  If<br>
  Â // it is false, call output() to write the formatted name to the given stream.<br>
-  Symbol *parse(StringView &MangledName);<br>
-  Symbol *parseOperator(StringView &MangledName);<br>
-<br>
-  void output(const Symbol *S, OutputStream &OS);<br>
+  SymbolNode *parse(StringView &MangledName);<br>
<br>
  Â // True if an error occurred.<br>
  Â bool Error = false;<br>
@@ -1415,28 +276,28 @@ public:<br>
  Â void dumpBackReferences();<br>
<br>
 private:<br>
-  std::pair<SymbolCategory, Type *><br>
-  demangleSymbolCategoryAndType(StringView &MangledName);<br>
+  SymbolNode *demangleEncodedSymbol(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  QualifiedNameNode *QN);<br>
<br>
-  Type *demangleVariableEncoding(StringView &MangledName, StorageClass SC);<br>
-  Type *demangleFunctionEncoding(StringView &MangledName);<br>
-  uint64_t demangleThunkThisAdjust(StringView &MangledName);<br>
+  VariableSymbolNode *demangleVariableEncoding(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â StorageClass SC);<br>
+  FunctionSymbolNode *demangleFunctionEncoding(StringView &MangledName);<br>
<br>
  Â Qualifiers demanglePointerExtQualifiers(StringView &MangledName);<br>
<br>
  Â // Parser functions. This is a recursive-descent parser.<br>
-  Type *demangleType(StringView &MangledName, QualifierMangleMode QMM);<br>
-  Type *demangleBasicType(StringView &MangledName);<br>
-  UdtType *demangleClassType(StringView &MangledName);<br>
-  PointerType *demanglePointerType(StringView &MangledName);<br>
-  MemberPointerType *demangleMemberPointerType(StringView &MangledName);<br>
-  FunctionType *demangleFunctionType(StringView &MangledName, bool HasThisQuals,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â bool IsFunctionPointer);<br>
+  TypeNode *demangleType(StringView &MangledName, QualifierMangleMode QMM);<br>
+  PrimitiveTypeNode *demanglePrimitiveType(StringView &MangledName);<br>
+  TagTypeNode *demangleClassType(StringView &MangledName);<br>
+  PointerTypeNode *demanglePointerType(StringView &MangledName);<br>
+  PointerTypeNode *demangleMemberPointerType(StringView &MangledName);<br>
+  FunctionSignatureNode *demangleFunctionType(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool HasThisQuals);<br>
<br>
-  ArrayType *demangleArrayType(StringView &MangledName);<br>
+  ArrayTypeNode *demangleArrayType(StringView &MangledName);<br>
<br>
-  TemplateParams *demangleTemplateParameterList(StringView &MangledName);<br>
-  FunctionParams demangleFunctionParameterList(StringView &MangledName);<br>
+  NodeArrayNode *demangleTemplateParameterList(StringView &MangledName);<br>
+  NodeArrayNode *demangleFunctionParameterList(StringView &MangledName);<br>
<br>
  Â std::pair<uint64_t, bool> demangleNumber(StringView &MangledName);<br>
  Â uint64_t demangleUnsigned(StringView &MangledName);<br>
@@ -1447,32 +308,59 @@ private:<br>
  Â /// Allocate a copy of \p Borrowed into memory that we own.<br>
  Â StringView copyString(StringView Borrowed);<br>
<br>
-  Name *demangleFullyQualifiedTypeName(StringView &MangledName);<br>
-  Name *demangleFullyQualifiedSymbolName(StringView &MangledName);<br>
+  QualifiedNameNode *demangleFullyQualifiedTypeName(StringView &MangledName);<br>
+  QualifiedNameNode *demangleFullyQualifiedSymbolName(StringView &MangledName);<br>
<br>
-  Name *demangleUnqualifiedTypeName(StringView &MangledName, bool Memorize);<br>
-  Name *demangleUnqualifiedSymbolName(StringView &MangledName,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  NameBackrefBehavior NBB);<br>
-<br>
-  Name *demangleNameScopeChain(StringView &MangledName, Name *UnqualifiedName);<br>
-  Name *demangleNameScopePiece(StringView &MangledName);<br>
-<br>
-  Name *demangleBackRefName(StringView &MangledName);<br>
-  Name *demangleTemplateInstantiationName(StringView &MangledName,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  NameBackrefBehavior NBB);<br>
-  std::pair<OperatorTy, Name *> demangleOperatorName(StringView &MangledName,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â bool FullyQualified);<br>
-  Name *demangleSimpleName(StringView &MangledName, bool Memorize);<br>
-  Name *demangleAnonymousNamespaceName(StringView &MangledName);<br>
-  Name *demangleLocallyScopedNamePiece(StringView &MangledName);<br>
-  StringLiteral *demangleStringLiteral(StringView &MangledName);<br>
+  IdentifierNode *demangleUnqualifiedTypeName(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool Memorize);<br>
+  IdentifierNode *demangleUnqualifiedSymbolName(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  NameBackrefBehavior NBB);<br>
+<br>
+  QualifiedNameNode *demangleNameScopeChain(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  IdentifierNode *UnqualifiedName);<br>
+  IdentifierNode *demangleNameScopePiece(StringView &MangledName);<br>
+<br>
+  NamedIdentifierNode *demangleBackRefName(StringView &MangledName);<br>
+  IdentifierNode *demangleTemplateInstantiationName(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  NameBackrefBehavior NBB);<br>
+  IdentifierNode *demangleFunctionIdentifierCode(StringView &MangledName);<br>
+  IdentifierNode *<br>
+  demangleFunctionIdentifierCode(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â FunctionIdentifierCodeGroup Group);<br>
+  StructorIdentifierNode *demangleStructorIdentifier(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â bool IsDestructor);<br>
+  ConversionOperatorIdentifierNode *<br>
+  demangleConversionOperatorIdentifier(StringView &MangledName);<br>
+  LiteralOperatorIdentifierNode *<br>
+  demangleLiteralOperatorIdentifier(StringView &MangledName);<br>
+<br>
+  SymbolNode *demangleSpecialIntrinsic(StringView &MangledName);<br>
+  SpecialTableSymbolNode *<br>
+  demangleSpecialTableSymbolNode(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â SpecialIntrinsicKind SIK);<br>
+  LocalStaticGuardVariableNode *<br>
+  demangleLocalStaticGuard(StringView &MangledName);<br>
+  VariableSymbolNode *demangleUntypedVariable(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView VariableName);<br>
+  VariableSymbolNode *<br>
+  demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView &MangledName);<br>
+  FunctionSymbolNode *demangleDynamicStructorFunction(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool IsDestructor);<br>
+<br>
+  NamedIdentifierNode *demangleSimpleName(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool Memorize);<br>
+  NamedIdentifierNode *demangleAnonymousNamespaceName(StringView &MangledName);<br>
+  NamedIdentifierNode *demangleLocallyScopedNamePiece(StringView &MangledName);<br>
+  EncodedStringLiteralNode *demangleStringLiteral(StringView &MangledName);<br>
+  FunctionSymbolNode *demangleVcallThunkNode(StringView &MangledName);<br>
<br>
  Â StringView demangleSimpleString(StringView &MangledName, bool Memorize);<br>
<br>
  Â FuncClass demangleFunctionClass(StringView &MangledName);<br>
  Â CallingConv demangleCallingConvention(StringView &MangledName);<br>
  Â StorageClass demangleVariableStorageClass(StringView &MangledName);<br>
-  ReferenceKind demangleReferenceKind(StringView &MangledName);<br>
  Â void demangleThrowSpecification(StringView &MangledName);<br>
  Â wchar_t demangleWcharLiteral(StringView &MangledName);<br>
  Â uint8_t demangleCharLiteral(StringView &MangledName);<br>
@@ -1506,121 +394,455 @@ StringView Demangler::copyString(StringV<br>
  Â return {Stable, Borrowed.size()};<br>
 }<br>
<br>
-Symbol *Demangler::parseOperator(StringView &MangledName) {<br>
-  Symbol *S = Arena.alloc<Symbol>();<br>
-<br>
-  bool IsMember = false;<br>
-  OperatorTy OTy;<br>
-  std::tie(OTy, S->SymbolName) = demangleOperatorName(MangledName, true);<br>
-  switch (OTy) {<br>
-  case OperatorTy::StringLiteral:<br>
-  Â  S->Category = SymbolCategory::SpecialOperator;<br>
+SpecialTableSymbolNode *<br>
+Demangler::demangleSpecialTableSymbolNode(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  SpecialIntrinsicKind K) {<br>
+  NamedIdentifierNode *NI = Arena.alloc<NamedIdentifierNode>();<br>
+  switch (K) {<br>
+  case SpecialIntrinsicKind::Vftable:<br>
+  Â  NI->Name = "`vftable'";<br>
  Â  Â break;<br>
-  case OperatorTy::Vcall:<br>
-  Â  S->Category = SymbolCategory::UnnamedFunction;<br>
+  case SpecialIntrinsicKind::Vbtable:<br>
+  Â  NI->Name = "`vbtable'";<br>
  Â  Â break;<br>
-  case OperatorTy::LocalStaticGuard:<br>
-  Â  S->Category = SymbolCategory::UnnamedVariable;<br>
+  case SpecialIntrinsicKind::LocalVftable:<br>
+  Â  NI->Name = "`local vftable'";<br>
  Â  Â break;<br>
-  case OperatorTy::Vftable:  Â  Â  Â  Â  Â  Â  Â  // Foo@@6B@<br>
-  case OperatorTy::LocalVftable:  Â  Â  Â  Â  Â // Foo@@6B@<br>
-  case OperatorTy::RttiCompleteObjLocator: // Foo@@6B@<br>
-  case OperatorTy::Vbtable:  Â  Â  Â  Â  Â  Â  Â  // Foo@@7B@<br>
-  Â  S->Category = SymbolCategory::UnnamedVariable;<br>
-  Â  switch (MangledName.popFront()) {<br>
-  Â  case '6':<br>
-  Â  case '7': {<br>
-  Â  Â  std::tie(S->SymbolQuals, IsMember) = demangleQualifiers(MangledName);<br>
-  Â  Â  if (!MangledName.consumeFront('@')) {<br>
-  Â  Â  Â  IndirectTable *Table = Arena.alloc<IndirectTable>(OTy);<br>
-  Â  Â  Â  Table->TableTarget = demangleFullyQualifiedTypeName(MangledName);<br>
-  Â  Â  Â  Table->TableLocation = S->SymbolName;<br>
-  Â  Â  Â  S->SymbolName = Table;<br>
-  Â  Â  }<br>
-  Â  Â  break;<br>
-  Â  }<br>
-  Â  default:<br>
-  Â  Â  Error = true;<br>
-  Â  Â  break;<br>
-  Â  }<br>
+  case SpecialIntrinsicKind::RttiCompleteObjLocator:<br>
+  Â  NI->Name = "`RTTI Complete Object Locator'";<br>
  Â  Â break;<br>
-  case OperatorTy::RttiTypeDescriptor: // <type>@@8<br>
-  Â  S->Category = SymbolCategory::UnnamedVariable;<br>
-  Â  S->SymbolType = demangleType(MangledName, QualifierMangleMode::Result);<br>
+  default:<br>
+  Â  LLVM_BUILTIN_UNREACHABLE;<br>
+  }<br>
+  QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);<br>
+  SpecialTableSymbolNode *STSN = Arena.alloc<SpecialTableSymbolNode>();<br>
+  STSN->Name = QN;<br>
+  bool IsMember = false;<br>
+  char Front = MangledName.popFront();<br>
+  if (Front != '6' && Front != '7') {<br>
+  Â  Error = true;<br>
+  Â  return nullptr;<br>
+  }<br>
+<br>
+  std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName);<br>
+  if (!MangledName.consumeFront('@'))<br>
+  Â  STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);<br>
+  return STSN;<br>
+}<br>
+<br>
+LocalStaticGuardVariableNode *<br>
+Demangler::demangleLocalStaticGuard(StringView &MangledName) {<br>
+  LocalStaticGuardIdentifierNode *LSGI =<br>
+  Â  Â  Arena.alloc<LocalStaticGuardIdentifierNode>();<br>
+  QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI);<br>
+  LocalStaticGuardVariableNode *LSGVN =<br>
+  Â  Â  Arena.alloc<LocalStaticGuardVariableNode>();<br>
+  LSGVN->Name = QN;<br>
+<br>
+  if (MangledName.consumeFront("4IA"))<br>
+  Â  LSGVN->IsVisible = false;<br>
+  else if (MangledName.consumeFront("5"))<br>
+  Â  LSGVN->IsVisible = true;<br>
+  else {<br>
+  Â  Error = true;<br>
+  Â  return nullptr;<br>
+  }<br>
+<br>
+  if (!MangledName.empty())<br>
+  Â  LSGI->ScopeIndex = demangleUnsigned(MangledName);<br>
+  return LSGVN;<br>
+}<br>
+<br>
+static NamedIdentifierNode *synthesizeNamedIdentifier(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView Name) {<br>
+  NamedIdentifierNode *Id = Arena.alloc<NamedIdentifierNode>();<br>
+  Id->Name = Name;<br>
+  return Id;<br>
+}<br>
+<br>
+static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  IdentifierNode *Identifier) {<br>
+  QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();<br>
+  QN->Components = Arena.alloc<NodeArrayNode>();<br>
+  QN->Components->Count = 1;<br>
+  QN->Components->Nodes = Arena.allocArray<Node *>(1);<br>
+  QN->Components->Nodes[0] = Identifier;<br>
+  return QN;<br>
+}<br>
+<br>
+static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView Name) {<br>
+  NamedIdentifierNode *Id = synthesizeNamedIdentifier(Arena, Name);<br>
+  return synthesizeQualifiedName(Arena, Id);<br>
+}<br>
+<br>
+static VariableSymbolNode *synthesizeVariable(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  TypeNode *Type,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  StringView VariableName) {<br>
+  VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();<br>
+  VSN->Type = Type;<br>
+  VSN->Name = synthesizeQualifiedName(Arena, VariableName);<br>
+  return VSN;<br>
+}<br>
+<br>
+VariableSymbolNode *Demangler::demangleUntypedVariable(<br>
+  Â  ArenaAllocator &Arena, StringView &MangledName, StringView VariableName) {<br>
+  NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName);<br>
+  QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);<br>
+  VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();<br>
+  VSN->Name = QN;<br>
+  if (MangledName.consumeFront("8"))<br>
+  Â  return VSN;<br>
+<br>
+  Error = true;<br>
+  return nullptr;<br>
+}<br>
+<br>
+VariableSymbolNode *<br>
+Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â StringView &MangledName) {<br>
+  RttiBaseClassDescriptorNode *RBCDN =<br>
+  Â  Â  Arena.alloc<RttiBaseClassDescriptorNode>();<br>
+  RBCDN->NVOffset = demangleUnsigned(MangledName);<br>
+  RBCDN->VBPtrOffset = demangleSigned(MangledName);<br>
+  RBCDN->VBTableOffset = demangleUnsigned(MangledName);<br>
+  RBCDN->Flags = demangleUnsigned(MangledName);<br>
+  if (Error)<br>
+  Â  return nullptr;<br>
+<br>
+  VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();<br>
+  VSN->Name = demangleNameScopeChain(MangledName, RBCDN);<br>
+  MangledName.consumeFront('8');<br>
+  return VSN;<br>
+}<br>
+<br>
+FunctionSymbolNode *<br>
+Demangler::demangleDynamicStructorFunction(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â bool IsDestructor) {<br>
+  DynamicStructorIdentifierNode *DSIN =<br>
+  Â  Â  Arena.alloc<DynamicStructorIdentifierNode>();<br>
+  DSIN->IsDestructor = IsDestructor;<br>
+  DSIN->Name = demangleFullyQualifiedTypeName(MangledName);<br>
+  QualifiedNameNode *QNN = synthesizeQualifiedName(Arena, DSIN);<br>
+  FunctionSymbolNode *FSN = demangleFunctionEncoding(MangledName);<br>
+  FSN->Name = QNN;<br>
+  return FSN;<br>
+}<br>
+<br>
+SymbolNode *Demangler::demangleSpecialIntrinsic(StringView &MangledName) {<br>
+  SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName);<br>
+  if (SIK == SpecialIntrinsicKind::None)<br>
+  Â  return nullptr;<br>
+<br>
+  switch (SIK) {<br>
+  case SpecialIntrinsicKind::StringLiteralSymbol:<br>
+  Â  return demangleStringLiteral(MangledName);<br>
+  case SpecialIntrinsicKind::Vftable:<br>
+  case SpecialIntrinsicKind::Vbtable:<br>
+  case SpecialIntrinsicKind::LocalVftable:<br>
+  case SpecialIntrinsicKind::RttiCompleteObjLocator:<br>
+  Â  return demangleSpecialTableSymbolNode(MangledName, SIK);<br>
+  case SpecialIntrinsicKind::VcallThunk:<br>
+  Â  return demangleVcallThunkNode(MangledName);<br>
+  case SpecialIntrinsicKind::LocalStaticGuard:<br>
+  Â  return demangleLocalStaticGuard(MangledName);<br>
+  case SpecialIntrinsicKind::RttiTypeDescriptor: {<br>
+  Â  TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);<br>
  Â  Â if (Error)<br>
  Â  Â  Â break;<br>
  Â  Â if (!MangledName.consumeFront("@8"))<br>
-  Â  Â  Error = true;<br>
+  Â  Â  break;<br>
  Â  Â if (!MangledName.empty())<br>
-  Â  Â  Error = true;<br>
-  Â  break;<br>
+  Â  Â  break;<br>
+  Â  return synthesizeVariable(Arena, T, "`RTTI Type Descriptor'");<br>
+  }<br>
+  case SpecialIntrinsicKind::RttiBaseClassArray:<br>
+  Â  return demangleUntypedVariable(Arena, MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â "`RTTI Base Class Array'");<br>
+  case SpecialIntrinsicKind::RttiClassHierarchyDescriptor:<br>
+  Â  return demangleUntypedVariable(Arena, MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â "`RTTI Class Hierarchy Descriptor'");<br>
+  case SpecialIntrinsicKind::RttiBaseClassDescriptor:<br>
+  Â  return demangleRttiBaseClassDescriptorNode(Arena, MangledName);<br>
+  case SpecialIntrinsicKind::DynamicInitializer:<br>
+  Â  return demangleDynamicStructorFunction(MangledName, false);<br>
+  case SpecialIntrinsicKind::DynamicAtexitDestructor:<br>
+  Â  return demangleDynamicStructorFunction(MangledName, true);<br>
  Â default:<br>
-  Â  if (!Error)<br>
-  Â  Â  std::tie(S->Category, S->SymbolType) =<br>
-  Â  Â  Â  Â  demangleSymbolCategoryAndType(MangledName);<br>
  Â  Â break;<br>
  Â }<br>
+  Error = true;<br>
+  return nullptr;<br>
+}<br>
+<br>
+IdentifierNode *<br>
+Demangler::demangleFunctionIdentifierCode(StringView &MangledName) {<br>
+  assert(MangledName.startsWith('?'));<br>
+  MangledName = MangledName.dropFront();<br>
+<br>
+  if (MangledName.consumeFront("__"))<br>
+  Â  return demangleFunctionIdentifierCode(<br>
+  Â  Â  Â  MangledName, FunctionIdentifierCodeGroup::DoubleUnder);<br>
+  else if (MangledName.consumeFront("_"))<br>
+  Â  return demangleFunctionIdentifierCode(MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  FunctionIdentifierCodeGroup::Under);<br>
+  return demangleFunctionIdentifierCode(MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  FunctionIdentifierCodeGroup::Basic);<br>
+}<br>
+<br>
+StructorIdentifierNode *<br>
+Demangler::demangleStructorIdentifier(StringView &MangledName,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool IsDestructor) {<br>
+  StructorIdentifierNode *N = Arena.alloc<StructorIdentifierNode>();<br>
+  N->IsDestructor = IsDestructor;<br>
+  return N;<br>
+}<br>
+<br>
+ConversionOperatorIdentifierNode *<br>
+Demangler::demangleConversionOperatorIdentifier(StringView &MangledName) {<br>
+  ConversionOperatorIdentifierNode *N =<br>
+  Â  Â  Arena.alloc<ConversionOperatorIdentifierNode>();<br>
+  return N;<br>
+}<br>
+<br>
+LiteralOperatorIdentifierNode *<br>
+Demangler::demangleLiteralOperatorIdentifier(StringView &MangledName) {<br>
+  LiteralOperatorIdentifierNode *N =<br>
+  Â  Â  Arena.alloc<LiteralOperatorIdentifierNode>();<br>
+  N->Name = demangleSimpleString(MangledName, false);<br>
+  return N;<br>
+}<br>
+<br>
+IntrinsicFunctionKind<br>
+translateIntrinsicFunctionCode(char CH, FunctionIdentifierCodeGroup Group) {<br>
+  // Not all ? identifiers are intrinsics *functions*.  This function only maps<br>
+  // operator codes for the special functions, all others are handled elsewhere,<br>
+  // hence the IFK::None entries in the table.<br>
+  using IFK = IntrinsicFunctionKind;<br>
+  static IFK Basic[36] = {<br>
+  Â  Â  IFK::None,  Â  Â  Â  Â  Â  Â // ?0 # Foo::Foo()<br>
+  Â  Â  IFK::None,  Â  Â  Â  Â  Â  Â // ?1 # Foo::~Foo()<br>
+  Â  Â  IFK::New,  Â  Â  Â  Â  Â  Â  // ?2 # operator new<br>
+  Â  Â  IFK::Delete,  Â  Â  Â  Â  Â // ?3 # operator delete<br>
+  Â  Â  IFK::Assign,  Â  Â  Â  Â  Â // ?4 # operator=<br>
+  Â  Â  IFK::RightShift,  Â  Â  Â // ?5 # operator>><br>
+  Â  Â  IFK::LeftShift,  Â  Â  Â  // ?6 # operator<<<br>
+  Â  Â  IFK::LogicalNot,  Â  Â  Â // ?7 # operator!<br>
+  Â  Â  IFK::Equals,  Â  Â  Â  Â  Â // ?8 # operator==<br>
+  Â  Â  IFK::NotEquals,  Â  Â  Â  // ?9 # operator!=<br>
+  Â  Â  IFK::ArraySubscript,  Â // ?A # operator[]<br>
+  Â  Â  IFK::None,  Â  Â  Â  Â  Â  Â // ?B # Foo::operator <type>()<br>
+  Â  Â  IFK::Pointer,  Â  Â  Â  Â  // ?C # operator-><br>
+  Â  Â  IFK::Dereference,  Â  Â  // ?D # operator*<br>
+  Â  Â  IFK::Increment,  Â  Â  Â  // ?E # operator++<br>
+  Â  Â  IFK::Decrement,  Â  Â  Â  // ?F # operator--<br>
+  Â  Â  IFK::Minus,  Â  Â  Â  Â  Â  // ?G # operator-<br>
+  Â  Â  IFK::Plus,  Â  Â  Â  Â  Â  Â // ?H # operator+<br>
+  Â  Â  IFK::BitwiseA</blockquote></div>