[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

18

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

18

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

18

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

18

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

383

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.

1390

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

18

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/include/clang/Basic/LangOptions.h

public:
   enum MSVCMajorVersion {
     MSVC2010 = 1600,
     MSVC2012 = 1700,
     MSVC2013 = 1800,
     MSVC2015 = 1900,
     MSVC2017 = 1910,
     MSVC2017_5 = 1912,
     MSVC2017_7 = 1914,
+    MSVC2019 = 1920,
   };
 
   /// Clang versions with different platform ABI conformance.
   enum class ClangABI {
     /// Attempt to be ABI-compatible with code generated by Clang 3.8.x
     /// (SVN r257626). This causes <1 x long long> to be passed in an
     /// integer register instead of an SSE register on x64_64.
     Ver3_8,

clang/lib/AST/MicrosoftMangle.cpp

 #undef TYPE
 
   void mangleType(const TagDecl *TD);
   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 mangleIntegerLiteral(const llvm::APSInt &Number,
+                            const NonTypeTemplateParmDecl *PD = nullptr,
+                            QualType TemplateArgType = QualType());
+  void mangleExpression(const Expr *E, const NonTypeTemplateParmDecl *PD);
   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
 MicrosoftCXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *TD) {
   // <unscoped-template-name> ::= ?$ <unqualified-name>
   Out << "?$";
   mangleUnqualifiedName(TD);
 }
 
-void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value,
-                                                   bool IsBoolean) {
+void MicrosoftCXXNameMangler::mangleIntegerLiteral(
+    const llvm::APSInt &Value, const NonTypeTemplateParmDecl *PD,
+    QualType TemplateArgType) {
   // <integer-literal> ::= $0 <number>
-  Out << "$0";
-  // Make sure booleans are encoded as 0/1.
-  if (IsBoolean && Value.getBoolValue())
-    mangleNumber(1);
-  else if (Value.isSigned())
+  Out << "$";
+
+  // Since MSVC 2019, add 'M[<type>]' after '$' for auto template parameter when
+  // argument is integer.
+  if (getASTContext().getLangOpts().isCompatibleWithMSVC(
+          LangOptions::MSVC2019) &&
+      PD && PD->getType()->getTypeClass() == Type::Auto &&
+      !TemplateArgType.isNull()) {
+    Out << "M";
+    mangleType(TemplateArgType, SourceRange(), QMM_Drop);
+  }
+
+  Out << "0";
+
+  if (Value.isSigned())
     mangleNumber(Value.getSExtValue());
   else
     mangleNumber(Value.getZExtValue());
 }
 
-void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
+void MicrosoftCXXNameMangler::mangleExpression(
+    const Expr *E, const NonTypeTemplateParmDecl *PD) {
   // See if this is a constant expression.
   if (Optional<llvm::APSInt> Value =
           E->getIntegerConstantExpr(Context.getASTContext())) {
-    mangleIntegerLiteral(*Value, E->getType()->isBooleanType());
+    mangleIntegerLiteral(*Value, PD, E->getType());
     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();
     mangleIntegerLiteral(TA.getAsIntegral(),
-                         TA.getIntegralType()->isBooleanType());
+                         cast<NonTypeTemplateParmDecl>(Parm), T);
     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);
         return;
       }
       if (MPT->isMemberDataPointer()) {
         if (!isa<FunctionTemplateDecl>(TD)) {
           mangleMemberDataPointer(RD, nullptr);
           return;
         }
         // nullptr data pointers are always represented with a single field
         // which is initialized with either 0 or -1.  Why -1?  Well, we need to
         // distinguish the case where the data member is at offset zero in the
         // record.
         // However, we are free to use 0 *if* we would use multiple fields for
         // non-nullptr member pointers.
         if (!RD->nullFieldOffsetIsZero()) {
-          mangleIntegerLiteral(llvm::APSInt::get(-1), /*IsBoolean=*/false);
+          mangleIntegerLiteral(llvm::APSInt::get(-1),
+                               cast<NonTypeTemplateParmDecl>(Parm), T);
           return;
         }
       }
     }
-    mangleIntegerLiteral(llvm::APSInt::getUnsigned(0), /*IsBoolean=*/false);
+    mangleIntegerLiteral(llvm::APSInt::getUnsigned(0),
+                         cast<NonTypeTemplateParmDecl>(Parm), T);
     break;
   }
   case TemplateArgument::Expression:
