maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGen/mangle-windows.c

69 lines
2.2 KiB
C
Raw Normal View History

Remove the -cxx-abi command-line flag. This makes the C++ ABI depend entirely on the target: MS ABI for -win32 triples, Itanium otherwise. It's no longer possible to do weird combinations. To be able to run a test with a specific ABI without constraining it to a specific triple, new substitutions are added to lit: %itanium_abi_triple and %ms_abi_triple can be used to get the current target triple adjusted to the desired ABI. For example, if the test suite is running with the i686-pc-win32 target, %itanium_abi_triple will expand to i686-pc-mingw32. Differential Revision: http://llvm-reviews.chandlerc.com/D2545 llvm-svn: 199250
2014-01-15 03:35:09 +08:00
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-mingw32 | FileCheck %s
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck %s --check-prefix=X64
// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-mingw32 | FileCheck %s --check-prefix=X64
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __stdcall f1(void) {}
// CHECK: define x86_stdcallcc void @"\01_f1@0"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f1(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f2(void) {}
// CHECK: define x86_fastcallcc void @"\01@f2@0"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f2(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __stdcall f3() {}
// CHECK: define x86_stdcallcc void @"\01_f3@0"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f3(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f4(char a) {}
// CHECK: define x86_fastcallcc void @"\01@f4@4"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f4(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f5(short a) {}
// CHECK: define x86_fastcallcc void @"\01@f5@4"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f5(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f6(int a) {}
// CHECK: define x86_fastcallcc void @"\01@f6@4"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f6(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f7(long a) {}
// CHECK: define x86_fastcallcc void @"\01@f7@4"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f7(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f8(long long a) {}
// CHECK: define x86_fastcallcc void @"\01@f8@8"
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f8(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void __fastcall f9(long long a, char b, char c, short d) {}
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// CHECK: define x86_fastcallcc void @"\01@f9@20"(i64 %a, i8 signext %b, i8 signext %c, i16 signext %d)
// X64: define void @f9(
On 32 bit windows, mangle stdcall and fastcall decls in clang. This removes the dependency on the llvm mangler doing it for us. In isolation, the benefit is that the testing of what mangling is applied is all in one place: (C, C++) X (Itanium, Microsoft) are all handled by clang. This also gives me hope that in the future the llvm mangler (and llvm-ar) will not depend on TargetMachine. llvm-svn: 192762
2013-10-16 09:40:34 +08:00
void f12(void) {}
// CHECK: define void @f12(
Implement IRGen for the x86 vectorcall convention The most complex aspect of the convention is the handling of homogeneous vector and floating point aggregates. Reuse the homogeneous aggregate classification code that we use on PPC64 and ARM for this. This convention also has a C mangling, and we apparently implement that in both Clang and LLVM. Reviewed By: majnemer Differential Revision: http://reviews.llvm.org/D6063 llvm-svn: 221006
2014-11-01 06:00:51 +08:00
// X64: define void @f12(
void __vectorcall v1(void) {}
// CHECK: define x86_vectorcallcc void @"\01v1@@0"(
// X64: define x86_vectorcallcc void @"\01v1@@0"(
void __vectorcall v2(char a) {}
// CHECK: define x86_vectorcallcc void @"\01v2@@4"(
// X64: define x86_vectorcallcc void @"\01v2@@8"(
void __vectorcall v3(short a) {}
// CHECK: define x86_vectorcallcc void @"\01v3@@4"(
// X64: define x86_vectorcallcc void @"\01v3@@8"(
void __vectorcall v4(int a) {}
// CHECK: define x86_vectorcallcc void @"\01v4@@4"(
// X64: define x86_vectorcallcc void @"\01v4@@8"(
void __vectorcall v5(long long a) {}
// CHECK: define x86_vectorcallcc void @"\01v5@@8"(
// X64: define x86_vectorcallcc void @"\01v5@@8"(
void __vectorcall v6(char a, char b) {}
// CHECK: define x86_vectorcallcc void @"\01v6@@8"(
// X64: define x86_vectorcallcc void @"\01v6@@16"(