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/value-init.cpp

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

342 lines
8.9 KiB
C++
Raw Normal View History

[OpaquePtrs][Clang] Add -no-opaque-pointers to tests (NFC) This adds -no-opaque-pointers to clang tests whose output will change when opaque pointers are enabled by default. This is intended to be part of the migration approach described in https://discourse.llvm.org/t/enabling-opaque-pointers-by-default/61322/9. The patch has been produced by replacing %clang_cc1 with %clang_cc1 -no-opaque-pointers for tests that fail with opaque pointers enabled. Worth noting that this doesn't cover all tests, there's a remaining ~40 tests not using %clang_cc1 that will need a followup change. Differential Revision: https://reviews.llvm.org/D123115
2022-04-07 18:03:55 +08:00
// RUN: %clang_cc1 -no-opaque-pointers -std=c++98 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CXX98
// RUN: %clang_cc1 -no-opaque-pointers -std=c++17 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CXX17
When value-initializing a class with no user-defined constructors but with a non-trivial default constructor, zero-initialize the storage and then call the default constructor. Fixes PR5800. llvm-svn: 91548
2009-12-17 02:50:27 +08:00
struct A {
virtual ~A();
};
struct B : A { };
struct C {
int i;
B b;
};
// CHECK: _Z15test_value_initv
void test_value_init() {
// This value initialization requires zero initialization of the 'B'
// subobject followed by a call to its constructor.
// PR5800
// CHECK: store i32 17
Reapply patch for adding support for address spaces and added a isVolatile field to memcpy, memmove, and memset. llvm-svn: 100305
2010-04-04 11:10:52 +08:00
// CHECK: call void @llvm.memset.p0i8.i64
Fix test case to unbreak testing llvm-svn: 91551
2009-12-17 03:18:40 +08:00
// CHECK: call void @_ZN1BC1Ev
When value-initializing a class with no user-defined constructors but with a non-trivial default constructor, zero-initialize the storage and then call the default constructor. Fixes PR5800. llvm-svn: 91548
2009-12-17 02:50:27 +08:00
C c = { 17 } ;
Fix test case to unbreak testing llvm-svn: 91551
2009-12-17 03:18:40 +08:00
// CHECK: call void @_ZN1CD1Ev
When value-initializing a class with no user-defined constructors but with a non-trivial default constructor, zero-initialize the storage and then call the default constructor. Fixes PR5800. llvm-svn: 91548
2009-12-17 02:50:27 +08:00
}
When explicitly building a temporary object (CXXTemporaryObjectExpr), keep track of whether we need to zero-initialize storage prior to calling its constructor. Previously, we were only tracking this when implicitly constructing the object (a CXXConstructExpr). Fixes Boost's value-initialization tests, which means that the Boost.Config library now passes all of its tests. llvm-svn: 102461
2010-04-28 04:36:09 +08:00
enum enum_type { negative_number = -1, magic_number = 42 };
class enum_holder
{
enum_type m_enum;
public:
enum_holder() : m_enum(magic_number) { }
};
struct enum_holder_and_int
{
enum_holder e;
int i;
};
// CHECK: _Z24test_enum_holder_and_intv()
void test_enum_holder_and_int() {
// CHECK: alloca
// CHECK-NEXT: bitcast
// CHECK-NEXT: call void @llvm.memset
// CHECK-NEXT: call void @_ZN19enum_holder_and_intC1Ev
enum_holder_and_int();
// CHECK-NEXT: ret void
}
Inline a special case of EmitAggregateCopy into EmitNullInitialization to avoid the awesome-but-wrong-in-this-case assertion in the canon EAC. Fixes PR7834. Also fix a subtle address-space bug in the memset path. llvm-svn: 110511
2010-08-07 16:21:30 +08:00
// PR7834: don't crash.
namespace test1 {
struct A {
int A::*f;
A();
A(const A&);
A &operator=(const A &);
};
struct B {
A base;
};
void foo() {
B();
}
}
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
namespace ptrmem {
struct S {
int mem1;
int S::*mem2;
};
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} i32 @_ZN6ptrmem4testEPNS_1SE
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
int test(S *s) {
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
// CHECK: getelementptr
// CHECK: ret
return s->*S().mem2;
}
}
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
namespace PR9801 {
struct Test {
Test() : i(10) {}
Test(int i) : i(i) {}
int i;
private:
int j;
};
struct Test2 {
Test t;
};
struct Test3 : public Test { };
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN6PR98011fEv
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
void f() {
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK-NOT: call void @llvm.memset.p0i8.i64
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
// CHECK: call void @_ZN6PR98014TestC1Ei
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK-NOT: call void @llvm.memset.p0i8.i64
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
// CHECK: call void @_ZN6PR98014TestC1Ev
Test partial[3] = { 1 };
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK-NOT: call void @llvm.memset.p0i8.i64
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
// CHECK: call void @_ZN6PR98014TestC1Ev
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NOT: call void @_ZN6PR98014TestC1Ev
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
Test empty[3] = {};
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK: call void @llvm.memset.p0i8.i64
// CHECK-NOT: call void @llvm.memset.p0i8.i64
Fix crash emitting transparent list initializer for a large aggregate. llvm-svn: 334565
2018-06-13 10:06:28 +08:00
// CHECK-CXX98: call void @_ZN6PR98015Test2C1Ev
// CHECK-CXX17: call void @_ZN6PR98014TestC1Ev
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NOT: call void @_ZN6PR98015Test2C1Ev
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
Test2 empty2[3] = {};
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK: call void @llvm.memset.p0i8.i64
// CHECK-NOT: call void @llvm.memset.p0i8.i64
Fix crash emitting transparent list initializer for a large aggregate. llvm-svn: 334565
2018-06-13 10:06:28 +08:00
// CHECK-CXX98: call void @_ZN6PR98015Test3C1Ev
// CHECK-CXX17: call void @_ZN6PR98014TestC2Ev
Cut down unnecessary zero'ing when value-initializing arrays of C++ objects. -C++ objects with user-declared constructor don't need zero'ing. -We can zero-initialize arrays of C++ objects in "bulk" now, in which case don't zero-initialize each object again. llvm-svn: 130453
2011-04-29 06:57:55 +08:00
// CHECK-NOT: call void @llvm.memset.p0i8.i64
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NOT: call void @_ZN6PR98015Test3C1Ev
When value-initializing the elements of an array not not included in the initializer make sure that a non-trivial C++ constructor gets called. Fixes rdar://9347552 & http://llvm.org/PR9801 llvm-svn: 130421
2011-04-29 02:53:58 +08:00
Test3 empty3[3] = {};
}
}
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
namespace zeroinit {
struct S { int i; };
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} i32 @_ZN8zeroinit4testEv()
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
int test() {
// CHECK: call void @llvm.memset.p0i8.i64
Unrevert r147271, reverted in r147361. Also temporarily remove the assumption from IR gen that we can emit IR for every constant we can fold, since it isn't currently true in C++11, to fix PR11676. Original comment from r147271: constexpr: perform zero-initialization prior to / instead of performing a constructor call when appropriate. Thanks to Eli for spotting this. llvm-svn: 147384
2011-12-31 05:15:51 +08:00
// CHECK: ret i32 0
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
return S().i;
}
When performing value-initialization for a class with a non-trivial, implicitly-defined default constructor, zero-initialize the memory before calling the default constructor. Previously, we would only zero-initialize in the case of a trivial default constructor. Also, simplify the hideous logic that determines when we have a trivial default constructor and, therefore, don't need to emit any call at all. llvm-svn: 111779
2010-08-23 00:15:35 +08:00
struct X0 {
X0() { }
int x;
};
struct X1 : X0 {
int x1;
void f();
};
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN8zeroinit9testX0_X1Ev
When performing value-initialization for a class with a non-trivial, implicitly-defined default constructor, zero-initialize the memory before calling the default constructor. Previously, we would only zero-initialize in the case of a trivial default constructor. Also, simplify the hideous logic that determines when we have a trivial default constructor and, therefore, don't need to emit any call at all. llvm-svn: 111779
2010-08-23 00:15:35 +08:00
void testX0_X1() {
// CHECK: call void @llvm.memset.p0i8.i64
// CHECK-NEXT: call void @_ZN8zeroinit2X1C1Ev
// CHECK-NEXT: call void @_ZN8zeroinit2X11fEv
X1().f();
}
Preserve the zero-initialization and construction-kind settings when instantiating CXXConstructExpr expressions. llvm-svn: 111780
2010-08-23 01:20:18 +08:00
template<typename>
struct X2 : X0 {
int x2;
void f();
};
template<typename>
struct X3 : X2<int> {
X3() : X2<int>() { }
Cleanup tests, no functionality change. llvm-svn: 129672
2011-04-18 05:49:47 +08:00
int i;
Preserve the zero-initialization and construction-kind settings when instantiating CXXConstructExpr expressions. llvm-svn: 111780
2010-08-23 01:20:18 +08:00
};
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN8zeroinit9testX0_X3Ev
Preserve the zero-initialization and construction-kind settings when instantiating CXXConstructExpr expressions. llvm-svn: 111780
2010-08-23 01:20:18 +08:00
void testX0_X3() {
// CHECK-NOT: call void @llvm.memset
// CHECK: call void @_ZN8zeroinit2X3IiEC1Ev
// CHECK: call void @_ZN8zeroinit2X2IiE1fEv
// CHECK-NEXT: ret void
X3<int>().f();
}
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// More checks at EOF
Fix a major regression with value-initialization of class types with trivial default constructors. We're weren't zero-initializing them, which manifested as <rdar://problem/8320532> (a regression in the GCC test suite) and is likely to have caused significant other breakage. llvm-svn: 111650
2010-08-21 00:57:37 +08:00
}
fix PR8726 by teaching the aggregate init optimization code to handle structs with references in them correctly. llvm-svn: 120722
2010-12-03 02:29:00 +08:00
namespace PR8726 {
class C;
struct S {
const C &c1;
int i;
const C &c2;
};
void f(const C& c) {
S s = {c, 42, c};
}
add missing newlines at end of file. llvm-svn: 122309
2010-12-21 10:36:58 +08:00
}
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// rdar://problem/9355931
namespace test6 {
struct A { A(); A(int); };
void test() {
A arr[10][20] = { 5 };
};
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN5test64testEv()
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK: [[ARR:%.*]] = alloca [10 x [20 x [[A:%.*]]]],
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[INNER:%.*]] = getelementptr inbounds [10 x [20 x [[A]]]], [10 x [20 x [[A]]]]* [[ARR]], i64 0, i64 0
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 0, i64 0
[Clang/Test]: Rename enable_noundef_analysis to disable-noundef-analysis and turn it off by default Turning on `enable_noundef_analysis` flag allows better codegen by removing freeze instructions. I modified clang by renaming `enable_noundef_analysis` flag to `disable-noundef-analysis` and turning it off by default. Test updates are made as a separate patch: D108453 Reviewed By: eugenis Differential Revision: https://reviews.llvm.org/D105169
2022-01-16 17:53:11 +08:00
// CHECK-NEXT: call void @_ZN5test61AC1Ei([[A]]* {{[^,]*}} [[T0]], i32 noundef 5)
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i64 1
// CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i64 20
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: br label
// CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
[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-NEXT: call void @_ZN5test61AC1Ev([[A]]* {{[^,]*}} [[CUR]])
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[NEXT]] = getelementptr inbounds [[A]], [[A]]* [[CUR]], i64 1
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[NEXT]], [[END]]
// CHECK-NEXT: br i1
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK: [[BEGIN:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 1
// CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 10
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: br label
// CHECK: [[CUR:%.*]] = phi [20 x [[A]]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
Convert the standard default-construction loops to use phis and partial destruction. llvm-svn: 135033
2011-07-13 14:10:41 +08:00
// Inner loop.
Fix crash emitting transparent list initializer for a large aggregate. llvm-svn: 334565
2018-06-13 10:06:28 +08:00
// CHECK-NEXT: [[IBEGIN:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[CUR]], i{{32|64}} 0, i{{32|64}} 0
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[IEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[IBEGIN]], i64 20
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: br label
Convert the standard default-construction loops to use phis and partial destruction. llvm-svn: 135033
2011-07-13 14:10:41 +08:00
// CHECK: [[ICUR:%.*]] = phi [[A]]* [ [[IBEGIN]], {{%.*}} ], [ [[INEXT:%.*]], {{%.*}} ]
[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-NEXT: call void @_ZN5test61AC1Ev([[A]]* {{[^,]*}} [[ICUR]])
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[INEXT:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ICUR]], i64 1
Convert the standard default-construction loops to use phis and partial destruction. llvm-svn: 135033
2011-07-13 14:10:41 +08:00
// CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[INEXT]], [[IEND]]
// CHECK-NEXT: br i1 [[T0]],
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK: [[NEXT]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[CUR]], i64 1
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK-NEXT: [[T0:%.*]] = icmp eq [20 x [[A]]]* [[NEXT]], [[END]]
// CHECK-NEXT: br i1 [[T0]]
// CHECK: ret void
}
PR11124: Don't overwrite memory outside of a base class when performing zero-initialization before running its constructor. llvm-svn: 141933
2011-10-14 10:27:24 +08:00
namespace PR11124 {
// Make sure C::C doesn't overwrite parts of A while it is zero-initializing B
struct A { int a; A(); A(int); };
struct B : virtual A { int b; };
struct C : B { C(); };
C::C() : A(3), B() {}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN7PR111241CC1Ev
Change memcpy/memove/memset to have dest and source alignment attributes (Step 1). Summary: Upstream LLVM is changing the the prototypes of the @llvm.memcpy/memmove/memset intrinsics. This change updates the Clang tests for this change. The @llvm.memcpy/memmove/memset intrinsics currently have an explicit argument which is required to be a constant integer. It represents the alignment of the dest (and source), and so must be the minimum of the actual alignment of the two. This change removes the alignment argument in favour of placing the alignment attribute on the source and destination pointers of the memory intrinsic call. For example, code which used to read: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 100, i32 4, i1 false) will now read call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %dest, i8* align 4 %src, i32 100, i1 false) At this time the source and destination alignments must be the same (Step 1). Step 2 of the change, to be landed shortly, will relax that contraint and allow the source and destination to have different alignments. llvm-svn: 322964
2018-01-20 01:12:54 +08:00
// CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 {{.*}}, i8 0, i64 12, i1 false)
PR11124: Don't overwrite memory outside of a base class when performing zero-initialization before running its constructor. llvm-svn: 141933
2011-10-14 10:27:24 +08:00
// CHECK-NEXT: call void @_ZN7PR111241BC2Ev
// Make sure C::C doesn't overwrite parts of A while it is zero-initializing B
struct B2 : virtual A { int B::*b; };
struct C2 : B2 { C2(); };
C2::C2() : A(3), B2() {}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_ZN7PR111242C2C1Ev
Change memcpy/memove/memset to have dest and source alignment attributes (Step 1). Summary: Upstream LLVM is changing the the prototypes of the @llvm.memcpy/memmove/memset intrinsics. This change updates the Clang tests for this change. The @llvm.memcpy/memmove/memset intrinsics currently have an explicit argument which is required to be a constant integer. It represents the alignment of the dest (and source), and so must be the minimum of the actual alignment of the two. This change removes the alignment argument in favour of placing the alignment attribute on the source and destination pointers of the memory intrinsic call. For example, code which used to read: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 100, i32 4, i1 false) will now read call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %dest, i8* align 4 %src, i32 100, i1 false) At this time the source and destination alignments must be the same (Step 1). Step 2 of the change, to be landed shortly, will relax that contraint and allow the source and destination to have different alignments. llvm-svn: 322964
2018-01-20 01:12:54 +08:00
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %{{.*}}, i8* align 8 {{.*}}, i64 16, i1 false)
PR11124: Don't overwrite memory outside of a base class when performing zero-initialization before running its constructor. llvm-svn: 141933
2011-10-14 10:27:24 +08:00
// CHECK-NEXT: call void @_ZN7PR111242B2C2Ev
}
Reinstate r170806, reverted in r170835, with a fix use i1 instead of i8 for a value-initialized bool! llvm-svn: 170837
2012-12-21 11:17:28 +08:00
// Ensure we produce an i1 here, and don't assert.
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_Z9r170806_bv(
[Clang/Test]: Rename enable_noundef_analysis to disable-noundef-analysis and turn it off by default Turning on `enable_noundef_analysis` flag allows better codegen by removing freeze instructions. I modified clang by renaming `enable_noundef_analysis` flag to `disable-noundef-analysis` and turning it off by default. Test updates are made as a separate patch: D108453 Reviewed By: eugenis Differential Revision: https://reviews.llvm.org/D105169
2022-01-16 17:53:11 +08:00
// CHECK: call void @_Z9r170806_ab(i1 noundef zeroext false)
Reinstate r170806, reverted in r170835, with a fix use i1 instead of i8 for a value-initialized bool! llvm-svn: 170837
2012-12-21 11:17:28 +08:00
void r170806_a(bool b = bool());
void r170806_b() { r170806_a(); }
PR20256: don't accidentally instantiate non-dependent default-initialization as value-initialization. llvm-svn: 212764
2014-07-11 04:53:43 +08:00
namespace PR20256 {
struct data { int i; };
template<typename T = int>
data g() {
data d; // not value-init
return d;
}
template data g();
// CHECK-LABEL: define {{.*}} @_ZN7PR202561gIiEENS_4dataEv(
// CHECK-NOT: store
// CHECK-NOT: memset
// CHECK: }
template<typename ...T>
data h(T ...t) {
data d(t...); // value-init
return d;
}
template data h();
// CHECK-LABEL: define {{.*}} @_ZN7PR202561hIJEEENS_4dataEDpT_(
// CHECK: call void @llvm.memset
// CHECK: }
template<typename T = int>
data j() {
data d = {}; // value-init
return d;
}
template data j();
// CHECK-LABEL: define {{.*}} @_ZN7PR202561jIiEENS_4dataEv(
// CHECK: call void @llvm.memset
// CHECK: }
data f() {
data d; // not value-init
return d;
}
// CHECK-LABEL: define {{.*}} @_ZN7PR202561fEv(
// CHECK-NOT: store
// CHECK-NOT: memset
// CHECK: }
data i() {
data d = {}; // value-init
return d;
}
// CHECK-LABEL: define {{.*}} @_ZN7PR202561iEv(
// CHECK: call void @llvm.memset
// CHECK: }
}
Fix defaulted-functions-in-C++98 extension to give the functions the same effect they would have in C++11. In particular, they do not prevent value-initialization from performing zero-initialization, nor do they prevent a struct from being an aggregate. llvm-svn: 290229
2016-12-21 09:57:02 +08:00
// CHECK-LABEL: define {{.*}}@_Z20explicitly_defaultedv
int explicitly_defaulted() {
struct A { A() = default; int n; };
// CHECK: call void @llvm.memset
A a = A();
return a.n;
} // CHECK-LABEL: }
[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-LABEL: define linkonce_odr void @_ZN8zeroinit2X3IiEC2Ev(%"struct.zeroinit::X3"* {{[^,]*}} %this) unnamed_addr
A number of array-related IR-gen cleanups. - Emit default-initialization of arrays that were partially initialized with initializer lists with a loop, rather than emitting the default initializer N times; - support destroying VLAs of non-trivial type, although this is not yet exposed to users; and - support the partial destruction of arrays initialized with initializer lists when an initializer throws an exception. llvm-svn: 134784
2011-07-09 09:37:26 +08:00
// CHECK: call void @llvm.memset.p0i8.i64
// CHECK-NEXT: call void @_ZN8zeroinit2X2IiEC2Ev
// CHECK-NEXT: ret void
Fix crash emitting transparent list initializer for a large aggregate. llvm-svn: 334565
2018-06-13 10:06:28 +08:00
#if __cplusplus >= 201103L
namespace transparent_init_list {
struct optional_assign_base {};
struct optional_data_dtor_base { char dummy_[24]; };
struct optional : optional_data_dtor_base, optional_assign_base {};
optional f(optional a) { return {optional(a)}; }
}
#endif