-    mangleExpression(TA.getAsExpr());
+    mangleExpression(TA.getAsExpr(), cast<NonTypeTemplateParmDecl>(Parm));
     break;
   case TemplateArgument::Pack: {
     ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
     if (TemplateArgs.empty()) {
       if (isa<TemplateTypeParmDecl>(Parm) ||
           isa<TemplateTemplateParmDecl>(Parm))
         // MSVC 2015 changed the mangling for empty expanded template packs,
         // use the old mangling for link compatibility for old versions.
void MicrosoftCXXNameMangler::mangleAddressSpaceType(QualType T,
   llvm::raw_svector_ostream Stream(ASMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
   Stream << "?$";
 
   LangAS AS = Quals.getAddressSpace();
   if (Context.getASTContext().addressSpaceMapManglingFor(AS)) {
     unsigned TargetAS = Context.getASTContext().getTargetAddressSpace(AS);
     Extra.mangleSourceName("_AS");
-    Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(TargetAS),
-                               /*IsBoolean*/ false);
+    Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(TargetAS));
   } else {
     switch (AS) {
     default:
       llvm_unreachable("Not a language specific address space");
     case LangAS::opencl_global:
       Extra.mangleSourceName("_ASCLglobal");
       break;
     case LangAS::opencl_global_device:
if (!IsBuiltin) {
     // types, and for extensions like __v4sf.
 
     llvm::SmallString<64> TemplateMangling;
     llvm::raw_svector_ostream Stream(TemplateMangling);
     MicrosoftCXXNameMangler Extra(Context, Stream);
     Stream << "?$";
     Extra.mangleSourceName("__vector");
     Extra.mangleType(QualType(ET, 0), Range, QMM_Escape);
-    Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()),
-                               /*IsBoolean=*/false);
+    Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()));
 
     mangleArtificialTagType(TTK_Union, TemplateMangling, {"__clang"});
   }
 }
 
 void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
                                          Qualifiers Quals, SourceRange Range) {
   mangleType(static_cast<const VectorType *>(T), Quals, Range);
void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
   QualType ElementType = T->getElementType();
 
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
   Stream << "?$";
   Extra.mangleSourceName("ocl_pipe");
   Extra.mangleType(ElementType, Range, QMM_Escape);
-  Extra.mangleIntegerLiteral(llvm::APSInt::get(T->isReadOnly()), true);
+  Extra.mangleIntegerLiteral(llvm::APSInt::get(T->isReadOnly()));
 
   mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
 void MicrosoftMangleContextImpl::mangleCXXName(GlobalDecl GD,
                                                raw_ostream &Out) {
   const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
   PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
void MicrosoftCXXNameMangler::mangleType(const ExtIntType *T, Qualifiers,
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
   Stream << "?$";
   if (T->isUnsigned())
     Extra.mangleSourceName("_UExtInt");
   else
     Extra.mangleSourceName("_ExtInt");
-  Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumBits()),
-                             /*IsBoolean=*/false);
+  Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumBits()));
 
   mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
 void MicrosoftCXXNameMangler::mangleType(const DependentExtIntType *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(

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

+// RUN: %clang_cc1 -std=c++17 -fms-compatibility-version=19.20 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-windows-msvc | FileCheck --check-prefix=AFTER %s
+// RUN: %clang_cc1 -std=c++17 -fms-compatibility-version=19.14 -emit-llvm %s -o - -fms-extensions -fdelayed-template-parsing -triple=x86_64-pc-windows-msvc | FileCheck --check-prefix=BEFORE %s
+
+template <auto a>
+class AutoParmTemplate {
+public:
+  AutoParmTemplate() {}
+};
+
+template <auto...>
+class AutoParmsTemplate {
+public:
+  AutoParmsTemplate() {}
+};
+
+template <auto a>
+auto AutoFunc () {
+  return a;
+}
+
+void template_mangling() {
+  AutoFunc<1>();
+  // AFTER: call {{.*}} @"??$AutoFunc@$MH00@@YA?A?<auto>@@XZ"
+  // BEFORE: call {{.*}} @"??$AutoFunc@$00@@YA?A?<auto>@@XZ"
+  AutoParmTemplate<0> auto_int;
+  // AFTER: call {{.*}} @"??0?$AutoParmTemplate@$MH0A@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$0A@@@QEAA@XZ"
+  AutoParmTemplate<'a'> auto_char;
+  // AFTER: call {{.*}} @"??0?$AutoParmTemplate@$MD0GB@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$0GB@@@QEAA@XZ"
+  AutoParmTemplate<9223372036854775807LL> int64_max;
+  // AFTER: call {{.*}} @"??0?$AutoParmTemplate@$M_J0HPPPPPPPPPPPPPPP@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$0HPPPPPPPPPPPPPPP@@@QEAA@XZ"
+  AutoParmTemplate<-9223372036854775807LL - 1LL> int64_min;
+  // AFTER: call {{.*}} @"??0?$AutoParmTemplate@$M_J0?IAAAAAAAAAAAAAAA@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$0?IAAAAAAAAAAAAAAA@@@QEAA@XZ"
+  AutoParmTemplate<(unsigned long long)-1> uint64_neg_1;
+  // AFTER: call {{.*}} @"??0?$AutoParmTemplate@$M_K0?0@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$0?0@@QEAA@XZ"
+
+  AutoParmsTemplate<0, false, 'a'> c1;
+  // AFTER: call {{.*}} @"??0?$AutoParmsTemplate@$MH0A@$M_N0A@$MD0GB@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmsTemplate@$0A@$0A@$0GB@@@QEAA@XZ"
+  AutoParmsTemplate<(unsigned long)1, 9223372036854775807LL> c2;
+  // AFTER: call {{.*}} @"??0?$AutoParmsTemplate@$MK00$M_J0HPPPPPPPPPPPPPPP@@@QEAA@XZ"
+  // BEFORE: call {{.*}} @"??0?$AutoParmsTemplate@$00$0HPPPPPPPPPPPPPPP@@@QEAA@XZ"
+}