maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/mangle-ms-cxx14.cpp

58 lines
2.4 KiB
C++
Raw Normal View History

MS ABI: Implement the MSVC 2015 scheme for scope disambiguation consider C++ that looks like: inline int &f(bool b) { if (b) { static int i; return i; } static int i; return i; } Both 'i' variables must have distinct (and stable) names for linkage purposes. The MSVC 2013 ABI would number the variables using a count of the number of scopes that have been created. However, the final 'i' returns to a scope that has already been created leading to a mangling collision. MSVC 2015 fixes this by giving the second 'i' the name it would have if it were declared before the 'if'. However, this results in ABI breakage because the mangled name, in cases where there was no ambiguity, would now be different. We implement the new behavior and only enable it if we are targeting the MSVC 2015 ABI, otherwise the old behavior will be used. This fixes PR18131. llvm-svn: 232766
2015-03-20 05:54:30 +08:00
// RUN: %clang_cc1 -std=c++1y -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 -fms-compatibility-version=19.00 | FileCheck %s --check-prefix=CHECK --check-prefix=MSVC2015
// RUN: %clang_cc1 -std=c++1y -fms-extensions -emit-llvm %s -o - -triple=i386-pc-win32 -fms-compatibility-version=18.00 | FileCheck %s --check-prefix=CHECK --check-prefix=MSVC2013
MS ABI: Mangle variable templates properly We wouldn't recognize variable templates as being templates leading us to leave the template arguments off of the mangled name. This would allow two unrelated templates to map to the same mangled name. N.B. While MSVC doesn't support variable templates as of this date, this mangling is the most likely thing they will choose to use. Their demangler can successfully demangle our manglings with the template arguments shown. llvm-svn: 202789
2014-03-04 13:38:05 +08:00
template <typename> int x = 0;
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01??$x@X@@3HA"
MS ABI: Mangle variable templates properly We wouldn't recognize variable templates as being templates leading us to leave the template arguments off of the mangled name. This would allow two unrelated templates to map to the same mangled name. N.B. While MSVC doesn't support variable templates as of this date, this mangling is the most likely thing they will choose to use. Their demangler can successfully demangle our manglings with the template arguments shown. llvm-svn: 202789
2014-03-04 13:38:05 +08:00
template <> int x<void>;
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01??$x@H@@3HA"
MS ABI: Mangle variable templates properly We wouldn't recognize variable templates as being templates leading us to leave the template arguments off of the mangled name. This would allow two unrelated templates to map to the same mangled name. N.B. While MSVC doesn't support variable templates as of this date, this mangling is the most likely thing they will choose to use. Their demangler can successfully demangle our manglings with the template arguments shown. llvm-svn: 202789
2014-03-04 13:38:05 +08:00
template <> int x<int>;
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01?FunctionWithLocalType@@YA?A?<auto>@@XZ"
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
auto FunctionWithLocalType() {
struct LocalType {};
return LocalType{};
}
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01?ValueFromFunctionWithLocalType@@3ULocalType@?1??FunctionWithLocalType@@YA?A?<auto>@@XZ@A"
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
auto ValueFromFunctionWithLocalType = FunctionWithLocalType();
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01??R<lambda_0>@@QBE?A?<auto>@@XZ"
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
auto LambdaWithLocalType = [] {
struct LocalType {};
return LocalType{};
};
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01?ValueFromLambdaWithLocalType@@3ULocalType@?1???R<lambda_0>@@QBE?A?<auto>@@XZ@A"
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
auto ValueFromLambdaWithLocalType = LambdaWithLocalType();
template <typename T>
auto TemplateFuncionWithLocalLambda(T) {
auto LocalLambdaWithLocalType = []() {
struct LocalType {};
return LocalType{};
};
return LocalLambdaWithLocalType();
}
Re-land "MS ABI: lambda call operators are instance methods and should use thiscall" Update the test cases to pass when lambda call operators use thiscall. Update the lambda-to-block conversion operator to use the default free function calling convention instead of the call operator's convention. This reverts commit r233082 and re-instates r233023. llvm-svn: 233835
2015-04-02 04:22:13 +08:00
// MSVC2013-DAG: "\01?ValueFromTemplateFuncionWithLocalLambda@@3ULocalType@?2???R<lambda_1>@??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z@QBE?A?3@XZ@A"
// MSVC2013-DAG: "\01?ValueFromTemplateFuncionWithLocalLambda@@3ULocalType@?2???R<lambda_1>@??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z@QBE?A?3@XZ@A"
// MSVC2015-DAG: "\01?ValueFromTemplateFuncionWithLocalLambda@@3ULocalType@?1???R<lambda_1>@??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z@QBE?A?3@XZ@A"
// MSVC2015-DAG: "\01?ValueFromTemplateFuncionWithLocalLambda@@3ULocalType@?1???R<lambda_1>@??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z@QBE?A?3@XZ@A"
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
// CHECK-DAG: "\01??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z"
// CHECK-DAG: "\01??R<lambda_1>@??$TemplateFuncionWithLocalLambda@H@@YA?A?<auto>@@H@Z@QBE?A?1@XZ"
MS ABI: Support mangling of return-types deducing to local types The MS ABI forces us into catch-22 when it comes to functions which return types which are local: - A function is mangled with it's return type. - A type is mangled with it's surrounding context. Avoid this by mangling auto and decltype(autp) directly into the function's return type. Using this mangling has the double advantage of being compatible with the C++ standard without crashing the compiler. N.B. For the curious, the MSVC mangling leads to collisions amongst template functions and either crashes when faced with local types or is otherwise incapable of returning them. llvm-svn: 205282
2014-04-01 13:29:46 +08:00
auto ValueFromTemplateFuncionWithLocalLambda = TemplateFuncionWithLocalLambda(0);
[MS ABI] Correctly mangle nullptr member pointers for variable templates Variable templates behave the same as class templates with regard to nullptr memeber pointers. llvm-svn: 254439
2015-12-02 03:13:51 +08:00
struct S;
template <int S::*>
int WithPMD = 0;
template <> int WithPMD<nullptr>;
// CHECK-DAG: "\01??$WithPMD@$GA@A@?0@@3HA"
[MS ABI] Add variable templates to the NameBackReferences Only function template specializations are exempt from being added to the NameBackReferences. Redundant variable template specializations should be appropriately substituted. llvm-svn: 256623
2015-12-30 13:40:32 +08:00
template <const int *, const int *>
struct Foo {};
Foo<&x<int>, &x<int>> Zoo;
// CHECK-DAG: "\01?Zoo@@3U?$Foo@$1??$x@H@@3HA$1?1@3HA@@A"