[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

254

s/True/Non-null/

594

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

303

no break after return

308

don't

319

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

594

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 PointerAffinity { Pointer, Reference };
 
 // Calling conventions
 enum class CallingConv : uint8_t {
   None,
   Cdecl,
   Pascal,
   Thiscall,
   Stdcall,
   Fastcall,
   Clrcall,
   Eabi,
   Vectorcall,
   Regcall,
 };
 
 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
 
 // Types
 enum class PrimTy : uint8_t {
   Unknown,
   None,
   Function,
   Ptr,
   Ref,
+  MemberPtr,
   Array,
 
   Struct,
   Union,
   Class,
   Enum,
 
   Void,
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; }
+  // 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;
+
+  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;
struct ArrayType : public Type {
   ArrayType *NextDimension = nullptr;
   uint32_t ArrayDimension = 0;
 
   Type *ElementType = nullptr;
 };
 
 } // namespace
 
+static bool isMemberPointer(StringView MangledName) {
+  switch (MangledName.popFront()) {
+  case 'A':
+    // 'A' indicates a reference, and you cannot have a reference to a member
+    // function or member variable.
+    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!");
+  }
+
+  // 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[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
+
+  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) {
   outputSpaceIfNecessary(OS);
 
   switch (CC) {
   case CallingConv::Cdecl:
     OS << "__cdecl";
     break;
   case CallingConv::Fastcall:

 
 void PointerType::outputPost(OutputStream &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);
+}
+
+void MemberPointerType::outputPre(OutputStream &OS) {
+  Type::outputPre(OS, *Pointee);
+
+  outputSpaceIfNecessary(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 << "(";
+
+  outputName(OS, MemberName);
+  OS << "::*";
+
+  // FIXME: We should output this, but it requires updating lots of tests.
+  // if (Ty.Quals & Q_Pointer64)
+  //  OS << " __ptr64";
+  if (Quals & Q_Restrict)
+    OS << " __restrict";
+}
+
+void MemberPointerType::outputPost(OutputStream &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);
 }
 
 void FunctionType::outputPre(OutputStream &OS) {
   if (!(FunctionClass & Global)) {
     if (FunctionClass & Static)
       OS << "static ";
private:
 
   Qualifiers demanglePointerExtQualifiers();
 
   // Parser functions. This is a recursive-descent parser.
   Type *demangleType(QualifierMangleMode QMM);
   Type *demangleBasicType();
   UdtType *demangleClassType();
   PointerType *demanglePointerType();
+  MemberPointerType *demangleMemberPointerType();
 
   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 *Ty = demangleType(QualifierMangleMode::Drop);
 
   Ty->Storage = SC;
 
   // <variable-type> ::= <type> <cvr-qualifiers>
   //                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
   switch (Ty->Prim) {
   case PrimTy::Ptr:
-  case PrimTy::Ref: {
+  case PrimTy::Ref:
+  case PrimTy::MemberPtr: {
     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 = false;
+    std::tie(ExtraChildQuals, IsMember) = demangleQualifiers();
 
-    if (PTy->isMemberPointer()) {
+    if (Ty->Prim == PrimTy::MemberPtr) {
+      assert(IsMember);
       Name *BackRefName = demangleName();
       (void)BackRefName;
+      MemberPointerType *MPTy = static_cast<MemberPointerType *>(Ty);
+      MPTy->Pointee->Quals = Qualifiers(MPTy->Pointee->Quals | ExtraChildQuals);
+    } else {
+      PointerType *PTy = static_cast<PointerType *>(Ty);
+      PTy->Pointee->Quals = Qualifiers(PTy->Pointee->Quals | ExtraChildQuals);
     }
 
-    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);
-
-  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);
+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);
-  }
-
-  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());
+  bool IsMember = false;
+  bool IsMemberKnown = false;
+  if (QMM == QualifierMangleMode::Mangle) {
+    std::tie(Quals, IsMember) = demangleQualifiers();
+    IsMemberKnown = true;
+  } else if (QMM == QualifierMangleMode::Result) {
+    if (MangledName.consumeFront('?')) {
+      std::tie(Quals, IsMember) = demangleQualifiers();
+      IsMemberKnown = true;
+    }
   }
 
   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
+    if (!IsMemberKnown)
+      IsMember = isMemberPointer(MangledName);
+    if (IsMember)
+      Ty = demangleMemberPointerType();
+    else
       Ty = demanglePointerType();
     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;
 }
 
-// <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type>
-//                       # the E is required for 64-bit non-static pointers
-PointerType *Demangler::demanglePointerType() {
-  PointerType *Pointer = Arena.alloc<PointerType>();
-
-  Pointer->Quals = Q_None;
+static std::pair<Qualifiers, PointerAffinity>
+demanglePointerCVQualifiers(StringView &MangledName) {
   switch (MangledName.popFront()) {
   case 'A':
-    Pointer->Prim = PrimTy::Ref;
-    break;
+    return std::make_pair(Q_None, PointerAffinity::Reference);
   case 'P':
-    Pointer->Prim = PrimTy::Ptr;
-    break;
+    return std::make_pair(Q_None, PointerAffinity::Pointer);
   case 'Q':
-    Pointer->Prim = PrimTy::Ptr;
-    Pointer->Quals = Q_Const;
-    break;
+    return std::make_pair(Q_Const, PointerAffinity::Pointer);
   case 'R':
-    Pointer->Quals = Q_Volatile;
-    Pointer->Prim = PrimTy::Ptr;
-    break;
+    return std::make_pair(Q_Volatile, PointerAffinity::Pointer);
   case 'S':
-    Pointer->Quals = Qualifiers(Q_Const | Q_Volatile);
-    Pointer->Prim = PrimTy::Ptr;
-    break;
+    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() {
+  PointerType *Pointer = Arena.alloc<PointerType>();
+
+  PointerAffinity Affinity;
+  std::tie(Pointer->Quals, Affinity) = demanglePointerCVQualifiers(MangledName);
+
+  Pointer->Prim =
+      (Affinity == PointerAffinity::Pointer) ? PrimTy::Ptr : PrimTy::Ref;
   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;
 }
 
+MemberPointerType *Demangler::demangleMemberPointerType() {
+  MemberPointerType *Pointer = Arena.alloc<MemberPointerType>();
+  Pointer->Prim = PrimTy::MemberPtr;
+
+  PointerAffinity Affinity;
+  std::tie(Pointer->Quals, Affinity) = demanglePointerCVQualifiers(MangledName);
+  assert(Affinity == PointerAffinity::Pointer);
+
+  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;
+  return Pointer;
+}
+
 Qualifiers Demangler::demanglePointerExtQualifiers() {
   Qualifiers Quals = Q_None;
   if (MangledName.consumeFront('E'))
     Quals = Qualifiers(Quals | Q_Pointer64);
   if (MangledName.consumeFront('I'))
     Quals = Qualifiers(Quals | Q_Restrict);
   if (MangledName.consumeFront('F'))
     Quals = Qualifiers(Quals | Q_Unaligned);

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