[MS Demangler] Demangle data member pointers

[zturner]

Summary

I intentionally didn't do member function pointers yet as I'm trying to keep the changes small and targeted.

The main trick here is being able to properly guess -- after you know you have a pointer -- whether it is a member pointer or not. You need to look for the pointee qualifier, but it is not necessarily the first character after the pointer type indicator.

[zturner]

I changed this slightly so that MemberPointerType is now its own derived class. This gives a little more control and flexibility over how we print them and also removes some branches from the pointer codepath, making each thing a little easier to follow.

[majnemer]

llvm/lib/Demangle/MicrosoftDemangle.cpp

250

s/True/Non-null/

536

Nit: Might wanna factor this condition into a little helper to ensure that pre and post are consistent.

[thakis]

a few nits (haven't looked at substance):

llvm/lib/Demangle/MicrosoftDemangle.cpp

290

no break after return

295

don't

306

just return MangledName.front() == '8';, ternary does nothing

[zturner]

ping. Any objections or suggestions?

[zturner]

Edit: Ignore that. Apparently I had a stale copy open in my browser and didn't notice that there are, in fact, already suggestions.

[zturner]

Fixed suggestions

[zturner]

llvm/lib/Demangle/MicrosoftDemangle.cpp

536

I've done this in a followup patch which I plan to apply after I submit the member function pointer patch, since there are some other changes that make sense to do at the same time such as moving the calling convention inside the parens.

[rnk]

lgtm

llvm/lib/Demangle/MicrosoftDemangle.cpp

 
 #include "llvm/Demangle/Demangle.h"
 
 #include "Compiler.h"
 #include "StringView.h"
 #include "Utility.h"
 
 #include <cctype>
+#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 {
 class ArenaAllocator {
enum class StorageClass : uint8_t {
   PrivateStatic,
   ProtectedStatic,
   PublicStatic,
   Global,
   FunctionLocalStatic
 };
 
 enum class QualifierMangleMode { Drop, Mangle, Result };
-enum class QualifierMangleLocation { Member, NonMember, Detect };
+enum class MemberPointerMode { Member, NonMember, DontKnow };
 
 // Calling conventions
 enum class CallingConv : uint8_t {
   None,
   Cdecl,
   Pascal,
   Thiscall,
   Stdcall,
struct Name {
   Name *Next = nullptr;
 };
 
 struct PointerType : public Type {
   Type *clone(ArenaAllocator &Arena) const override;
   void outputPre(OutputStream &OS) override;
   void outputPost(OutputStream &OS) override;
 
-  bool isMemberPointer() const { return false; }
+  // True if this is a member pointer.
+  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 {
   Type *clone(ArenaAllocator &Arena) const override;
   void outputPre(OutputStream &OS) override;
   void outputPost(OutputStream &OS) override;
 
   Type *ReturnType = nullptr;
   // If this is a reference, the type of reference.
   ReferenceKind RefKind;
 
   CallingConv CallConvention;
   FuncClass FunctionClass;

 } // namespace
 
 static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
   outputSpaceIfNecessary(OS);
 
   switch (CC) {
   case CallingConv::Cdecl:
     OS << "__cdecl";
     break;
   case CallingConv::Fastcall:
     OS << "__fastcall";
     break;
   case CallingConv::Pascal:
     OS << "__pascal";
     break;
   case CallingConv::Regcall:
     OS << "__regcall";
     break;
   case CallingConv::Stdcall:
     OS << "__stdcall";
     break;
   case CallingConv::Thiscall:
     OS << "__thiscall";
     break;
   case CallingConv::Eabi:
     OS << "__eabi";
     break;
   case CallingConv::Vectorcall:
     OS << "__vectorcall";
     break;
   case CallingConv::Clrcall:
     OS << "__clrcall";
     break;
void PointerType::outputPre(OutputStream &OS) {
 
   // "[]" 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 << "(";
 
+  if (MemberName) {
+    outputName(OS, MemberName);
+    OS << "::";
+  }
+
   if (Prim == PrimTy::Ptr)
     OS << "*";
   else
     OS << "&";
 
   // FIXME: We should output this, but it requires updating lots of tests.
   // if (Ty.Quals & Q_Pointer64)
   //  OS << " __ptr64";
void FunctionType::outputPre(OutputStream &OS) {
   if (!(FunctionClass & Global)) {
     if (FunctionClass & Static)
       OS << "static ";
   }
 
   if (ReturnType)
     Type::outputPre(OS, *ReturnType);
 
   outputCallingConvention(OS, CallConvention);
 }
 
 void FunctionType::outputPost(OutputStream &OS) {
   OS << "(";
   outputParameterList(OS, Params);
   OS << ")";
   if (Quals & Q_Const)
     OS << " const";
private:
   Type *demangleFunctionEncoding();
 
   Qualifiers demanglePointerExtQualifiers();
 
   // Parser functions. This is a recursive-descent parser.
   Type *demangleType(QualifierMangleMode QMM);
   Type *demangleBasicType();
   UdtType *demangleClassType();
-  PointerType *demanglePointerType();
+  PointerType *demanglePointerType(MemberPointerMode MPM);
 
   ArrayType *demangleArrayType();
 
   ParamList demangleParameterList();
 
   int demangleNumber();
   void demangleNamePiece(Name &Node, bool IsHead);
 
   StringView demangleString(bool memorize);
   void memorizeString(StringView s);
   Name *demangleName();
   void demangleOperator(Name *);
   StringView demangleOperatorName();
   int demangleFunctionClass();
   CallingConv demangleCallingConvention();
   StorageClass demangleVariableStorageClass();
   ReferenceKind demangleReferenceKind();
 
-  Qualifiers demangleFunctionQualifiers();
-  Qualifiers demangleVariablQualifiers();
-  Qualifiers demangleReturnTypQualifiers();
-
-  Qualifiers demangleQualifiers(
-      QualifierMangleLocation Location = QualifierMangleLocation::Detect);
+  std::pair<Qualifiers, bool> demangleQualifiers();
 
   // The result is written to this stream.
   OutputStream OS;
 
   // Mangled symbol. demangle* functions shorten this string
   // as they parse it.
   StringView MangledName;
 
Type *Demangler::demangleVariableEncoding() {
   //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
   switch (Ty->Prim) {
   case PrimTy::Ptr:
   case PrimTy::Ref: {
     Qualifiers ExtraChildQuals = Q_None;
     Ty->Quals = Qualifiers(Ty->Quals | demanglePointerExtQualifiers());
 
     PointerType *PTy = static_cast<PointerType *>(Ty);
-    QualifierMangleLocation Location = PTy->isMemberPointer()
-                                           ? QualifierMangleLocation::Member
-                                           : QualifierMangleLocation::NonMember;
 
-    ExtraChildQuals = demangleQualifiers(Location);
+    bool IsMember;
+    std::tie(ExtraChildQuals, IsMember) = demangleQualifiers();
 
-    if (PTy->isMemberPointer()) {
+    if (PTy->MemberName) {
       Name *BackRefName = demangleName();
       (void)BackRefName;
     }
 
     PTy->Pointee->Quals = Qualifiers(PTy->Pointee->Quals | ExtraChildQuals);
     break;
   }
   default:
-    Ty->Quals = demangleQualifiers();
+    Ty->Quals = demangleQualifiers().first;
     break;
   }
 
   return Ty;
 }
 
 // Sometimes numbers are encoded in mangled symbols. For example,
 // "int (*x)[20]" is a valid C type (x is a pointer to an array of
while (!MangledName.consumeFront("@")) {
 
     assert(!Error);
     demangleNamePiece(*Elem, Head == nullptr);
     if (Error)
       return nullptr;
 
     Elem->Next = Head;
     Head = Elem;
+    if (MangledName.empty()) {
+      Error = true;
+      return nullptr;
+    }
   }
 
   return Head;
 }
 
 void Demangler::demangleOperator(Name *OpName) {
   OpName->Operator = demangleOperatorName();
   if (!Error && !MangledName.empty() && MangledName.front() != '@')
case 'Z':
     return Global | Far;
   }
 
   Error = true;
   RestoreOnError.shouldRestore(true);
   return 0;
 }
 
-Qualifiers Demangler::demangleFunctionQualifiers() {
-  SwapAndRestore<StringView> RestoreOnError(MangledName, MangledName);
-  RestoreOnError.shouldRestore(false);
-
-  switch (MangledName.popFront()) {
-  case 'A':
-    return Q_None;
-  case 'B':
-    return Q_Const;
-  case 'C':
-    return Q_Volatile;
-  case 'D':
-    return Qualifiers(Q_Const | Q_Volatile);
-  }
-
-  Error = true;
-  RestoreOnError.shouldRestore(true);
-  return Q_None;
-}
-
 CallingConv Demangler::demangleCallingConvention() {
   switch (MangledName.popFront()) {
   case 'A':
   case 'B':
     return CallingConv::Cdecl;
   case 'C':
   case 'D':
     return CallingConv::Pascal;
case '3':
     return StorageClass::Global;
   case '4':
     return StorageClass::FunctionLocalStatic;
   }
   Error = true;
   return StorageClass::None;
 }
 
-Qualifiers Demangler::demangleVariablQualifiers() {
-  SwapAndRestore<StringView> RestoreOnError(MangledName, MangledName);
-  RestoreOnError.shouldRestore(false);
+std::pair<Qualifiers, bool> Demangler::demangleQualifiers() {
 
   switch (MangledName.popFront()) {
-  case 'A':
-    return Q_None;
-  case 'B':
-    return Q_Const;
-  case 'C':
-    return Q_Volatile;
-  case 'D':
-    return Qualifiers(Q_Const | Q_Volatile);
-  case 'E':
-    return Q_Far;
-  case 'F':
-    return Qualifiers(Q_Const | Q_Far);
-  case 'G':
-    return Qualifiers(Q_Volatile | Q_Far);
-  case 'H':
-    return Qualifiers(Q_Const | Q_Volatile | Q_Far);
-  }
-
-  Error = true;
-  RestoreOnError.shouldRestore(true);
-  return Q_None;
-}
-
-Qualifiers Demangler::demangleReturnTypQualifiers() {
-  if (!MangledName.consumeFront("?"))
-    return Q_None;
-
-  SwapAndRestore<StringView> RestoreOnError(MangledName, MangledName);
-  RestoreOnError.shouldRestore(false);
-
-  switch (MangledName.popFront()) {
-  case 'A':
-    return Q_None;
-  case 'B':
-    return Q_Const;
-  case 'C':
-    return Q_Volatile;
-  case 'D':
-    return Qualifiers(Q_Const | Q_Volatile);
-  }
-
-  Error = true;
-  RestoreOnError.shouldRestore(true);
-  return Q_None;
-}
-
-Qualifiers Demangler::demangleQualifiers(QualifierMangleLocation Location) {
-  if (Location == QualifierMangleLocation::Detect) {
-    switch (MangledName.front()) {
-    case 'Q':
-    case 'R':
-    case 'S':
-    case 'T':
-      Location = QualifierMangleLocation::Member;
-      break;
-    case 'A':
-    case 'B':
-    case 'C':
-    case 'D':
-      Location = QualifierMangleLocation::NonMember;
-      break;
-    default:
-      Error = true;
-      return Q_None;
-    }
-  }
-
-  if (Location == QualifierMangleLocation::Member) {
-    switch (MangledName.popFront()) {
-    // Member qualifiers
-    case 'Q':
-      return Q_None;
-    case 'R':
-      return Q_Const;
-    case 'S':
-      return Q_Volatile;
-    case 'T':
-      return Qualifiers(Q_Const | Q_Volatile);
-    }
-  } else {
-    switch (MangledName.popFront()) {
-    // Non-Member qualifiers
-    case 'A':
-      return Q_None;
-    case 'B':
-      return Q_Const;
-    case 'C':
-      return Q_Volatile;
-    case 'D':
-      return Qualifiers(Q_Const | Q_Volatile);
-    }
+    return std::make_pair(Q_None, true);
+    return std::make_pair(Q_Const, true);
+    return std::make_pair(Q_Volatile, true);
+    return std::make_pair(Qualifiers(Q_Const | Q_Volatile), true);
+    return std::make_pair(Q_None, false);
+    return std::make_pair(Q_Const, false);
+    return std::make_pair(Q_Volatile, false);
+    return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false);
   }
   Error = true;
-  return Q_None;
+  return std::make_pair(Q_None, false);
 }
 
 // <variable-type> ::= <type> <cvr-qualifiers>
 //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
 Type *Demangler::demangleType(QualifierMangleMode QMM) {
   Qualifiers Quals = Q_None;
-  if (QMM == QualifierMangleMode::Mangle)
-    Quals = Qualifiers(Quals | demangleQualifiers());
-  else if (QMM == QualifierMangleMode::Result) {
-    if (MangledName.consumeFront('?'))
-      Quals = Qualifiers(Quals | demangleQualifiers());
+  MemberPointerMode MPM = MemberPointerMode::DontKnow;
+  if (QMM == QualifierMangleMode::Mangle) {
+    bool IsMember = false;
+    std::tie(Quals, IsMember) = demangleQualifiers();
+    MPM = IsMember ? MemberPointerMode::Member : MemberPointerMode::NonMember;
+  } else if (QMM == QualifierMangleMode::Result) {
+    if (MangledName.consumeFront('?')) {
+      bool IsMember = false;
+      std::tie(Quals, IsMember) = demangleQualifiers();
+      MPM = IsMember ? MemberPointerMode::Member : MemberPointerMode::NonMember;
+    }
   }
 
   Type *Ty = nullptr;
   switch (MangledName.front()) {
   case 'T': // union
   case 'U': // struct
   case 'V': // class
   case 'W': // enum
     Ty = demangleClassType();
     break;
   case 'A': // foo &
   case 'P': // foo *
   case 'Q': // foo *const
   case 'R': // foo *volatile
   case 'S': // foo *const volatile
-    Ty = demanglePointerType();
+    Ty = demanglePointerType(MPM);
     break;
   case 'Y':
     Ty = demangleArrayType();
     break;
   default:
     Ty = demangleBasicType();
     break;
   }

 Type *Demangler::demangleFunctionEncoding() {
   FunctionType *FTy = Arena.alloc<FunctionType>();
 
   FTy->Prim = PrimTy::Function;
   FTy->FunctionClass = (FuncClass)demangleFunctionClass();
   if (functionHasThisPtr(*FTy)) {
     FTy->Quals = demanglePointerExtQualifiers();
     FTy->RefKind = demangleReferenceKind();
-    FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers());
+    FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers().first);
   }
 
   // Fields that appear on both member and non-member functions.
   FTy->CallConvention = demangleCallingConvention();
 
   // <return-type> ::= <type>
   //               ::= @ # structors (they have no declared return type)
   bool IsStructor = MangledName.consumeFront('@');
UdtType *Demangler::demangleClassType() {
   default:
     assert(false);
   }
 
   UTy->UdtName = demangleName();
   return UTy;
 }
 
+static bool isMemberPointer(StringView MangledName) {
+  // If it starts with a number, then 6 indicates a non-member function
+  // pointer, and 8 indicates a member function pointer.
+  if (startsWithDigit(MangledName)) {
+    assert(MangledName.front() == '6' || MangledName.front() == '8');
+    return (MangledName.front() == '8') ? true : false;
+  }
+
+  // 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
+
+  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;
+}
+
 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type>
 //                       # the E is required for 64-bit non-static pointers
-PointerType *Demangler::demanglePointerType() {
+PointerType *Demangler::demanglePointerType(MemberPointerMode MPM) {
   PointerType *Pointer = Arena.alloc<PointerType>();
 
   Pointer->Quals = Q_None;
   switch (MangledName.popFront()) {
   case 'A':
     Pointer->Prim = PrimTy::Ref;
     break;
   case 'P':
PointerType *Demangler::demanglePointerType(MemberPointerMode MPM) {
   case 'S':
     Pointer->Quals = Qualifiers(Q_Const | Q_Volatile);
     Pointer->Prim = PrimTy::Ptr;
     break;
   default:
     assert(false && "Ty is not a pointer type!");
   }
 
+  if (MPM == MemberPointerMode::DontKnow) {
+    bool IsMember = isMemberPointer(MangledName);
+    MPM = IsMember ? MemberPointerMode::Member : MemberPointerMode::NonMember;
+  }
+
+  if (MPM == MemberPointerMode::Member) {
+    Qualifiers ExtQuals = demanglePointerExtQualifiers();
+    Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
+
+    Qualifiers PointeeQuals = Q_None;
+    bool IsMember = false;
+    std::tie(PointeeQuals, IsMember) = demangleQualifiers();
+    assert(IsMember);
+    Pointer->MemberName = demangleName();
+
+    Pointer->Pointee = demangleType(QualifierMangleMode::Drop);
+    Pointer->Pointee->Quals = PointeeQuals;
+  } else {
     if (MangledName.consumeFront("6")) {
       FunctionType *FTy = Arena.alloc<FunctionType>();
       FTy->Prim = PrimTy::Function;
       FTy->CallConvention = demangleCallingConvention();
 
       FTy->ReturnType = demangleType(QualifierMangleMode::Drop);
       FTy->Params = demangleParameterList();
 
       if (!MangledName.consumeFront("@Z"))
         MangledName.consumeFront("Z");
 
       Pointer->Pointee = FTy;
       return Pointer;
     }
 
     Qualifiers ExtQuals = demanglePointerExtQualifiers();
     Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
     Pointer->Pointee = demangleType(QualifierMangleMode::Mangle);
+  }
   return Pointer;
 }
 
 Qualifiers Demangler::demanglePointerExtQualifiers() {
   Qualifiers Quals = Q_None;
   if (MangledName.consumeFront('E'))
     Quals = Qualifiers(Quals | Q_Pointer64);
   if (MangledName.consumeFront('I'))

llvm/test/Demangle/ms-mangle.test

 ; CHECK: int (*i)[20]
 
 ?FunArr@@3PAY0BE@P6AHHH@ZA
 ; CHECK: int __cdecl (*(*FunArr)[20])(int, int)
 
 ?j@@3P6GHCE@ZA
 ; CHECK: int __stdcall (*j)(signed char, unsigned char)
 
+?k@@3PTfoo@@DT1@
+; CHECK: char const volatile foo::*k
 
-; FIXME: We don't handle member pointers yet.
-; ?k@@3PTfoo@@DT1
-; FIXME: char const volatile foo::*k
+?k@@3PETfoo@@DET1@
+; CHECK: char const volatile foo::*k
 
-; ?k@@3PETfoo@@DET1
-; FIXME: char const volatile foo::*k
-
-; ?l@@3P8foo@@AEHH@ZQ1
+; FIXME: We don't support member function pointers yet.
+; ?l@@3P8foo@@AEHH@ZQ1@
 ; FIXME: int __thiscall (foo::*l)(int)
 
 ?g_cInt@@3HB
 ; CHECK: int const g_cInt
 
 ?g_vInt@@3HC
 ; CHECK: int volatile g_vInt