[MS Demangler] Demangle pointers to member functions

[zturner]

Summary

After this we should have full coverage of mangle-ms.cpp, minus clang extensions like blocks.

[zturner]

I had forgotten to re-enable all of the member pointer tests. When I did re-enable them, a few were still broken, so I fixed them up. All member pointer tests now pass.

In doing so, we now differ from undname with regards to function return values. If you have this code:

typedef int (*fun)();
fun (B::* volatile memptrtofun7)();

This will be mangled as ?memptrtofun7@@3R8B@@EAAP6AHXZXZEQ1@. undname will undecorate this as int (__cdecl*(__cdecl B::* __ptr64 memptrtofun7)(void) __ptr64)(void). I find the multiple levels of nesting pretty difficult to read here, and I find it makes more sense when the return value is entirely on the left. So I've implemented that change here, and now we will print int __cdecl (*)(void) __cdecl (B::*volatile memptrtofun7)(void) which is much more similar to how the code actually looks.

Also, I was wrong in my original commit message. We're still not at 100% - clang extensions. This patch still has some failing tests regarding extern c functions and static locals. I'll consider those low priority though and work on getting major functionality working first.

[ruiu]

Even though int __cdecl (*)(void) __cdecl (B::*volatile memptrtofun7)(void) is easier to read, it is not a valid piece of code, no? It is unfortunate that the C type declaration is so hard to read, but I believe people expect that demangler emits function declaration not in some "improved" form but in the regular C grammar.

[rnk]

In D49639#1171901, @ruiu wrote:

Even though int __cdecl (*)(void) __cdecl (B::*volatile memptrtofun7)(void) is easier to read, it is not a valid piece of code, no? It is unfortunate that the C type declaration is so hard to read, but I believe people expect that demangler emits function declaration not in some "improved" form but in the regular C grammar.

+1

[zturner]

In D49639#1171949, @rnk wrote:

In D49639#1171901, @ruiu wrote:

Even though int __cdecl (*)(void) __cdecl (B::*volatile memptrtofun7)(void) is easier to read, it is not a valid piece of code, no? It is unfortunate that the C type declaration is so hard to read, but I believe people expect that demangler emits function declaration not in some "improved" form but in the regular C grammar.

+1

I guess another option would be to print something like:

T1 (__cdecl B::*volatile memptrtofun7)(void)
with
[
    T1 = int (__cdecl *)(void);
]

but that would be a little strange as a default since, as you said, usually people just want 1 declaration. But perhaps it would be an interesting thing to put behind a command line option in case you want a readable declaration rather than a pedantically legal declaration. It could make some types of symbols significantly easier to read, especially when the same parameter is repeated multiple times. (which should be easy to identify from the mangling).

[zturner]

