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

264 lines
6.5 KiB
C++
Raw Normal View History

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
// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
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;
};
// CHECK: define i32 @_ZN6ptrmem4testEPNS_1SE
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 { };
// CHECK: define void @_ZN6PR98011fEv
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
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 @_ZN6PR98015Test2C1Ev
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
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 @_ZN6PR98015Test3C1Ev
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; };
// CHECK: define i32 @_ZN8zeroinit4testEv()
int test() {
// CHECK: call void @llvm.memset.p0i8.i64
Revert r147271. This fixes PR11676. llvm-svn: 147362
2011-12-30 11:11:50 +08:00
// CHECK: getelementptr
// CHECK: ret i32
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();
};
// CHECK: define void @_ZN8zeroinit9testX0_X1Ev
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
};
// CHECK: define void @_ZN8zeroinit9testX0_X3Ev
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 };
};
// CHECK: define void @_ZN5test64testEv()
// CHECK: [[ARR:%.*]] = alloca [10 x [20 x [[A:%.*]]]],
// CHECK-NEXT: [[INNER:%.*]] = getelementptr inbounds [10 x [20 x [[A]]]]* [[ARR]], i64 0, i64 0
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [20 x [[A]]]* [[INNER]], i64 0, i64 0
// CHECK-NEXT: call void @_ZN5test61AC1Ei([[A]]* [[T0]], i32 5)
// CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [[A]]* [[T0]], i64 1
// CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[T0]], i64 20
// CHECK-NEXT: br label
// CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
// CHECK-NEXT: call void @_ZN5test61AC1Ev([[A]]* [[CUR]])
// CHECK-NEXT: [[NEXT]] = getelementptr inbounds [[A]]* [[CUR]], i64 1
// CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[NEXT]], [[END]]
// CHECK-NEXT: br i1
// CHECK: [[BEGIN:%.*]] = getelementptr inbounds [20 x [[A]]]* [[INNER]], i64 1
// CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [20 x [[A]]]* [[INNER]], i64 10
// 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.
// CHECK-NEXT: [[IBEGIN:%.*]] = getelementptr inbounds [20 x [[A]]]* [[CUR]], i32 0, i32 0
// CHECK-NEXT: [[IEND:%.*]] = getelementptr inbounds [[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:%.*]], {{%.*}} ]
// CHECK-NEXT: call void @_ZN5test61AC1Ev([[A]]* [[ICUR]])
// CHECK-NEXT: [[INEXT:%.*]] = getelementptr inbounds [[A]]* [[ICUR]], i64 1
// CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[INEXT]], [[IEND]]
// CHECK-NEXT: br i1 [[T0]],
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]] = getelementptr inbounds [20 x [[A]]]* [[CUR]], i64 1
// 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() {}
// CHECK: define void @_ZN7PR111241CC1Ev
// CHECK: call void @llvm.memset.p0i8.i64(i8* {{.*}}, i8 0, i64 12, i32 8, i1 false)
// 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() {}
// CHECK: define void @_ZN7PR111242C2C1Ev
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %{{.*}}, i8* {{.*}}, i64 16, i32 8, i1 false)
// CHECK-NEXT: call void @_ZN7PR111242B2C2Ev
}
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: define linkonce_odr void @_ZN8zeroinit2X3IiEC2Ev(%"struct.zeroinit::X3"* %this) unnamed_addr
// CHECK: call void @llvm.memset.p0i8.i64
// CHECK-NEXT: call void @_ZN8zeroinit2X2IiEC2Ev
// CHECK-NEXT: ret void