[Demangle] Add a few more options to the microsoft demangler

[mstorsjo]

Summary

This corresponds to commonly used options to UnDecorateSymbolName within llvm.

Add them as hidden options in llvm-undname. MS undname.exe takes numeric flags, corresponding to the UNDNAME_* constants, but instead of hardcoding in mappings for those numbers, just add textual options instead, as it the use of them here is primarily intended for testing.

This should allow replacing UnDecorateSymbolName from dbghelp with the llvm demangler mostly without changing the output.

[rnk]

llvm/include/llvm/Demangle/Demangle.h

39

Any reason not to say MSDF_NoCallingConvention instead? I see it's consistent with the UnDecorateSymbolName flag, but "allocation language" is pretty opaque. It's not like we're being compatible with undname here, we might as well use descriptive command line flag names.

40

"Function returns" could be "return types", but I don't feel as strongly about it.

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

602

Code golf suggestion:

StringRef AccessSpec;
bool IsStatic = true;
switch (SC) {
  case StorageClass::PrivateStatic:
    AccessSpec = "private";
    break;
  case StorageClass::ProtectedStatic:
    AccessSpec = "protected";
    break;
  case StorageClass::PublicStatic:
    AccessSpec = "public";
    break;
  default:
    IsStatic = false;
    break;
}
if (!(Flags & OF_NoAccessSpecifier) && !AccessSpec.empty())
  OS << AccessSpec << ": ";
if (!(Flags & OF_NoNoMemberType) && IsStatic)
  OS << "static";

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

37

Ditto, we should consider a more descriptive name.

[mstorsjo]

llvm/include/llvm/Demangle/Demangle.h

39

Sounds good, I'd change both this and the llvm-undname flag then.

40

If deviating from the undname naming, we can just as well make all of them more straightforward, so I'd change this one as well then.

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

602

Neat! StringRef isn't really allowed here, but using const char * isn't any more cumbersome here.

[mstorsjo]

Applied Reid's suggestions

[rnk]

lgtm

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

602

Right. Wow, I guess the demangler has it's whole own set of operator<< overloads. >_>

[thakis]

This is cool, thanks!

