[Symbolize][MinGW] Support demangling i386 call-conv-decorated C++ names

On i386 Windows, after C++ names have been Itanium-mangled, the C name
mangling specific to its call convention may also be applied on top.
This change teaches symbolizer to be able to demangle this type of
mangled names.

As part of this change, `demanglePE32ExternCFunc` has also been modified
to fix unwanted stripping for vectorcall names when the demangled name
is supposed to contain a leading `_`. Notice that the vectorcall
mangling does not add either an `_` or `@` prefix. The old code always
tries to strip the prefix first, which for Itanium mangled names in
vectorcall, the leading underscore of the Itanium name gets stripped
instead and breaks the Itanium demangler.

Differential Revision: https://reviews.llvm.org/D144049

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

@@ -649,22 +649,29 @@ namespace {
 // vectorcall  - foo@@12
 // These are all different linkage names for 'foo'.
 StringRef demanglePE32ExternCFunc(StringRef SymbolName) {
-  // Remove any '_' or '@' prefix.
   char Front = SymbolName.empty() ? '\0' : SymbolName[0];
-  if (Front == '_' || Front == '@')
-    SymbolName = SymbolName.drop_front();
 
   // Remove any '@[0-9]+' suffix.
+  bool HasAtNumSuffix = false;
   if (Front != '?') {
     size_t AtPos = SymbolName.rfind('@');
     if (AtPos != StringRef::npos &&
-        all_of(drop_begin(SymbolName, AtPos + 1), isDigit))
+        all_of(drop_begin(SymbolName, AtPos + 1), isDigit)) {
       SymbolName = SymbolName.substr(0, AtPos);
+      HasAtNumSuffix = true;
+    }
   }
 
   // Remove any ending '@' for vectorcall.
-  if (SymbolName.endswith("@"))
+  bool IsVectorCall = false;
+  if (HasAtNumSuffix && SymbolName.endswith("@")) {
     SymbolName = SymbolName.drop_back();
+    IsVectorCall = true;
+  }
+
+  // If not vectorcall, remove any '_' or '@' prefix.
+  if (!IsVectorCall && (Front == '_' || Front == '@'))
+    SymbolName = SymbolName.drop_front();
 
   return SymbolName;
 }
@@ -692,8 +699,14 @@ LLVMSymbolizer::DemangleName(const std::string &Name,
     return Result;
   }
 
-  if (DbiModuleDescriptor && DbiModuleDescriptor->isWin32Module())
-    return std::string(demanglePE32ExternCFunc(Name));
+  if (DbiModuleDescriptor && DbiModuleDescriptor->isWin32Module()) {
+    std::string DemangledCName(demanglePE32ExternCFunc(Name));
+    // On i386 Windows, the C name mangling for different calling conventions
+    // may also be applied on top of the Itanium or Rust name mangling.
+    if (nonMicrosoftDemangle(DemangledCName.c_str(), Result))
+      return Result;
+    return DemangledCName;
+  }
   return Name;
 }
 

llvm/test/DebugInfo/symbolize-demangling-mingw32.s

@@ -0,0 +1,124 @@
+# REQUIRES: x86-registered-target
+
+# RUN: llvm-mc --filetype=obj --triple=i386-w64-windows-gnu %s -o %t.o -g
+
+# RUN: llvm-symbolizer --obj=%t.o 0 1 2 3 4 5 6 7 8 9 10 | FileCheck %s
+
+  .def g
+  .scl 2
+  .type 32
+  .endef
+g:
+  nop
+# CHECK:       {{^g$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:12
+# CHECK-EMPTY:
+
+  .def baz
+  .scl 2
+  .type 32
+  .endef
+baz:
+  nop
+# CHECK-NEXT:  {{^baz$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:22
+# CHECK-EMPTY:
+
+# extern "C" void c() {} // __cdecl
+  .def _c
+  .scl 2
+  .type 32
+  .endef
+_c:
+  nop
+# CHECK-NEXT:  {{^c$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:33
+# CHECK-EMPTY:
+
+# extern "C" void __stdcall c1() {}
+  .def _c1@0
+  .scl 2
+  .type 32
+  .endef
+_c1@0:
+  nop
+# CHECK-NEXT:  {{^c1$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:44
+# CHECK-EMPTY:
+
+# extern "C" void __fastcall c2(void) {}
+  .def @c2@0
+  .scl 2
+  .type 32
+  .endef
+@c2@0:
+  nop
+# CHECK-NEXT:  {{^c2$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:55
+# CHECK-EMPTY:
+
+# extern "C" void __vectorcall c3(void) {}
+  .def c3@@0
+  .scl 2
+  .type 32
+  .endef
+c3@@0:
+  nop
+# CHECK-NEXT:  {{^c3$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:66
+# CHECK-EMPTY:
+
+# void f() {} // __cdecl
+  .def __Z1fv
+  .scl 2
+  .type 32
+  .endef
+__Z1fv:
+  nop
+# CHECK-NEXT:  {{^f\(\)$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:77
+# CHECK-EMPTY:
+
+# void __stdcall f1() {}
+  .def __Z2f1v@0
+  .scl 2
+  .type 32
+  .endef
+__Z2f1v@0:
+  nop
+# CHECK-NEXT:  {{^f1\(\)$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:88
+# CHECK-EMPTY:
+
+# void __fastcall f2(void) {}
+  .def @_Z2f2v@0
+  .scl 2
+  .type 32
+  .endef
+@_Z2f2v@0:
+  nop
+# CHECK-NEXT:  {{^f2\(\)$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:99
+# CHECK-EMPTY:
+
+# void __vectorcall f3(void) {}
+  .def _Z2f3v@@0
+  .scl 2
+  .type 32
+  .endef
+_Z2f3v@@0:
+  nop
+# CHECK-NEXT:  {{^f3\(\)$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:110
+# CHECK-EMPTY:
+
+# Rust
+  .def __RNvC1x1y
+  .scl 2
+  .type 32
+  .endef
+__RNvC1x1y:
+  nop
+# CHECK-NEXT:  {{^x::y$}}
+# CHECK-NEXT:  symbolize-demangling-mingw32.s:121
+# CHECK-EMPTY: