[clang-cl] [AST] Reapply #102848 Fix placeholder return type name mangling for MSVC 1920+ / VS2019+ #104722
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
clang
|
@llvm/pr-subscribers-clang Author: Max Winkler (MaxEW707) ChangesReapply #102848. The description in this PR will detail the changes from the reverted original PR above. For We can use If we are mangling a template with a placeholder return type we want to get the first template declaration and use its return type to do the mangling of any instantiations. This fixes the bug reported in the original PR that caused the revert with libcxx Patch is 23.63 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/104722.diff 6 Files Affected:
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 3c2e0282d1c72d..4b6ddd1dd8d0f3 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -46,6 +46,8 @@ C++ Specific Potentially Breaking Changes
ABI Changes in This Version
---------------------------
+- Fixed Microsoft name mangling of placeholder, auto and decltype(auto), return types for MSVC 1920+. This change resolves incompatibilities with code compiled by MSVC 1920+ but will introduce incompatibilities with code compiled by earlier versions of Clang unless such code is built with the compiler option -fms-compatibility-version=19.14 to imitate the MSVC 1914 mangling behavior.
+
AST Dumping Potentially Breaking Changes
----------------------------------------
diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp
index 28f66e71c2f2de..7b3731db019ffa 100644
--- a/clang/lib/AST/MicrosoftMangle.cpp
+++ b/clang/lib/AST/MicrosoftMangle.cpp
@@ -408,6 +408,8 @@ class MicrosoftCXXNameMangler {
void mangleSourceName(StringRef Name);
void mangleNestedName(GlobalDecl GD);
+ void mangleAutoReturnType(QualType T, QualifierMangleMode QMM);
+
private:
bool isStructorDecl(const NamedDecl *ND) const {
return ND == Structor || getStructor(ND) == Structor;
@@ -477,6 +479,11 @@ class MicrosoftCXXNameMangler {
SourceRange Range);
void mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals,
SourceRange Range);
+
+ void mangleAutoReturnType(const MemberPointerType *T, Qualifiers Quals);
+ void mangleAutoReturnType(const PointerType *T, Qualifiers Quals);
+ void mangleAutoReturnType(const LValueReferenceType *T, Qualifiers Quals);
+ void mangleAutoReturnType(const RValueReferenceType *T, Qualifiers Quals);
};
}
@@ -2494,6 +2501,57 @@ void MicrosoftCXXNameMangler::mangleAddressSpaceType(QualType T,
mangleArtificialTagType(TagTypeKind::Struct, ASMangling, {"__clang"});
}
+void MicrosoftCXXNameMangler::mangleAutoReturnType(QualType T,
+ QualifierMangleMode QMM) {
+ assert(getASTContext().getLangOpts().isCompatibleWithMSVC(
+ LangOptions::MSVC2019) &&
+ "Cannot mangle MSVC 2017 auto return types!");
+
+ if (isa<AutoType>(T)) {
+ const auto *AT = T->getContainedAutoType();
+ Qualifiers Quals = T.getLocalQualifiers();
+
+ if (QMM == QMM_Result)
+ Out << '?';
+ if (QMM != QMM_Drop)
+ mangleQualifiers(Quals, false);
+ Out << (AT->isDecltypeAuto() ? "_T" : "_P");
+ return;
+ }
+
+ T = T.getDesugaredType(getASTContext());
+ Qualifiers Quals = T.getLocalQualifiers();
+
+ switch (QMM) {
+ case QMM_Drop:
+ case QMM_Result:
+ break;
+ case QMM_Mangle:
+ mangleQualifiers(Quals, false);
+ break;
+ default:
+ llvm_unreachable("QMM_Escape unexpected");
+ }
+
+ const Type *ty = T.getTypePtr();
+ switch (ty->getTypeClass()) {
+ case Type::MemberPointer:
+ mangleAutoReturnType(cast<MemberPointerType>(ty), Quals);
+ break;
+ case Type::Pointer:
+ mangleAutoReturnType(cast<PointerType>(ty), Quals);
+ break;
+ case Type::LValueReference:
+ mangleAutoReturnType(cast<LValueReferenceType>(ty), Quals);
+ break;
+ case Type::RValueReference:
+ mangleAutoReturnType(cast<RValueReferenceType>(ty), Quals);
+ break;
+ default:
+ llvm_unreachable("Invalid type expected");
+ }
+}
+
void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range,
QualifierMangleMode QMM) {
// Don't use the canonical types. MSVC includes things like 'const' on
@@ -2900,17 +2958,60 @@ void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
// can differ by their calling convention and are typically deduced. So
// we make sure that this type gets mangled properly.
mangleType(ResultType, Range, QMM_Result);
- } else if (const auto *AT = dyn_cast_or_null<AutoType>(
- ResultType->getContainedAutoType())) {
- Out << '?';
- mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
- Out << '?';
+ } else if (IsInLambda) {
+ if (const auto *AT = ResultType->getContainedAutoType()) {
+ assert(AT->getKeyword() == AutoTypeKeyword::Auto &&
+ "should only need to mangle auto!");
+ (void)AT;
+ Out << '?';
+ mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
+ Out << '?';
+ mangleSourceName("<auto>");
+ Out << '@';
+ } else {
+ Out << '@';
+ }
+ } else if (const auto *AT = ResultType->getContainedAutoType()) {
assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&
"shouldn't need to mangle __auto_type!");
- mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
- Out << '@';
- } else if (IsInLambda) {
- Out << '@';
+
+ // If we have any pointer types with the clang address space extension
+ // then defer to the custom clang mangling to keep backwards
+ // compatibility. See `mangleType(const PointerType *T, Qualifiers Quals,
+ // SourceRange Range)` for details.
+ auto UseClangMangling = [](QualType ResultType) {
+ QualType T = ResultType;
+ while (isa<PointerType>(T.getTypePtr())) {
+ T = T->getPointeeType();
+ if (T.getQualifiers().hasAddressSpace())
+ return true;
+ }
+ return false;
+ };
+
+ if (getASTContext().getLangOpts().isCompatibleWithMSVC(
+ LangOptions::MSVC2019) &&
+ !UseClangMangling(ResultType)) {
+ if (D && !D->getPrimaryTemplate()) {
+ Out << '@';
+ } else {
+ if (D && D->getPrimaryTemplate()) {
+ const FunctionProtoType *FPT = D->getPrimaryTemplate()
+ ->getTemplatedDecl()
+ ->getFirstDecl()
+ ->getType()
+ ->castAs<FunctionProtoType>();
+ ResultType = FPT->getReturnType();
+ }
+ mangleAutoReturnType(ResultType, QMM_Result);
+ }
+ } else {
+ Out << '?';
+ mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
+ Out << '?';
+ mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
+ Out << '@';
+ }
} else {
if (ResultType->isVoidType())
ResultType = ResultType.getUnqualifiedType();
@@ -4213,6 +4314,57 @@ void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL,
Mangler.getStream() << '@';
}
+void MicrosoftCXXNameMangler::mangleAutoReturnType(const MemberPointerType *T,
+ Qualifiers Quals) {
+ QualType PointeeType = T->getPointeeType();
+ manglePointerCVQualifiers(Quals);
+ manglePointerExtQualifiers(Quals, PointeeType);
+ if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
+ Out << '8';
+ mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleFunctionType(FPT, nullptr, true);
+ } else {
+ mangleQualifiers(PointeeType.getQualifiers(), true);
+ mangleName(T->getClass()->castAs<RecordType>()->getDecl());
+ mangleAutoReturnType(PointeeType, QMM_Drop);
+ }
+}
+
+void MicrosoftCXXNameMangler::mangleAutoReturnType(const PointerType *T,
+ Qualifiers Quals) {
+ QualType PointeeType = T->getPointeeType();
+ assert(!PointeeType.getQualifiers().hasAddressSpace() &&
+ "Unexpected address space mangling required");
+
+ manglePointerCVQualifiers(Quals);
+ manglePointerExtQualifiers(Quals, PointeeType);
+
+ if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
+ Out << '6';
+ mangleFunctionType(FPT);
+ } else {
+ mangleAutoReturnType(PointeeType, QMM_Mangle);
+ }
+}
+
+void MicrosoftCXXNameMangler::mangleAutoReturnType(const LValueReferenceType *T,
+ Qualifiers Quals) {
+ QualType PointeeType = T->getPointeeType();
+ assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
+ Out << 'A';
+ manglePointerExtQualifiers(Quals, PointeeType);
+ mangleAutoReturnType(PointeeType, QMM_Mangle);
+}
+
+void MicrosoftCXXNameMangler::mangleAutoReturnType(const RValueReferenceType *T,
+ Qualifiers Quals) {
+ QualType PointeeType = T->getPointeeType();
+ assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
+ Out << "$$Q";
+ manglePointerExtQualifiers(Quals, PointeeType);
+ mangleAutoReturnType(PointeeType, QMM_Mangle);
+}
+
MicrosoftMangleContext *MicrosoftMangleContext::create(ASTContext &Context,
DiagnosticsEngine &Diags,
bool IsAux) {
diff --git a/clang/test/CodeGenCXX/mangle-ms-auto-return.cpp b/clang/test/CodeGenCXX/mangle-ms-auto-return.cpp
new file mode 100644
index 00000000000000..5b18dcc0820ee6
--- /dev/null
+++ b/clang/test/CodeGenCXX/mangle-ms-auto-return.cpp
@@ -0,0 +1,383 @@
+// 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 %s
+
+struct StructA {};
+
+template<class T>
+auto AutoT() { return T(); }
+
+template<class T>
+const auto AutoConstT() { return T(); }
+
+template<class T>
+volatile auto AutoVolatileT() { return T(); }
+
+template<class T>
+const volatile auto AutoConstVolatileT() { return T(); }
+
+// The qualifiers of the return type should always be emitted even for void types.
+// Void types usually have their qualifers stripped in the mangled name for MSVC ABI.
+void test_template_auto_void() {
+ AutoT<void>();
+ // CHECK: call {{.*}} @"??$AutoT@X@@YA?A_PXZ"
+
+ AutoT<const void>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CBX@@YA?A_PXZ"
+
+ AutoT<volatile void>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CCX@@YA?A_PXZ"
+
+ AutoT<const volatile void>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CDX@@YA?A_PXZ"
+
+ AutoConstT<void>();
+ // CHECK: call {{.*}} @"??$AutoConstT@X@@YA?B_PXZ"
+
+ AutoVolatileT<void>();
+ // CHECK: call {{.*}} @"??$AutoVolatileT@X@@YA?C_PXZ"
+
+ AutoConstVolatileT<void>();
+ // CHECK: call {{.*}} @"??$AutoConstVolatileT@X@@YA?D_PXZ"
+}
+
+void test_template_auto_int() {
+ AutoT<int>();
+ // CHECK: call {{.*}} @"??$AutoT@H@@YA?A_PXZ"
+
+ AutoT<const int>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CBH@@YA?A_PXZ"
+
+ AutoT<volatile int>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CCH@@YA?A_PXZ"
+
+ AutoT<const volatile int>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CDH@@YA?A_PXZ"
+
+ AutoConstT<int>();
+ // CHECK: call {{.*}} @"??$AutoConstT@H@@YA?B_PXZ"
+
+ AutoVolatileT<int>();
+ // CHECK: call {{.*}} @"??$AutoVolatileT@H@@YA?C_PXZ"
+
+ AutoConstVolatileT<int>();
+ // CHECK: call {{.*}} @"??$AutoConstVolatileT@H@@YA?D_PXZ"
+}
+
+void test_template_auto_struct() {
+ AutoT<StructA>();
+ // CHECK: call {{.*}} @"??$AutoT@UStructA@@@@YA?A_PXZ"
+
+ AutoT<const StructA>();
+ // CHECK: call {{.*}} @"??$AutoT@$$CBUStructA@@@@YA?A_PXZ"
+
+ AutoConstT<StructA>();
+ // CHECK: call {{.*}} @"??$AutoConstT@UStructA@@@@YA?B_PXZ"
+
+ AutoVolatileT<StructA>();
+ // CHECK: call {{.*}} @"??$AutoVolatileT@UStructA@@@@YA?C_PXZ"
+
+ AutoConstVolatileT<StructA>();
+ // CHECK: call {{.*}} @"??$AutoConstVolatileT@UStructA@@@@YA?D_PXZ"
+}
+
+void test_template_auto_ptr() {
+ AutoT<int*>();
+ // CHECK: call {{.*}} @"??$AutoT@PEAH@@YA?A_PXZ"
+
+ AutoT<const int*>();
+ // CHECK: call {{.*}} @"??$AutoT@PEBH@@YA?A_PXZ"
+
+ AutoT<const int* const>();
+ // CHECK: call {{.*}} @"??$AutoT@QEBH@@YA?A_PXZ"
+
+ AutoConstT<int*>();
+ // CHECK: call {{.*}} @"??$AutoConstT@PEAH@@YA?B_PXZ"
+
+ AutoVolatileT<int*>();
+ // CHECK: call {{.*}} @"??$AutoVolatileT@PEAH@@YA?C_PXZ"
+
+ AutoConstVolatileT<int*>();
+ // CHECK: call {{.*}} @"??$AutoConstVolatileT@PEAH@@YA?D_PXZ"
+}
+
+template<class T>
+auto* PtrAutoT() { return T(); }
+
+template<class T>
+const auto* PtrAutoConstT() { return T(); }
+
+template<class T>
+volatile auto* PtrAutoVolatileT() { return T(); }
+
+template<class T>
+const volatile auto* PtrAutoConstVolatileT() { return T(); }
+
+void test_template_ptr_auto() {
+ PtrAutoT<int*>();
+ // CHECK: call {{.*}} @"??$PtrAutoT@PEAH@@YAPEA_PXZ"
+
+ PtrAutoT<const int*>();
+ // CHECK: call {{.*}} @"??$PtrAutoT@PEBH@@YAPEA_PXZ"
+
+ PtrAutoT<const int* const>();
+ // CHECK: call {{.*}} @"??$PtrAutoT@QEBH@@YAPEA_PXZ"
+
+ PtrAutoConstT<int*>();
+ // CHECK: call {{.*}} @"??$PtrAutoConstT@PEAH@@YAPEB_PXZ"
+
+ PtrAutoVolatileT<int*>();
+ // CHECK: call {{.*}} @"??$PtrAutoVolatileT@PEAH@@YAPEC_PXZ"
+
+ PtrAutoConstVolatileT<int*>();
+ // CHECK: call {{.*}} @"??$PtrAutoConstVolatileT@PEAH@@YAPED_PXZ"
+}
+
+int func_int();
+const int func_constint();
+void func_void();
+int* func_intptr();
+
+template<class T, T v>
+auto (*FuncPtrAutoT())() { return v; }
+
+void test_template_func_ptr_auto() {
+ FuncPtrAutoT<int (*)(), &func_int>();
+ // CHECK: call {{.*}} @"??$FuncPtrAutoT@P6AHXZ$1?func_int@@YAHXZ@@YAP6A?A_PXZXZ"
+
+ FuncPtrAutoT<const int (*)(), &func_constint>();
+ // CHECK: call {{.*}} @"??$FuncPtrAutoT@P6A?BHXZ$1?func_constint@@YA?BHXZ@@YAP6A?A_PXZXZ"
+
+ FuncPtrAutoT<void (*)(), &func_void>();
+ // CHECK: call {{.*}} @"??$FuncPtrAutoT@P6AXXZ$1?func_void@@YAXXZ@@YAP6A?A_PXZXZ"
+
+ FuncPtrAutoT<int * (*)(), &func_intptr>();
+ // CHECK: call {{.*}} @"??$FuncPtrAutoT@P6APEAHXZ$1?func_intptr@@YAPEAHXZ@@YAP6A?A_PXZXZ"
+}
+
+template<class T>
+auto& RefAutoT(T& x) { return x; }
+
+template<class T>
+const auto& ConstRefAutoT(T& x) { return x; }
+
+template<class T>
+auto&& RRefAutoT(T& x) { return static_cast<int&&>(x); }
+
+void test_template_ref_auto() {
+ int x;
+
+ RefAutoT(x);
+ // CHECK: call {{.*}} @"??$RefAutoT@H@@YAAEA_PAEAH@Z"
+
+ ConstRefAutoT(x);
+ // CHECK: call {{.*}} @"??$ConstRefAutoT@H@@YAAEB_PAEAH@Z"
+
+ RRefAutoT(x);
+ // CHECK: call {{.*}} @"??$RRefAutoT@H@@YA$$QEA_PAEAH@Z"
+}
+
+template<class T>
+decltype(auto) DecltypeAutoT() { return T(); }
+
+template<class T>
+decltype(auto) DecltypeAutoT2(T& x) { return static_cast<T&&>(x); }
+
+void test_template_decltypeauto() {
+ DecltypeAutoT<void>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@X@@YA?A_TXZ"
+
+ DecltypeAutoT<const void>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CBX@@YA?A_TXZ"
+
+ DecltypeAutoT<volatile void>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CCX@@YA?A_TXZ"
+
+ DecltypeAutoT<const volatile void>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CDX@@YA?A_TXZ"
+
+ DecltypeAutoT<int>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@H@@YA?A_TXZ"
+
+ DecltypeAutoT<const int>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CBH@@YA?A_TXZ"
+
+ DecltypeAutoT<volatile int>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CCH@@YA?A_TXZ"
+
+ DecltypeAutoT<const volatile int>();
+ // CHECK: call {{.*}} @"??$DecltypeAutoT@$$CDH@@YA?A_TXZ"
+
+ int x;
+
+ DecltypeAutoT2(x);
+ // CHECK: call {{.*}} @"??$DecltypeAutoT2@H@@YA?A_TAEAH@Z"
+}
+
+// Still want to use clang's custom mangling for lambdas to keep backwards compatibility until
+// MSVC lambda name mangling has been deciphered.
+void test_lambda() {
+ auto lambdaIntRetAuto = []() { return 0; };
+ lambdaIntRetAuto();
+ // CHECK: call {{.*}} @"??R<lambda_1>@?0??test_lambda@@YAXXZ@QEBA?A?<auto>@@XZ"
+
+ auto lambdaIntRet = []() -> int { return 0; };
+ lambdaIntRet();
+ // CHECK: call {{.*}} @"??R<lambda_2>@?0??test_lambda@@YAXXZ@QEBA@XZ"
+
+ auto lambdaGenericIntIntRetAuto = [](auto a) { return a; };
+ lambdaGenericIntIntRetAuto(0);
+ // CHECK: call {{.*}} @"??$?RH@<lambda_0>@?0??test_lambda@@YAXXZ@QEBA?A?<auto>@@H@Z"
+}
+
+auto TestTrailingInt() -> int {
+ return 0;
+}
+
+auto TestTrailingConstVolatileVoid() -> const volatile void {
+}
+
+auto TestTrailingStructA() -> StructA {
+ return StructA{};
+}
+
+void test_trailing_return() {
+ TestTrailingInt();
+ // CHECK: call {{.*}} @"?TestTrailingInt@@YAHXZ"
+
+ TestTrailingConstVolatileVoid();
+ // CHECK: call {{.*}} @"?TestTrailingConstVolatileVoid@@YAXXZ"
+
+ TestTrailingStructA();
+ // CHECK: call {{.*}} @"?TestTrailingStructA@@YA?AUStructA@@XZ"
+}
+
+auto TestNonTemplateAutoInt() {
+ return 0;
+}
+
+auto TestNonTemplateAutoVoid() {
+ return;
+}
+
+auto TestNonTemplateAutoStructA() {
+ return StructA{};
+}
+
+const auto TestNonTemplateConstAutoInt() {
+ return 0;
+}
+
+const auto TestNonTemplateConstAutoVoid() {
+ return;
+}
+
+const auto TestNonTemplateConstAutoStructA() {
+ return StructA{};
+}
+
+void test_nontemplate_auto() {
+ TestNonTemplateAutoInt();
+ // CHECK: call {{.*}} @"?TestNonTemplateAutoInt@@YA@XZ"
+
+ TestNonTemplateAutoVoid();
+ // CHECK: call {{.*}} @"?TestNonTemplateAutoVoid@@YA@XZ"
+
+ TestNonTemplateAutoStructA();
+ // CHECK: call {{.*}} @"?TestNonTemplateAutoStructA@@YA@XZ"
+
+ TestNonTemplateConstAutoInt();
+ // CHECK: call {{.*}} @"?TestNonTemplateConstAutoInt@@YA@XZ"
+
+ TestNonTemplateConstAutoVoid();
+ // CHECK: call {{.*}} @"?TestNonTemplateConstAutoVoid@@YA@XZ"
+
+ TestNonTemplateConstAutoStructA();
+ // CHECK: call {{.*}} @"?TestNonTemplateConstAutoStructA@@YA@XZ"
+}
+
+decltype(auto) TestNonTemplateDecltypeAutoInt() {
+ return 0;
+}
+
+decltype(auto) TestNonTemplateDecltypeAutoVoid() {
+ return;
+}
+
+decltype(auto) TestNonTemplateDecltypeAutoStructA() {
+ return StructA{};
+}
+
+void test_nontemplate_decltypeauto() {
+ TestNonTemplateDecltypeAutoInt();
+ // CHECK: call {{.*}} @"?TestNonTemplateDecltypeAutoInt@@YA@XZ"
+
+ TestNonTemplateDecltypeAutoVoid();
+ // CHECK: call {{.*}} @"?TestNonTemplateDecltypeAutoVoid@@YA@XZ"
+
+ TestNonTemplateDecltypeAutoStructA();
+ // CHECK: call {{.*}} @"?TestNonTemplateDecltypeAutoStructA@@YA@XZ"
+}
+
+struct StructB {
+ int x;
+};
+
+template<class T>
+auto StructB::* AutoMemberDataPtrT(T x) { return x; }
+
+template<class T>
+const auto StructB::* AutoConstMemberDataPtrT(T x) { return x; }
+
+void test_template_auto_member_data_ptr() {
+ AutoMemberDataPtrT(&StructB::x);
+ // CHECK: call {{.*}} @"??$AutoMemberDataPtrT@PEQStructB@@H@@YAPEQStructB@@_PPEQ0@H@Z"
+
+ AutoConstMemberDataPtrT(&StructB::x);
+ // CHECK: call {{.*}} @"??$AutoConstMemberDataPtrT@PEQStructB@@H@@YAPERStructB@@_PPEQ0@H@Z"
+}
+
+struct StructC {
+ void test() {}
+};
+
+struct StructD {
+ const int test() { return 0; }
+};
+
+template<class T>
+auto (StructC::*AutoMemberFuncPtrT(T x))() { return x; }
+
+template<class T>
+const auto (StructD::*AutoConstMemberFuncPtrT(T x))() { return x; }
+
+void test_template_auto_member_func_ptr() {
+ AutoMemberFuncPtrT(&StructC::test);
+ // CHECK: call {{.*}} @"??$AutoMemberFuncPtrT@P8StructC@@EAAXXZ@@YAP8StructC@@EAA?A_PXZP80@EAAXXZ@Z"
+
+ AutoConstMemberFuncPtrT(&StructD::test);
+ // CHECK: call {{.*}} @"??$AutoConstMemberFuncPtrT@P8StructD@@EAA?BHXZ@@YAP8StructD@@EAA?B_PXZP80@EAA?BHXZ@Z"
+}
+
+template<class T>
+auto * __attribute__((address_space(1))) * AutoPtrAddressSpaceT() {
+ T * __attribute__((address_space(1))) * p = nullptr;
+ return p;
+}
+
+void test_template_auto_address_space_ptr() {
+ AutoPtrAddressSpaceT<int>();
+ // CHECK: call {{.*}} @"??$AutoPtrAddressSpaceT@H@@YA?A?<auto>@@XZ"
+}
+
+template<class T>
+auto&& AutoReferenceCollapseT(T& x) { return static_cast<T&>(x); }
+
+auto&& AutoReferenceCollapse(int& x) { return static_cast<int&>(x); }
+
+void test2() {
+ int x = 1;
+ auto&& rref0 = AutoReferenceCollapseT(x);
+ // CHECK: call {{.*}} @"??$AutoReferenceCollapseT@H@@YA$$QEA_PAEAH@Z"
+
+ auto&& rref1 = AutoReferenceCollapse(x);
+ // CHECK: call {{.*}} @"?AutoReferenceCollapse@@YA@AEAH@Z"
+}
diff --git a/clang/test/CodeGenCXX/mangle-ms-auto-templates-memptrs.cpp b/clang/test/CodeGenCXX/mangle-ms-auto-templates-memptrs.cpp
index 360ebdecc5562b..b7bc3953f0b438 100644
--- a/clang/test/CodeGenCXX/mangle-ms-auto-templates-memptrs.cpp
+++ b/clang/test/CodeGenCXX/mangle-ms-auto-templates-memptrs.cpp
@@ -34,15 +34,15 @@ void template_mangling() {
// BEFORE: call {{.*}} @"??0?$AutoParmTemplate@$I?f@V@@QEAAXXZA@A@@@QEAA@X...
[truncated]
|
MaxEW707
deleted the
mew/fix-placeholder-return-type-mangling-msvc-1920
branch
|
I have a fix for https://ci.chromium.org/ui/p/chromium/builders/ci/ToTWin. This was an accidental regression on my part, sorry. The fix is here #105999. |
dmpolukhin
pushed a commit
to dmpolukhin/llvm-project
that referenced
this pull request
Sep 2, 2024
… mangling for MSVC 1920+ / VS2019+ (llvm#104722) Reapply llvm#102848. The description in this PR will detail the changes from the reverted original PR above. For `auto&&` return types that can partake in reference collapsing we weren't properly handling that mangling that can arise. When collapsing occurs an inner reference is created with the collapsed reference type. If we return `int&` from such a function then an inner reference of `int&` is created within the `auto&&` return type. `getPointeeType` on a reference type goes through all inner references before returning the pointee type which ends up being a builtin type, `int`, which is unexpected. We can use `getPointeeTypeAsWritten` to get the `AutoType` as expected however for the instantiated template declaration reference collapsing already occurred on the return type. This means `auto&&` is turned into `auto&` in our example above. We end up mangling an lvalue reference type. This is unintended as MSVC mangles on the declaration of the return type, `auto&&` in this case, which is treated as an rvalue reference. ``` template<class T> auto&& AutoReferenceCollapseT(int& x) { return static_cast<int&>(x); } void test() { int x = 1; auto&& rref = AutoReferenceCollapseT<void>(x); // "??$AutoReferenceCollapseT@X@@ya$$QEA_PAEAH@Z" // Mangled as an rvalue reference to auto } ``` If we are mangling a template with a placeholder return type we want to get the first template declaration and use its return type to do the mangling of any instantiations. This fixes the bug reported in the original PR that caused the revert with libcxx `std::variant`. I also tested locally with libcxx and the following test code which fails in the original PR but now works in this PR. ``` #include <variant> void test() { std::variant<int> v{ 1 }; int& r = std::get<0>(v); (void)r; } ```
dmpolukhin
pushed a commit
to dmpolukhin/llvm-project
that referenced
this pull request
Sep 2, 2024
…mbdas (llvm#105999) Fixes llvm#104722. Missed handling `decltype(auto)` trailing return types for lambdas. This was a mistake and regression on my part with my PR, llvm#104722. Added some missing unit tests to test for the various placeholder trailing return types in lambdas.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Reapply #102848.
The description in this PR will detail the changes from the reverted original PR above.
For
auto&&return types that can partake in reference collapsing we weren't properly handling that mangling that can arise.When collapsing occurs an inner reference is created with the collapsed reference type. If we return
int&from such a function then an inner reference ofint&is created within theauto&&return type.getPointeeTypeon a reference type goes through all inner references before returning the pointee type which ends up being a builtin type,int, which is unexpected.We can use
getPointeeTypeAsWrittento get theAutoTypeas expected however for the instantiated template declaration reference collapsing already occurred on the return type. This meansauto&&is turned intoauto&in our example above.We end up mangling an lvalue reference type.
This is unintended as MSVC mangles on the declaration of the return type,
auto&&in this case, which is treated as an rvalue reference.If we are mangling a template with a placeholder return type we want to get the first template declaration and use its return type to do the mangling of any instantiations.
This fixes the bug reported in the original PR that caused the revert with libcxx
std::variant.I also tested locally with libcxx and the following test code which fails in the original PR but now works in this PR.