Note that there are a 3 or so places where the demangler also hardcodes OF_Default. One patch that I have sitting around locally fixes one of them (https://gist.github.com/nico/8f219c64c9269c1f8c6657c46f3e8644 -- feel free to take that one over; I wrote it for something else that I couldn't yet prove is actually a problem; from the test script at the bottom you can probably figure out what it was :)). As-is, these options are ignored for these cases (cached types in templates, parent scopes of locally numbered scopes, and something else). It's possible that these contexts are unaffected by these options, but I figured I'd mention it, in case you want to check.

[mstorsjo]

In D68917#1713451, @thakis wrote:

This is cool, thanks!

Note that there are a 3 or so places where the demangler also hardcodes OF_Default. One patch that I have sitting around locally fixes one of them (https://gist.github.com/nico/8f219c64c9269c1f8c6657c46f3e8644 -- feel free to take that one over; I wrote it for something else that I couldn't yet prove is actually a problem; from the test script at the bottom you can probably figure out what it was :)). As-is, these options are ignored for these cases (cached types in templates, parent scopes of locally numbered scopes, and something else). It's possible that these contexts are unaffected by these options, but I figured I'd mention it, in case you want to check.

Oh, ok. TBH, unless there's a clear issue I'm running into, I don't think I'll be looking more into it right now. My original quest was to sift through lldb and enable as much as makes sense of #ifdef _MSC_VER blocks on mingw, and that's more or less comple now. :-) For the use of dbghelp for demangling I thought it'd be trivial to just convert to the internal demangler - instead of using more elaborate mechanisms than #pragma comment(lib) for linking to dbghelp. It turned out to be a bit bigger task than I had expected originally, but not too bad.

llvm/include/llvm/Demangle/Demangle.h

enum : int {
   demangle_memory_alloc_failure = -1,
   demangle_success = 0,
 };
 
 char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
                       int *status);
 
 
-enum MSDemangleFlags { MSDF_None = 0, MSDF_DumpBackrefs = 1 << 0 };
+enum MSDemangleFlags {
+  MSDF_None = 0,
+  MSDF_DumpBackrefs = 1 << 0,
+  MSDF_NoAccessSpecifier = 1 << 1,
+  MSDF_NoCallingConvention = 1 << 2,
+  MSDF_NoReturnType = 1 << 3,
+  MSDF_NoMemberType = 1 << 4,
+};
 char *microsoftDemangle(const char *mangled_name, char *buf, size_t *n,
                         int *status, MSDemangleFlags Flags = MSDF_None);
 
 /// Attempt to demangle a string using different demangling schemes.
 /// The function uses heuristics to determine which demangling scheme to use.
 /// \param MangledName - reference to string to demangle.
 /// \returns - the demangled string, or a copy of the input string if no
 /// demangling occurred.

llvm/include/llvm/Demangle/MicrosoftDemangleNodes.h

 };
 
 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
 
 enum OutputFlags {
   OF_Default = 0,
   OF_NoCallingConvention = 1,
   OF_NoTagSpecifier = 2,
+  OF_NoAccessSpecifier = 4,
+  OF_NoMemberType = 8,
+  OF_NoReturnType = 16,
 };
 
 // Types
 enum class PrimitiveKind {
   Void,
   Bool,
   Char,
   Schar,

llvm/lib/Demangle/MicrosoftDemangle.cpp

char *llvm::microsoftDemangle(const char *MangledName, char *Buf, size_t *N,
   OutputStream S;
 
   StringView Name{MangledName};
   SymbolNode *AST = D.parse(Name);
 
   if (Flags & MSDF_DumpBackrefs)
     D.dumpBackReferences();
 
+  OutputFlags OF = OF_Default;
+  if (Flags & MSDF_NoCallingConvention)
+    OF = OutputFlags(OF | OF_NoCallingConvention);
+  if (Flags & MSDF_NoAccessSpecifier)
+    OF = OutputFlags(OF | OF_NoAccessSpecifier);
+  if (Flags & MSDF_NoReturnType)
+    OF = OutputFlags(OF | OF_NoReturnType);
+  if (Flags & MSDF_NoMemberType)
+    OF = OutputFlags(OF | OF_NoMemberType);
+
   if (D.Error)
     InternalStatus = demangle_invalid_mangled_name;
   else if (!initializeOutputStream(Buf, N, S, 1024))
     InternalStatus = demangle_memory_alloc_failure;
   else {
-    AST->output(S, OF_Default);
+    AST->output(S, OF);
     S += '\0';
     if (N != nullptr)
       *N = S.getCurrentPosition();
     Buf = S.getBuffer();
   }
 
   if (Status)
     *Status = InternalStatus;
   return InternalStatus == demangle_success ? Buf : nullptr;
 }

llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

 void LiteralOperatorIdentifierNode::output(OutputStream &OS,
                                            OutputFlags Flags) const {
   OS << "operator \"\"" << Name;
   outputTemplateParameters(OS, Flags);
 }
 
 void FunctionSignatureNode::outputPre(OutputStream &OS,
                                       OutputFlags Flags) const {
+  if (!(Flags & OF_NoAccessSpecifier)) {
     if (FunctionClass & FC_Public)
       OS << "public: ";
     if (FunctionClass & FC_Protected)
       OS << "protected: ";
     if (FunctionClass & FC_Private)
       OS << "private: ";
+  }
 
+  if (!(Flags & OF_NoMemberType)) {
     if (!(FunctionClass & FC_Global)) {
       if (FunctionClass & FC_Static)
         OS << "static ";
     }
     if (FunctionClass & FC_Virtual)
       OS << "virtual ";
 
     if (FunctionClass & FC_ExternC)
       OS << "extern \"C\" ";
+  }
 
-  if (ReturnType) {
+  if (!(Flags & OF_NoReturnType) && ReturnType) {
     ReturnType->outputPre(OS, Flags);
     OS << " ";
   }
 
   if (!(Flags & OF_NoCallingConvention))
     outputCallingConvention(OS, CallConvention);
 }
 
void FunctionSignatureNode::outputPost(OutputStream &OS,
   if (IsNoexcept)
     OS << " noexcept";
 
   if (RefQualifier == FunctionRefQualifier::Reference)
     OS << " &";
   else if (RefQualifier == FunctionRefQualifier::RValueReference)
     OS << " &&";
 
-  if (ReturnType)
+  if (!(Flags & OF_NoReturnType) && ReturnType)
     ReturnType->outputPost(OS, Flags);
 }
 
 void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
   OS << "[thunk]: ";
 
   FunctionSignatureNode::outputPre(OS, Flags);
 }

 void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
   Signature->outputPre(OS, Flags);
   outputSpaceIfNecessary(OS);
   Name->output(OS, Flags);
   Signature->outputPost(OS, Flags);
 }
 
 void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+  const char *AccessSpec = nullptr;
