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/inalloca-overaligned.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

112 lines
3.8 KiB
C++
Raw Normal View History

Re-land "[MS] Overhaul how clang passes overaligned args on x86_32" This brings back 2af74e27ed7d0832cbdde9cb969aaca7a42e99f9 and reverts eaabaf7e04fe98990a8177a3e053346395efde1c. The changes were correct, the code that was broken contained an ODR violation that assumed that these types are passed equivalently: struct alignas(uint64_t) Wrapper { uint64_t P }; void f(uint64_t p); void f(Wrapper p); MSVC does not pass them the same way, and so clang-cl should not pass them the same way either.
2020-02-12 08:03:26 +08:00
// RUN: %clang_cc1 -fms-extensions -w -triple i386-pc-win32 -emit-llvm -o - %s | FileCheck %s
// PR44395
// MSVC passes overaligned types indirectly since MSVC 2015. Make sure that
// works with inalloca.
struct NonTrivial {
NonTrivial();
NonTrivial(const NonTrivial &o);
int x;
};
struct __declspec(align(64)) OverAligned {
OverAligned();
int buf[16];
};
[MS] On x86_32, pass overaligned, non-copyable arguments indirectly This updates the C++ ABI argument classification code to use the logic from D72114, fixing an ABI incompatibility with MSVC. Part of PR44395. Differential Revision: https://reviews.llvm.org/D87923
2020-09-19 02:22:15 +08:00
struct __declspec(align(8)) Both {
Both();
Both(const Both &o);
int x, y;
};
Re-land "[MS] Overhaul how clang passes overaligned args on x86_32" This brings back 2af74e27ed7d0832cbdde9cb969aaca7a42e99f9 and reverts eaabaf7e04fe98990a8177a3e053346395efde1c. The changes were correct, the code that was broken contained an ODR violation that assumed that these types are passed equivalently: struct alignas(uint64_t) Wrapper { uint64_t P }; void f(uint64_t p); void f(Wrapper p); MSVC does not pass them the same way, and so clang-cl should not pass them the same way either.
2020-02-12 08:03:26 +08:00
extern int gvi32;
int receive_inalloca_overaligned(NonTrivial nt, OverAligned o) {
return nt.x + o.buf[0];
}
// CHECK-LABEL: define dso_local i32 @"?receive_inalloca_overaligned@@Y{{.*}}"
// CHECK-SAME: (<{ %struct.NonTrivial, %struct.OverAligned* }>* inalloca %0)
int pass_inalloca_overaligned() {
gvi32 = receive_inalloca_overaligned(NonTrivial(), OverAligned());
return gvi32;
}
// CHECK-LABEL: define dso_local i32 @"?pass_inalloca_overaligned@@Y{{.*}}"
// CHECK: [[TMP:%[^ ]*]] = alloca %struct.OverAligned, align 64
// CHECK: call i8* @llvm.stacksave()
// CHECK: alloca inalloca <{ %struct.NonTrivial, %struct.OverAligned* }>
// Construct OverAligned into TMP.
[CodeGen] Apply 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments. * Adds 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments * Gates 'nonnull' on -f(no-)delete-null-pointer-checks * Introduces this-nonnull.cpp and microsoft-abi-this-nullable.cpp tests to explicitly test the behavior of this change * Refactors hundreds of over-constrained clang tests to permit these attributes, where needed * Updates Clang12 patch notes mentioning this change Reviewed-by: rsmith, jdoerfert Differential Revision: https://reviews.llvm.org/D17993
2020-11-17 07:04:55 +08:00
// CHECK: call x86_thiscallcc %struct.OverAligned* @"??0OverAligned@@QAE@XZ"(%struct.OverAligned* {{[^,]*}} [[TMP]])
Re-land "[MS] Overhaul how clang passes overaligned args on x86_32" This brings back 2af74e27ed7d0832cbdde9cb969aaca7a42e99f9 and reverts eaabaf7e04fe98990a8177a3e053346395efde1c. The changes were correct, the code that was broken contained an ODR violation that assumed that these types are passed equivalently: struct alignas(uint64_t) Wrapper { uint64_t P }; void f(uint64_t p); void f(Wrapper p); MSVC does not pass them the same way, and so clang-cl should not pass them the same way either.
2020-02-12 08:03:26 +08:00
// Construct NonTrivial into the GEP.
// CHECK: [[GEP:%[^ ]*]] = getelementptr inbounds <{ %struct.NonTrivial, %struct.OverAligned* }>, <{ %struct.NonTrivial, %struct.OverAligned* }>* %{{.*}}, i32 0, i32 0
[CodeGen] Apply 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments. * Adds 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments * Gates 'nonnull' on -f(no-)delete-null-pointer-checks * Introduces this-nonnull.cpp and microsoft-abi-this-nullable.cpp tests to explicitly test the behavior of this change * Refactors hundreds of over-constrained clang tests to permit these attributes, where needed * Updates Clang12 patch notes mentioning this change Reviewed-by: rsmith, jdoerfert Differential Revision: https://reviews.llvm.org/D17993
2020-11-17 07:04:55 +08:00
// CHECK: call x86_thiscallcc %struct.NonTrivial* @"??0NonTrivial@@QAE@XZ"(%struct.NonTrivial* {{[^,]*}} [[GEP]])
Re-land "[MS] Overhaul how clang passes overaligned args on x86_32" This brings back 2af74e27ed7d0832cbdde9cb969aaca7a42e99f9 and reverts eaabaf7e04fe98990a8177a3e053346395efde1c. The changes were correct, the code that was broken contained an ODR violation that assumed that these types are passed equivalently: struct alignas(uint64_t) Wrapper { uint64_t P }; void f(uint64_t p); void f(Wrapper p); MSVC does not pass them the same way, and so clang-cl should not pass them the same way either.
2020-02-12 08:03:26 +08:00
// Store the address of an OverAligned temporary into the struct.
// CHECK: getelementptr inbounds <{ %struct.NonTrivial, %struct.OverAligned* }>, <{ %struct.NonTrivial, %struct.OverAligned* }>* %{{.*}}, i32 0, i32 1
// CHECK: store %struct.OverAligned* [[TMP]], %struct.OverAligned** %{{.*}}, align 4
// CHECK: call i32 @"?receive_inalloca_overaligned@@Y{{.*}}"(<{ %struct.NonTrivial, %struct.OverAligned* }>* inalloca %argmem)
[MS] On x86_32, pass overaligned, non-copyable arguments indirectly This updates the C++ ABI argument classification code to use the logic from D72114, fixing an ABI incompatibility with MSVC. Part of PR44395. Differential Revision: https://reviews.llvm.org/D87923
2020-09-19 02:22:15 +08:00
int receive_both(Both o) {
return o.x + o.y;
}
// CHECK-LABEL: define dso_local i32 @"?receive_both@@Y{{.*}}"
// CHECK-SAME: (%struct.Both* %o)
int pass_both() {
gvi32 = receive_both(Both());
return gvi32;
}
// CHECK-LABEL: define dso_local i32 @"?pass_both@@Y{{.*}}"
// CHECK: [[TMP:%[^ ]*]] = alloca %struct.Both, align 8
[CodeGen] Apply 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments. * Adds 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments * Gates 'nonnull' on -f(no-)delete-null-pointer-checks * Introduces this-nonnull.cpp and microsoft-abi-this-nullable.cpp tests to explicitly test the behavior of this change * Refactors hundreds of over-constrained clang tests to permit these attributes, where needed * Updates Clang12 patch notes mentioning this change Reviewed-by: rsmith, jdoerfert Differential Revision: https://reviews.llvm.org/D17993
2020-11-17 07:04:55 +08:00
// CHECK: call x86_thiscallcc %struct.Both* @"??0Both@@QAE@XZ"(%struct.Both* {{[^,]*}} [[TMP]])
[MS] On x86_32, pass overaligned, non-copyable arguments indirectly This updates the C++ ABI argument classification code to use the logic from D72114, fixing an ABI incompatibility with MSVC. Part of PR44395. Differential Revision: https://reviews.llvm.org/D87923
2020-09-19 02:22:15 +08:00
// CHECK: call i32 @"?receive_both@@Y{{.*}}"(%struct.Both* [[TMP]])
int receive_inalloca_both(NonTrivial nt, Both o) {
return nt.x + o.x + o.y;
}
// CHECK-LABEL: define dso_local i32 @"?receive_inalloca_both@@Y{{.*}}"
// CHECK-SAME: (<{ %struct.NonTrivial, %struct.Both* }>* inalloca %0)
int pass_inalloca_both() {
gvi32 = receive_inalloca_both(NonTrivial(), Both());
return gvi32;
}
// CHECK-LABEL: define dso_local i32 @"?pass_inalloca_both@@Y{{.*}}"
// CHECK: [[TMP:%[^ ]*]] = alloca %struct.Both, align 8
[CodeGen] Apply 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments. * Adds 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments * Gates 'nonnull' on -f(no-)delete-null-pointer-checks * Introduces this-nonnull.cpp and microsoft-abi-this-nullable.cpp tests to explicitly test the behavior of this change * Refactors hundreds of over-constrained clang tests to permit these attributes, where needed * Updates Clang12 patch notes mentioning this change Reviewed-by: rsmith, jdoerfert Differential Revision: https://reviews.llvm.org/D17993
2020-11-17 07:04:55 +08:00
// CHECK: call x86_thiscallcc %struct.Both* @"??0Both@@QAE@XZ"(%struct.Both* {{[^,]*}} [[TMP]])
[MS] On x86_32, pass overaligned, non-copyable arguments indirectly This updates the C++ ABI argument classification code to use the logic from D72114, fixing an ABI incompatibility with MSVC. Part of PR44395. Differential Revision: https://reviews.llvm.org/D87923
2020-09-19 02:22:15 +08:00
// CHECK: call i32 @"?receive_inalloca_both@@Y{{.*}}"(<{ %struct.NonTrivial, %struct.Both* }>* inalloca %argmem)
[MS] Simplify rules for passing C++ records Regardless of the target architecture, we should always use the C rules (RAA_Default) for records that "canBePassedInRegisters". Those are trivially copyable things, and things marked with [[trivial_abi]]. This should be NFC, although it changes where the final decision about x86_32 overaligned records is made. The current x86_32 C rules say that overaligned things are passed indirectly, so there is no functional difference.
2020-09-25 04:42:41 +08:00
// Here we have a type that is:
// - overaligned
// - not trivially copyable
// - can be "passed in registers" due to [[trivial_abi]]
// Clang should pass it directly.
struct [[trivial_abi]] alignas(8) MyPtr {
MyPtr();
MyPtr(const MyPtr &o);
~MyPtr();
int *ptr;
};
int receiveMyPtr(MyPtr o) { return *o.ptr; }
// CHECK-LABEL: define dso_local i32 @"?receiveMyPtr@@Y{{.*}}"
// CHECK-SAME: (%struct.MyPtr* %o)
int passMyPtr() { return receiveMyPtr(MyPtr()); }
// CHECK-LABEL: define dso_local i32 @"?passMyPtr@@Y{{.*}}"
// CHECK: [[TMP:%[^ ]*]] = alloca %struct.MyPtr, align 8
[CodeGen] Apply 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments. * Adds 'nonnull' and 'dereferenceable(N)' to 'this' pointer arguments * Gates 'nonnull' on -f(no-)delete-null-pointer-checks * Introduces this-nonnull.cpp and microsoft-abi-this-nullable.cpp tests to explicitly test the behavior of this change * Refactors hundreds of over-constrained clang tests to permit these attributes, where needed * Updates Clang12 patch notes mentioning this change Reviewed-by: rsmith, jdoerfert Differential Revision: https://reviews.llvm.org/D17993
2020-11-17 07:04:55 +08:00
// CHECK: call x86_thiscallcc %struct.MyPtr* @"??0MyPtr@@QAE@XZ"(%struct.MyPtr* {{[^,]*}} [[TMP]])
[MS] Simplify rules for passing C++ records Regardless of the target architecture, we should always use the C rules (RAA_Default) for records that "canBePassedInRegisters". Those are trivially copyable things, and things marked with [[trivial_abi]]. This should be NFC, although it changes where the final decision about x86_32 overaligned records is made. The current x86_32 C rules say that overaligned things are passed indirectly, so there is no functional difference.
2020-09-25 04:42:41 +08:00
// CHECK: call i32 @"?receiveMyPtr@@Y{{.*}}"(%struct.MyPtr* [[TMP]])