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

263 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
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();
};
// 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