+  bool IsStatic = true;
   switch (SC) {
   case StorageClass::PrivateStatic:
-    OS << "private: static ";
+    AccessSpec = "private";
     break;
   case StorageClass::PublicStatic:
-    OS << "public: static ";
+    AccessSpec = "public";
     break;
   case StorageClass::ProtectedStatic:
-    OS << "protected: static ";
+    AccessSpec = "protected";
     break;
   default:
+    IsStatic = false;
     break;
   }
+  if (!(Flags & OF_NoAccessSpecifier) && AccessSpec)
+    OS << AccessSpec << ": ";
+  if (!(Flags & OF_NoMemberType) && IsStatic)
+    OS << "static ";
 
   if (Type) {
     Type->outputPre(OS, Flags);
     outputSpaceIfNecessary(OS);
   }
   Name->output(OS, Flags);
   if (Type)
     Type->outputPost(OS, Flags);

llvm/test/Demangle/ms-options.test

+; RUN: llvm-undname < %s | FileCheck %s
+; RUN: llvm-undname --no-calling-convention < %s | FileCheck %s --check-prefix=CHECK-NO-CALLING-CONV
+; RUN: llvm-undname --no-return-type < %s | FileCheck %s --check-prefix=CHECK-NO-RETURN
+; RUN: llvm-undname --no-access-specifier < %s | FileCheck %s --check-prefix=CHECK-NO-ACCESS
+; RUN: llvm-undname --no-member-type < %s | FileCheck %s --check-prefix=CHECK-NO-MEMBER-TYPE
+; RUN: llvm-undname --no-calling-convention --no-return-type --no-access-specifier --no-member-type < %s | FileCheck %s --check-prefix=CHECK-NO-ALL
+
+?func@MyClass@@UEAAHHH@Z
+; CHECK: public: virtual int __cdecl MyClass::func(int, int)
+; CHECK-NO-CALLING-CONV: public: virtual int MyClass::func(int, int)
+; CHECK-NO-RETURN: public: virtual __cdecl MyClass::func(int, int)
+; CHECK-NO-ACCESS: {{^}}virtual int __cdecl MyClass::func(int, int)
+; CHECK-NO-MEMBER-TYPE: public: int __cdecl MyClass::func(int, int)
+; CHECK-NO-ALL: {{^}}MyClass::func(int, int)

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

 #include <iostream>
 #include <string>
 
 using namespace llvm;
 
 cl::opt<bool> DumpBackReferences("backrefs", cl::Optional,
                                  cl::desc("dump backreferences"), cl::Hidden,
                                  cl::init(false));
+cl::opt<bool> NoAccessSpecifier("no-access-specifier", cl::Optional,
+                                cl::desc("skip access specifiers"), cl::Hidden,
+                                cl::init(false));
+cl::opt<bool> NoCallingConvention("no-calling-convention", cl::Optional,
+                                  cl::desc("skip calling convention"),
+                                  cl::Hidden, cl::init(false));
+cl::opt<bool> NoReturnType("no-return-type", cl::Optional,
+                           cl::desc("skip return types"), cl::Hidden,
+                           cl::init(false));
+cl::opt<bool> NoMemberType("no-member-type", cl::Optional,
+                           cl::desc("skip member types"), cl::Hidden,
+                           cl::init(false));
 cl::opt<std::string> RawFile("raw-file", cl::Optional,
                              cl::desc("for fuzzer data"), cl::Hidden);
 cl::list<std::string> Symbols(cl::Positional, cl::desc("<input symbols>"),
                               cl::ZeroOrMore);
 
 static bool msDemangle(const std::string &S) {
   int Status;
   MSDemangleFlags Flags = MSDF_None;
   if (DumpBackReferences)
     Flags = MSDemangleFlags(Flags | MSDF_DumpBackrefs);
+  if (NoAccessSpecifier)
+    Flags = MSDemangleFlags(Flags | MSDF_NoAccessSpecifier);
+  if (NoCallingConvention)
+    Flags = MSDemangleFlags(Flags | MSDF_NoCallingConvention);
+  if (NoReturnType)
+    Flags = MSDemangleFlags(Flags | MSDF_NoReturnType);
+  if (NoMemberType)
+    Flags = MSDemangleFlags(Flags | MSDF_NoMemberType);
 
   char *ResultBuf =
       microsoftDemangle(S.c_str(), nullptr, nullptr, &Status, Flags);
   if (Status == llvm::demangle_success) {
     outs() << ResultBuf << "\n";
     outs().flush();
   } else {
     WithColor::error() << "Invalid mangled name\n";