(And for now, I'll just change it to print the one-line declaration that is legal according to the grammar, and leave any command-line options and/or extended output mode for the future.)

[rnk]

llvm/lib/Demangle/MicrosoftDemangle.cpp

1295 ↗

(On Diff #156694)

Don't need this cast anymore

llvm/test/Demangle/ms-mangle.test

102 ↗

(On Diff #156694)

Is there a way to get the calling convention inside the parentheses? Undname produces names like:
Undecoration of :- "?memptrtofun5@@3P8B@@EAA?CHXZEQ1@"
is :- "int volatile (cdecl B::* ptr64 memptrtofun5)(void) __ptr64"

I believe that's where you have to write the calling convention if you want it to parse.

If it's too difficult to do in this patch, that's fine.

[zturner]

llvm/test/Demangle/ms-mangle.test

102 ↗

(On Diff #156694)

I have this working in a followup patch, but it pollutes this patch a bit too much IMO, so after I get this and the others in, I'll submit that in a followup. That said, I still need to update this patch to print the grammatically legal form of a member function pointer, so I'll update this patch soon with that piece, and do the calling convention part later.

[zturner]

Mangled Name: ?memptrtofun7@@3R8B@@EAAP6AHXZXZEQ1@
Previous Undecoration: int __cdecl (*)(void) __cdecl (B::*volatile memptrtofun7)(void)
New Undecoration: int __cdecl (* __cdecl (B::*volatile memptrtofun7)(void))(void)

Note that the calling convention is in the wrong place, but as mentioned in the comments, I will address this in a followup. I already have the patch that does it, but it requires some more functional changes that I think should be separate since it also affects non-member function pointers, and this patch is specifically about member function pointers.

[rnk]

lgtm

llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp

 
 namespace {
 
 struct Type;
 
 // Represents a list of parameters (template params or function arguments.
 // It's represented as a linked list.
 struct ParamList {
+  bool IsVariadic = false;
+
   Type *Current = nullptr;
 
   ParamList *Next = nullptr;
 };
 
 // The type class. Mangled symbols are first parsed and converted to
 // this type and then converted to string.
 struct Type {
case CallingConv::Clrcall:
     break;
   default:
     break;
   }
 }
 
 // Write a function or template parameter list.
 static void outputParameterList(OutputStream &OS, const ParamList &Params) {
+  if (!Params.Current) {
+    OS << "void";
+    return;
+  }
+
   const ParamList *Head = &Params;
   while (Head) {
     Type::outputPre(OS, *Head->Current);
     Type::outputPost(OS, *Head->Current);
 
     Head = Head->Next;
 
     if (Head)

 }
 
 void FunctionType::outputPre(OutputStream &OS) {
   if (!(FunctionClass & Global)) {
     if (FunctionClass & Static)
       OS << "static ";
   }
 
-  if (ReturnType)
+  if (ReturnType) {
     Type::outputPre(OS, *ReturnType);
+    OS << " ";
+  }
 
   outputCallingConvention(OS, CallConvention);
 }
 
 void FunctionType::outputPost(OutputStream &OS) {
   OS << "(";
   outputParameterList(OS, Params);
   OS << ")";
   if (Quals & Q_Const)
     OS << " const";
   if (Quals & Q_Volatile)
     OS << " volatile";
+
+  if (ReturnType)
+    Type::outputPost(OS, *ReturnType);
   return;
 }
 
 Type *UdtType::clone(ArenaAllocator &Arena) const {
   return Arena.alloc<UdtType>(*this);
 }
 
 void UdtType::outputPre(OutputStream &OS) {
private:
   Qualifiers demanglePointerExtQualifiers();
 
   // Parser functions. This is a recursive-descent parser.
   Type *demangleType(QualifierMangleMode QMM);
   Type *demangleBasicType();
   UdtType *demangleClassType();
   PointerType *demanglePointerType();
   MemberPointerType *demangleMemberPointerType();
+  FunctionType *demangleFunctionType(bool HasThisQuals);
 
   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();
+  FuncClass demangleFunctionClass();
   CallingConv demangleCallingConvention();
   StorageClass demangleVariableStorageClass();
   ReferenceKind demangleReferenceKind();
+  void demangleThrowSpecification();
 
   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.
if (I >= BackRefCount) {
       return;
     }
     MangledName = MangledName.dropFront();
     Node.Str = BackReferences[I];
   } else if (MangledName.consumeFront("?$")) {
     // Class template.
     Node.Str = demangleString(false);
     Node.TemplateParams = demangleParameterList();
-    if (!MangledName.consumeFront('@')) {
-      Error = true;
-      return;
-    }
   } else if (!IsHead && MangledName.consumeFront("?A")) {
     // Anonymous namespace starts with ?A.  So does overloaded operator[],
     // but the distinguishing factor is that namespace themselves are not
     // mangled, only the variables and functions inside of them are.  So
     // an anonymous namespace will never occur as the first item in the
     // name.
     Node.Str = "`anonymous namespace'";
     if (!MangledName.consumeFront('@')) {
StringView Demangler::demangleOperatorName() {
   }
   }
 
   Error = true;
   RestoreOnError.shouldRestore(true);
   return "";
 }
 
-int Demangler::demangleFunctionClass() {
+FuncClass Demangler::demangleFunctionClass() {
   SwapAndRestore<StringView> RestoreOnError(MangledName, MangledName);
   RestoreOnError.shouldRestore(false);
 
   switch (MangledName.popFront()) {
   case 'A':
     return Private;
   case 'B':
-    return Private | Far;
+    return FuncClass(Private | Far);
   case 'C':
-    return Private | Static;
+    return FuncClass(Private | Static);
   case 'D':
-    return Private | Static;
+    return FuncClass(Private | Static);
   case 'E':
-    return Private | Virtual;
+    return FuncClass(Private | Virtual);
   case 'F':
-    return Private | Virtual;
+    return FuncClass(Private | Virtual);
   case 'I':
     return Protected;
   case 'J':
-    return Protected | Far;
+    return FuncClass(Protected | Far);
   case 'K':
-    return Protected | Static;
+    return FuncClass(Protected | Static);
   case 'L':
-    return Protected | Static | Far;
+    return FuncClass(Protected | Static | Far);
   case 'M':
-    return Protected | Virtual;
+    return FuncClass(Protected | Virtual);
   case 'N':
-    return Protected | Virtual | Far;
+    return FuncClass(Protected | Virtual | Far);
   case 'Q':
     return Public;
   case 'R':
-    return Public | Far;
+    return FuncClass(Public | Far);
   case 'S':
-    return Public | Static;
+    return FuncClass(Public | Static);
   case 'T':
-    return Public | Static | Far;
+    return FuncClass(Public | Static | Far);
   case 'U':
-    return Public | Virtual;
+    return FuncClass(Public | Virtual);
   case 'V':
-    return Public | Virtual | Far;
+    return FuncClass(Public | Virtual | Far);
   case 'Y':
     return Global;
   case 'Z':
-    return Global | Far;
+    return FuncClass(Global | Far);
   }
 
   Error = true;
   RestoreOnError.shouldRestore(true);
-  return 0;
+  return Public;
 }
 
 CallingConv Demangler::demangleCallingConvention() {
   switch (MangledName.popFront()) {
   case 'A':
   case 'B':
     return CallingConv::Cdecl;
   case 'C':
Type *Demangler::demangleType(QualifierMangleMode QMM) {
   default:
     Ty = demangleBasicType();
     break;
   }
   Ty->Quals = Qualifiers(Ty->Quals | Quals);
   return Ty;
 }
 
-static bool functionHasThisPtr(const FunctionType &Ty) {
-  assert(Ty.Prim == PrimTy::Function);
-  if (Ty.FunctionClass & Global)
-    return false;
-  if (Ty.FunctionClass & Static)
-    return false;
-  return true;
-}
-
 ReferenceKind Demangler::demangleReferenceKind() {
   if (MangledName.consumeFront('G'))
     return ReferenceKind::LValueRef;
   else if (MangledName.consumeFront('H'))
     return ReferenceKind::RValueRef;
   return ReferenceKind::None;
 }
 
-Type *Demangler::demangleFunctionEncoding() {
-  FunctionType *FTy = Arena.alloc<FunctionType>();
+void Demangler::demangleThrowSpecification() {
+  if (MangledName.consumeFront('Z'))
+    return;
 
+  Error = true;
+}
+
+FunctionType *Demangler::demangleFunctionType(bool HasThisQuals) {
+  FunctionType *FTy = Arena.alloc<FunctionType>();
   FTy->Prim = PrimTy::Function;
-  FTy->FunctionClass = (FuncClass)demangleFunctionClass();
-  if (functionHasThisPtr(*FTy)) {
+
+  if (HasThisQuals) {
     FTy->Quals = demanglePointerExtQualifiers();
     FTy->RefKind = demangleReferenceKind();
     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('@');
   if (!IsStructor)
     FTy->ReturnType = demangleType(QualifierMangleMode::Result);
 
   FTy->Params = demangleParameterList();
 
+  demangleThrowSpecification();
+
+  return FTy;
+}
+
+Type *Demangler::demangleFunctionEncoding() {
+  FuncClass FC = demangleFunctionClass();
+
+  bool HasThisQuals = !(FC & (Global | Static));
+  FunctionType *FTy = demangleFunctionType(HasThisQuals);
+  FTy->FunctionClass = FC;
+
   return FTy;
 }
 
 // Reads a primitive type.
 Type *Demangler::demangleBasicType() {
   Type *Ty = Arena.alloc<Type>();
 
   switch (MangledName.popFront()) {
MemberPointerType *Demangler::demangleMemberPointerType() {
 
   PointerAffinity Affinity;
   std::tie(Pointer->Quals, Affinity) = demanglePointerCVQualifiers(MangledName);
   assert(Affinity == PointerAffinity::Pointer);
 
   Qualifiers ExtQuals = demanglePointerExtQualifiers();
   Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
 
+  if (MangledName.consumeFront("8")) {
+    Pointer->MemberName = demangleName();
+    Pointer->Pointee = demangleFunctionType(true);
+  } else {
     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'))

 }
 
 // Reads a function or a template parameters.
 ParamList Demangler::demangleParameterList() {
   // Within the same parameter list, you can backreference the first 10 types.
   Type *BackRef[10];
   int Idx = 0;
 
+  // Empty parameter list.
+  // FIXME: Will this cause problems if demangleParameterList() is called in the
+  // context of a template parameter list?
+  if (MangledName.consumeFront('X'))
+    return {};
+
   ParamList *Head;
   ParamList **Current = &Head;
   while (!Error && !MangledName.startsWith('@') &&
          !MangledName.startsWith('Z')) {
     if (startsWithDigit(MangledName)) {
       int N = MangledName[0] - '0';
       if (N >= Idx) {
         Error = true;
while (!Error && !MangledName.startsWith('@') &&
 
     // Single-letter types are ignored for backreferences because
     // memorizing them doesn't save anything.
     if (Idx <= 9 && ArrayDimension - MangledName.size() > 1)
       BackRef[Idx++] = (*Current)->Current;
     Current = &(*Current)->Next;
   }
 
+  if (Error)
+    return {};
+
+  // A non-empty parameter list is terminated by either 'Z' (variadic) parameter
+  // list or '@' (non variadic).  Careful not to consume "@Z", as in that case
+  // the following Z could be a throw specifier.
+  if (MangledName.consumeFront('@'))
     return *Head;
+
+  if (MangledName.consumeFront('Z')) {
+    Head->IsVariadic = true;
+    return *Head;
+  }
+
+  Error = true;
+  return {};
 }
 
 void Demangler::output() {
   // Converts an AST to a string.
   //
   // Converting an AST representing a C++ type to a string is tricky due
   // to the bad grammar of the C++ declaration inherited from C. You have
   // to construct a string from inside to outside. For example, if a type

llvm/trunk/lib/Demangle/StringView.h

if (To >= size())
       To = size() - 1;
     if (From >= size())
       From = size() - 1;
     return StringView(First + From, First + To);
   }
 
   StringView dropFront(size_t N = 1) const {
     if (N >= size())
-      N = size() - 1;
+      N = size();
     return StringView(First + N, Last);
   }
 
   char front() const {
     assert(!empty());
     return *begin();
   }
 

llvm/trunk/test/Demangle/ms-basic.test

 ?x@ns@@3PEAV?$klass@HH@1@EA
 ; CHECK: class ns::klass<int, int> *ns::x
 
 ?fn@?$klass@H@ns@@QEBAIXZ
 ; CHECK: unsigned int __cdecl ns::klass<int>::fn(void) const
 
 
 ??4klass@@QEAAAEBV0@AEBV0@@Z
-; CHECK: class klass const &__cdecl klass::operator=(class klass const &)
+; CHECK: class klass const & __cdecl klass::operator=(class klass const &)
 
 ??7klass@@QEAA_NXZ
 ; CHECK: bool __cdecl klass::operator!(void)
 
 ??8klass@@QEAA_NAEBV0@@Z
 ; CHECK: bool __cdecl klass::operator==(class klass const &)
 
 ??9klass@@QEAA_NAEBV0@@Z

 
 ??_3klass@@QEAAHH@Z
 ; CHECK: int __cdecl klass::operator<<=(int)
 
 ??_6klass@@QEAAHH@Z
 ; CHECK: int __cdecl klass::operator^=(int)
 
 ??6@YAAEBVklass@@AEBV0@H@Z
-; CHECK: class klass const &__cdecl operator<<(class klass const &, int)
+; CHECK: class klass const & __cdecl operator<<(class klass const &, int)
 
 ??5@YAAEBVklass@@AEBV0@_K@Z
-; CHECK: class klass const &__cdecl operator>>(class klass const &, unsigned __int64)
+; CHECK: class klass const & __cdecl operator>>(class klass const &, unsigned __int64)
 
 ??2@YAPEAX_KAEAVklass@@@Z
-; CHECK: void *__cdecl operator new(unsigned __int64, class klass &)
+; CHECK: void * __cdecl operator new(unsigned __int64, class klass &)
 
 ??_U@YAPEAX_KAEAVklass@@@Z
-; CHECK: void *__cdecl operator new[](unsigned __int64, class klass &)
+; CHECK: void * __cdecl operator new[](unsigned __int64, class klass &)
 
 ??3@YAXPEAXAEAVklass@@@Z
 ; CHECK: void __cdecl operator delete(void *, class klass &)
 
 ??_V@YAXPEAXAEAVklass@@@Z
 ; CHECK: void __cdecl operator delete[](void *, class klass &)
 

llvm/trunk/test/Demangle/ms-mangle.test

 
 ??Hfoo@@QAEHH@Z
 ; CHECK: int __thiscall foo::operator+(int)
 
 ??Hfoo@@QEAAHH@Z
 ; CHECK: int __cdecl foo::operator+(int)
 
 ?static_method@foo@@SAPAV1@XZ
-; CHECK: static class foo *__cdecl foo::static_method(void)
+; CHECK: static class foo * __cdecl foo::static_method(void)
 
 ?static_method@foo@@SAPEAV1@XZ
-; CHECK: static class foo *__cdecl foo::static_method(void)
+; CHECK: static class foo * __cdecl foo::static_method(void)
 
 ?g@bar@@2HA
 ; CHECK: static int bar::g
 
 ; undname returns `int *h1`, but it is a bug in their demangler.  Their mangler
 ; correctly mangles `int *h1` as ?h1@3PAHA and `int * const h1` as ?h1@3QAHA
 ?h1@@3QAHA
 ; CHECK: int *const h1

 ; 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)
 
+?funptr@@YAP6AHXZXZ
+; CHECK: int __cdecl (* __cdecl funptr(void))(void)
+
 ?k@@3PTfoo@@DT1@
 ; CHECK: char const volatile foo::*k
 
 ?k@@3PETfoo@@DET1@
 ; CHECK: char const volatile foo::*k
 
-; FIXME: We don't support member function pointers yet.
-; ?l@@3P8foo@@AEHH@ZQ1@
-; FIXME: int __thiscall (foo::*l)(int)
+?l@@3P8foo@@AEHH@ZQ1@
+; CHECK: int __thiscall (foo::*l)(int)
 
 ?g_cInt@@3HB
 ; CHECK: int const g_cInt
 
 ?g_vInt@@3HC
 ; CHECK: int volatile g_vInt
 
 ?g_cvInt@@3HD

 
 ?zeta@@YAXP6AHHH@Z@Z
 ; CHECK: void __cdecl zeta(int __cdecl (*)(int, int))
 
 ?zeta@@YAXP6AHHH@Z@Z
 ; CHECK: void __cdecl zeta(int __cdecl (*)(int, int))
 
 ??2@YAPAXI@Z
-; CHECK: void *__cdecl operator new(unsigned int)
+; CHECK: void * __cdecl operator new(unsigned int)
 
 ??3@YAXPAX@Z
 ; CHECK: void __cdecl operator delete(void *)
 
 ??_U@YAPAXI@Z
-; CHECK: void *__cdecl operator new[](unsigned int)
+; CHECK: void * __cdecl operator new[](unsigned int)
 
 ??_V@YAXPAX@Z
 ; CHECK: void __cdecl operator delete[](void *)
 
 ?color1@@3PANA
 ; CHECK: double *color1
 
 ?color2@@3QBNB
 ; CHECK: double const *const color2
 
 ; FIXME-EXTRACONST: These tests fails because we print an extra const inside the parens.
 ; ?color3@@3QAY02$$CBNA
 ; FIXME-EXTRACONST: double const (*color3)[3]
 
 ; ?color4@@3QAY02$$CBNA
 ; FIXME-EXTRACONST: double const (*color4)[3]
 
-; FIXME-MEMBERPTR: We don't support member pointers yet.
-; ?memptr1@@3RESB@@HES1
-; FIXME-MEMBERPTR: volatile int B::*memptr2
+?memptr1@@3RESB@@HES1@
+; CHECK: int volatile B::*volatile memptr1
 
-; ?memptr2@@3PESB@@HES1
-; FIXME: volatile int B::*memptr2
+?memptr2@@3PESB@@HES1@
+; CHECK: int volatile B::*memptr2
 
-; ?memptr3@@3REQB@@HEQ1
-; FIXME-MEMBERPTR: int B::* volatile memptr3
+?memptr3@@3REQB@@HEQ1@
+; CHECK: int B::*volatile memptr3
 
-; ?funmemptr1@@3RESB@@R6AHXZES1
-; FIXME-MEMBERPTR: int __cdecl (* volatile B::* volatile funmemptr1)(void)
+?funmemptr1@@3RESB@@R6AHXZES1@
+; CHECK: int __cdecl (*volatile B::*volatile funmemptr1)(void)
 
-; ?funmemptr2@@3PESB@@R6AHXZES1
-; FIXME-MEMBERPTR: int __cdecl (* volatile B::*funmemptr2)(void)
+?funmemptr2@@3PESB@@R6AHXZES1@
+; CHECK: int __cdecl (*volatile B::*funmemptr2)(void)
 
-; ?funmemptr3@@3REQB@@P6AHXZEQ1
-; FIXME-MEMBERPTR: int __cdecl (* B::*volatile funmemptr3)(void)
+?funmemptr3@@3REQB@@P6AHXZEQ1@
+; CHECK: int __cdecl (*B::*volatile funmemptr3)(void)
 
-; ?memptrtofun1@@3R8B@@EAAXXZEQ1
-; FIXME-MEMBERPTR: void __cdecl (B::*volatile memptrtofun1)(void)
+?memptrtofun1@@3R8B@@EAAXXZEQ1@
+; CHECK: void __cdecl (B::*volatile memptrtofun1)(void)
 
-; ?memptrtofun2@@3P8B@@EAAXXZEQ1
-; FIXME-MEMBERPTR: void __cdecl (B::*memptrtofun2)(void)
+?memptrtofun2@@3P8B@@EAAXXZEQ1@
+; CHECK: void __cdecl (B::*memptrtofun2)(void)
 
-; ?memptrtofun3@@3P8B@@EAAXXZEQ1
-; FIXME-MEMBERPTR: void __cdecl (B::*memptrtofun3)(void)
+?memptrtofun3@@3P8B@@EAAXXZEQ1@
+; CHECK: void __cdecl (B::*memptrtofun3)(void)
 
-; ?memptrtofun4@@3R8B@@EAAHXZEQ1
-; FIXME-MEMBERPTR: int __cdecl (B::* volatile memptrtofun4)(void)
+?memptrtofun4@@3R8B@@EAAHXZEQ1@
+; CHECK: int __cdecl (B::*volatile memptrtofun4)(void)
 
-; ?memptrtofun5@@3P8B@@EAA?CHXZEQ1
-; FIXME-MEMBERPTR: int volatile __cdecl (B::*memptrtofun5)(void)
+?memptrtofun5@@3P8B@@EAA?CHXZEQ1@
+; CHECK: int volatile __cdecl (B::*memptrtofun5)(void)
 
-; ?memptrtofun6@@3P8B@@EAA?BHXZEQ1
-; FIXME-MEMBERPTR: int const __cdecl (B::*memptrtofun6)(void)
+?memptrtofun6@@3P8B@@EAA?BHXZEQ1@
+; CHECK: int const __cdecl (B::*memptrtofun6)(void)
 
-; ?memptrtofun7@@3R8B@@EAAP6AHXZXZEQ1
-; FIXME-MEMBERPTR: int __cdecl (*(__cdecl B::*volatile memptrtofun7)(void))(void)
+?memptrtofun7@@3R8B@@EAAP6AHXZXZEQ1@
+; CHECK: int __cdecl (* __cdecl (B::*volatile memptrtofun7)(void))(void)
 
-; ?memptrtofun8@@3P8B@@EAAR6AHXZXZEQ1
-; FIXME-MEMBERPTR: int __cdecl (*(__cdecl B::*memptrtofun8)(void))(void)
+?memptrtofun8@@3P8B@@EAAR6AHXZXZEQ1@
+; CHECK: int __cdecl (*volatile __cdecl (B::*memptrtofun8)(void))(void)
 
-; ?memptrtofun9@@3P8B@@EAAQ6AHXZXZEQ1
-; FIXME-MEMBERPTR: int __cdecl(*(__cdecl B::*memptrtofun9)(void))(void)
+?memptrtofun9@@3P8B@@EAAQ6AHXZXZEQ1@
+; CHECK: int __cdecl (*const __cdecl (B::*memptrtofun9)(void))(void)
 
 
 ?fooE@@YA?AW4E@@XZ
 ; CHECK: enum E __cdecl fooE(void)
 
 ?fooE@@YA?AW4E@@XZ
 ; CHECK: enum E __cdecl fooE(void)
 

 ; FIXME-EXTERNC: We don't properly support static locals in extern c functions yet.
 ; ?local@?1??extern_c_func@@9@4HA
 ; FIXME-EXTERNC: int `extern_c_func'::`2'::local
 
 ; ?local@?1??extern_c_func@@9@4HA
 ; FIXME-EXTERNC: int `extern_c_func'::`2'::local
 
 ??2OverloadedNewDelete@@SAPAXI@Z
-; CHECK: static void *__cdecl OverloadedNewDelete::operator new(unsigned int)
+; CHECK: static void * __cdecl OverloadedNewDelete::operator new(unsigned int)
 
 
 ??_UOverloadedNewDelete@@SAPAXI@Z
-; CHECK: static void *__cdecl OverloadedNewDelete::operator new[](unsigned int)
+; CHECK: static void * __cdecl OverloadedNewDelete::operator new[](unsigned int)
 
 ??3OverloadedNewDelete@@SAXPAX@Z
 ; CHECK: static void __cdecl OverloadedNewDelete::operator delete(void *)
 
 
 ??_VOverloadedNewDelete@@SAXPAX@Z
 ; CHECK: static void __cdecl OverloadedNewDelete::operator delete[](void *)
 
 ??HOverloadedNewDelete@@QAEHH@Z
 ; CHECK: int __thiscall OverloadedNewDelete::operator+(int)
 
 ??2OverloadedNewDelete@@SAPEAX_K@Z
-; CHECK: static void *__cdecl OverloadedNewDelete::operator new(unsigned __int64)
+; CHECK: static void * __cdecl OverloadedNewDelete::operator new(unsigned __int64)
 
 ??_UOverloadedNewDelete@@SAPEAX_K@Z
-; CHECK: static void *__cdecl OverloadedNewDelete::operator new[](unsigned __int64)
+; CHECK: static void * __cdecl OverloadedNewDelete::operator new[](unsigned __int64)
 
 ??3OverloadedNewDelete@@SAXPEAX@Z
 ; CHECK: static void __cdecl OverloadedNewDelete::operator delete(void *)
 
 
 ??_VOverloadedNewDelete@@SAXPEAX@Z
 ; CHECK: static void __cdecl OverloadedNewDelete::operator delete[](void *)
 
 ??HOverloadedNewDelete@@QEAAHH@Z
 ; CHECK: int __cdecl OverloadedNewDelete::operator+(int)
 
 
 ??2TypedefNewDelete@@SAPAXI@Z
-; CHECK: static void *__cdecl TypedefNewDelete::operator new(unsigned int)
+; CHECK: static void * __cdecl TypedefNewDelete::operator new(unsigned int)
 
 
 ??_UTypedefNewDelete@@SAPAXI@Z
-; CHECK: static void *__cdecl TypedefNewDelete::operator new[](unsigned int)
+; CHECK: static void * __cdecl TypedefNewDelete::operator new[](unsigned int)
 
 ??3TypedefNewDelete@@SAXPAX@Z
 ; CHECK: static void __cdecl TypedefNewDelete::operator delete(void *)
 
 ??_VTypedefNewDelete@@SAXPAX@Z
 ; CHECK: static void __cdecl TypedefNewDelete::operator delete[](void *)
 
 ?vector_func@@YQXXZ