[MS ABI] Add mangled type for auto template parameter whose argument kind is Integeral

[zequanwu]

Summary

Add mangled type for auto template parameter to differentiate different types of template integer arguments, as MSVC does: https://godbolt.org/z/6FMZbF

Bug filed here: https://bugs.llvm.org/show_bug.cgi?id=45969 which is caused by missing mangled type for template integer argument.

[zequanwu]

• Only add mangled type for auto template parameter, whose argument kind is Integral.
• MSVC mangled name has 1 more letter M before the mangled type, but I don't do it here because I think the M is from mangled qualifier and the function mangleQualifiers is incomplete yet.

[thakis]

clang/test/CodeGenCXX/mangle-ms-auto-templates.cpp

17 ↗

(On Diff #266082)

Are you sure this is correct? MSVC produces a different mangling (https://godbolt.org/z/VxRfJd) and neither undname nor llvm-undname / demumble can demangle the symbol here (while they demange the msvc output according to godbolt fine).

[zequanwu]

clang/test/CodeGenCXX/mangle-ms-auto-templates.cpp

17 ↗

(On Diff #266082)

I use x64 msvc v19.24 version, which gives @"??0?$AutoParmTemplate@$MH0A@@@QAE@XZ". The extra M might come from qualifier mangling.

For x86 msvc v19.24(WINE) version, it produces ??0?$AutoParmTemplate@$0A@@@QAE@XZ for both AutoParmTemplate<0> auto_int and AutoParmTemplate<false> auto_int. Isn't this a bug?

[thakis]

clang/test/CodeGenCXX/mangle-ms-auto-templates.cpp

17 ↗

(On Diff #266082)

The test at the top says -triple=i386. If you have x64 mangling results in here, you should use a 64-bit triple (ie -tripe=x86_64-pc-windows). If the mangling is structurally different for different bitnesses, we should probably have tests for both.

For symbols that can be exported, we need to match msvc's mangling to be abi-compatible, no matter if we consider the mangling a bug or not.

[zequanwu]

clang/test/CodeGenCXX/mangle-ms-auto-templates.cpp

17 ↗

(On Diff #266082)

In x64 msvc v19.14, it still gives the same mangling results as x86. From godbolt, it looks like that the mangled type was only added since msvc v19.20. (https://godbolt.org/z/xGT3w-). But the MSVCMajorVersion is only up to 1914, which I guess means v19.14.

I will add a new version for v19.20 which will add M[type] for each auto template parameter.

[zequanwu]

Add 19.20 version. Only add mangled type for version 19. 20 or later to be abi-compatible with https://godbolt.org/z/Bhc__A

[zequanwu]

Do you think adding MSVC2019 to make the name mangling compatible with MSVC v19.20 is acceptable?

[rnk]

clang/lib/AST/MicrosoftMangle.cpp

384

I see you need an optional QualType here. Can you do this: QualType TemplateArgType = QualType()? I believe it will create a null QualType, which you can then check for with .isNull().

QualType is pointer-sized and is generally passed by value. I think it will help make the other call sites shorter, so they don't need to take the address of a local variable.

1378

For example, if you can avoid the pointer indirection, you can avoid the local variable here.

[zequanwu]

rebase and address comment.

[rnk]

Looks good, but we should test both sides of the MSVC behavior.

clang/test/CodeGenCXX/mangle-ms-auto-templates.cpp

17 ↗

(On Diff #266082)

Please add a second RUN line with a new check prefix to test the behavior both before and after.

[zequanwu]

Add check for MSVC version 19.14 (removed AutoParmTemplate<false> auto_bool as its mangled name conflicts with AutoParmTemplate<0> auto_int in V19.14).

[rnk]

lgtm, thanks!

[zequanwu]

update comment.
add a test case for template function.

[zequanwu]

committed here https://reviews.llvm.org/rG83286a1a8f059d1664b64341854676a36a85cecd.

clang/lib/AST/MicrosoftMangle.cpp

#undef TYPE
   void mangleDecayedArrayType(const ArrayType *T);
   void mangleArrayType(const ArrayType *T);
   void mangleFunctionClass(const FunctionDecl *FD);
   void mangleCallingConvention(CallingConv CC);
   void mangleCallingConvention(const FunctionType *T);
   void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean);
   void mangleExpression(const Expr *E);
   void mangleThrowSpecification(const FunctionProtoType *T);
 
   void mangleTemplateArgs(const TemplateDecl *TD,
                           const TemplateArgumentList &TemplateArgs);
   void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
                          const NamedDecl *Parm);
 
   void mangleObjCProtocol(const ObjCProtocolDecl *PD);
   void mangleObjCLifetime(const QualType T, Qualifiers Quals,
                           SourceRange Range);
void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value,
   else
     mangleNumber(Value.getZExtValue());
 }
 
 void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
   // See if this is a constant expression.
   llvm::APSInt Value;
   if (E->isIntegerConstantExpr(Value, Context.getASTContext())) {
-    mangleIntegerLiteral(Value, E->getType()->isBooleanType());
+    QualType T = E->getType();
+    mangleType(T, SourceRange());
+    mangleIntegerLiteral(Value, T->isBooleanType());
     return;
   }
 
   // As bad as this diagnostic is, it's better than crashing.
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
   Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {
         mangleName(FD);
         mangleFunctionEncoding(FD, /*ShouldMangle=*/true);
       }
     } else {
       mangle(ND, TA.getParamTypeForDecl()->isReferenceType() ? "$E?" : "$1?");
     }
     break;
   }
-  case TemplateArgument::Integral:
+  case TemplateArgument::Integral: {
+    QualType T = TA.getIntegralType();
+    mangleType(T, SourceRange());
     mangleIntegerLiteral(TA.getAsIntegral(),
-                         TA.getIntegralType()->isBooleanType());
+                         T->isBooleanType());
+  }
     break;
   case TemplateArgument::NullPtr: {
     QualType T = TA.getNullPtrType();
     if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) {
       const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
       if (MPT->isMemberFunctionPointerType() &&
           !isa<FunctionTemplateDecl>(TD)) {
         mangleMemberFunctionPointer(RD, nullptr);