1 // RUN: %clang_cc1 -std=c++98 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CXX98
2 // RUN: %clang_cc1 -std=c++17 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CXX17
3
4 struct A {
5 virtual ~A();
6 };
7
8 struct B : A { };
9
10 struct C {
11 int i;
12 B b;
13 };
14
15 // CHECK: _Z15test_value_initv
test_value_init()16 void test_value_init() {
17 // This value initialization requires zero initialization of the 'B'
18 // subobject followed by a call to its constructor.
19 // PR5800
20
21 // CHECK: store i32 17
22 // CHECK: call void @llvm.memset.p0i8.i64
23 // CHECK: call void @_ZN1BC1Ev
24 C c = { 17 } ;
25 // CHECK: call void @_ZN1CD1Ev
26 }
27
28 enum enum_type { negative_number = -1, magic_number = 42 };
29
30 class enum_holder
31 {
32 enum_type m_enum;
33
34 public:
enum_holder()35 enum_holder() : m_enum(magic_number) { }
36 };
37
38 struct enum_holder_and_int
39 {
40 enum_holder e;
41 int i;
42 };
43
44 // CHECK: _Z24test_enum_holder_and_intv()
test_enum_holder_and_int()45 void test_enum_holder_and_int() {
46 // CHECK: alloca
47 // CHECK-NEXT: bitcast
48 // CHECK-NEXT: call void @llvm.memset
49 // CHECK-NEXT: call void @_ZN19enum_holder_and_intC1Ev
50 enum_holder_and_int();
51 // CHECK-NEXT: ret void
52 }
53
54 // PR7834: don't crash.
55 namespace test1 {
56 struct A {
57 int A::*f;
58 A();
59 A(const A&);
60 A &operator=(const A &);
61 };
62
63 struct B {
64 A base;
65 };
66
foo()67 void foo() {
68 B();
69 }
70 }
71
72 namespace ptrmem {
73 struct S {
74 int mem1;
75 int S::*mem2;
76 };
77
78 // CHECK-LABEL: define{{.*}} i32 @_ZN6ptrmem4testEPNS_1SE
test(S * s)79 int test(S *s) {
80 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
81 // CHECK: getelementptr
82 // CHECK: ret
83 return s->*S().mem2;
84 }
85 }
86
87 namespace PR9801 {
88
89 struct Test {
TestPR9801::Test90 Test() : i(10) {}
TestPR9801::Test91 Test(int i) : i(i) {}
92 int i;
93 private:
94 int j;
95 };
96
97 struct Test2 {
98 Test t;
99 };
100
101 struct Test3 : public Test { };
102
103 // CHECK-LABEL: define{{.*}} void @_ZN6PR98011fEv
f()104 void f() {
105 // CHECK-NOT: call void @llvm.memset.p0i8.i64
106 // CHECK: call void @_ZN6PR98014TestC1Ei
107 // CHECK-NOT: call void @llvm.memset.p0i8.i64
108 // CHECK: call void @_ZN6PR98014TestC1Ev
109 Test partial[3] = { 1 };
110
111 // CHECK-NOT: call void @llvm.memset.p0i8.i64
112 // CHECK: call void @_ZN6PR98014TestC1Ev
113 // CHECK-NOT: call void @_ZN6PR98014TestC1Ev
114 Test empty[3] = {};
115
116 // CHECK: call void @llvm.memset.p0i8.i64
117 // CHECK-NOT: call void @llvm.memset.p0i8.i64
118 // CHECK-CXX98: call void @_ZN6PR98015Test2C1Ev
119 // CHECK-CXX17: call void @_ZN6PR98014TestC1Ev
120 // CHECK-NOT: call void @_ZN6PR98015Test2C1Ev
121 Test2 empty2[3] = {};
122
123 // CHECK: call void @llvm.memset.p0i8.i64
124 // CHECK-NOT: call void @llvm.memset.p0i8.i64
125 // CHECK-CXX98: call void @_ZN6PR98015Test3C1Ev
126 // CHECK-CXX17: call void @_ZN6PR98014TestC2Ev
127 // CHECK-NOT: call void @llvm.memset.p0i8.i64
128 // CHECK-NOT: call void @_ZN6PR98015Test3C1Ev
129 Test3 empty3[3] = {};
130 }
131
132 }
133
134 namespace zeroinit {
135 struct S { int i; };
136
137 // CHECK-LABEL: define{{.*}} i32 @_ZN8zeroinit4testEv()
test()138 int test() {
139 // CHECK: call void @llvm.memset.p0i8.i64
140 // CHECK: ret i32 0
141 return S().i;
142 }
143
144 struct X0 {
X0zeroinit::X0145 X0() { }
146 int x;
147 };
148
149 struct X1 : X0 {
150 int x1;
151 void f();
152 };
153
154 // CHECK-LABEL: define{{.*}} void @_ZN8zeroinit9testX0_X1Ev
testX0_X1()155 void testX0_X1() {
156 // CHECK: call void @llvm.memset.p0i8.i64
157 // CHECK-NEXT: call void @_ZN8zeroinit2X1C1Ev
158 // CHECK-NEXT: call void @_ZN8zeroinit2X11fEv
159 X1().f();
160 }
161
162 template<typename>
163 struct X2 : X0 {
164 int x2;
165 void f();
166 };
167
168 template<typename>
169 struct X3 : X2<int> {
X3zeroinit::X3170 X3() : X2<int>() { }
171 int i;
172 };
173
174
175 // CHECK-LABEL: define{{.*}} void @_ZN8zeroinit9testX0_X3Ev
testX0_X3()176 void testX0_X3() {
177 // CHECK-NOT: call void @llvm.memset
178 // CHECK: call void @_ZN8zeroinit2X3IiEC1Ev
179 // CHECK: call void @_ZN8zeroinit2X2IiE1fEv
180 // CHECK-NEXT: ret void
181 X3<int>().f();
182 }
183
184 // More checks at EOF
185 }
186
187 namespace PR8726 {
188 class C;
189 struct S {
190 const C &c1;
191 int i;
192 const C &c2;
193 };
f(const C & c)194 void f(const C& c) {
195 S s = {c, 42, c};
196 }
197
198 }
199
200 // rdar://problem/9355931
201 namespace test6 {
202 struct A { A(); A(int); };
203
test()204 void test() {
205 A arr[10][20] = { 5 };
206 };
207 // CHECK-LABEL: define{{.*}} void @_ZN5test64testEv()
208 // CHECK: [[ARR:%.*]] = alloca [10 x [20 x [[A:%.*]]]],
209
210 // CHECK-NEXT: [[INNER:%.*]] = getelementptr inbounds [10 x [20 x [[A]]]], [10 x [20 x [[A]]]]* [[ARR]], i64 0, i64 0
211 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 0, i64 0
212 // CHECK-NEXT: call void @_ZN5test61AC1Ei([[A]]* {{[^,]*}} [[T0]], i32 5)
213 // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i64 1
214 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i64 20
215 // CHECK-NEXT: br label
216 // CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
217 // CHECK-NEXT: call void @_ZN5test61AC1Ev([[A]]* {{[^,]*}} [[CUR]])
218 // CHECK-NEXT: [[NEXT]] = getelementptr inbounds [[A]], [[A]]* [[CUR]], i64 1
219 // CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[NEXT]], [[END]]
220 // CHECK-NEXT: br i1
221
222 // CHECK: [[BEGIN:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 1
223 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[INNER]], i64 10
224 // CHECK-NEXT: br label
225 // CHECK: [[CUR:%.*]] = phi [20 x [[A]]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
226
227 // Inner loop.
228 // CHECK-NEXT: [[IBEGIN:%.*]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[CUR]], i{{32|64}} 0, i{{32|64}} 0
229 // CHECK-NEXT: [[IEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[IBEGIN]], i64 20
230 // CHECK-NEXT: br label
231 // CHECK: [[ICUR:%.*]] = phi [[A]]* [ [[IBEGIN]], {{%.*}} ], [ [[INEXT:%.*]], {{%.*}} ]
232 // CHECK-NEXT: call void @_ZN5test61AC1Ev([[A]]* {{[^,]*}} [[ICUR]])
233 // CHECK-NEXT: [[INEXT:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ICUR]], i64 1
234 // CHECK-NEXT: [[T0:%.*]] = icmp eq [[A]]* [[INEXT]], [[IEND]]
235 // CHECK-NEXT: br i1 [[T0]],
236
237 // CHECK: [[NEXT]] = getelementptr inbounds [20 x [[A]]], [20 x [[A]]]* [[CUR]], i64 1
238 // CHECK-NEXT: [[T0:%.*]] = icmp eq [20 x [[A]]]* [[NEXT]], [[END]]
239 // CHECK-NEXT: br i1 [[T0]]
240 // CHECK: ret void
241 }
242
243 namespace PR11124 {
244 // Make sure C::C doesn't overwrite parts of A while it is zero-initializing B
245 struct A { int a; A(); A(int); };
246 struct B : virtual A { int b; };
247 struct C : B { C(); };
C()248 C::C() : A(3), B() {}
249 // CHECK-LABEL: define{{.*}} void @_ZN7PR111241CC1Ev
250 // CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 {{.*}}, i8 0, i64 12, i1 false)
251 // CHECK-NEXT: call void @_ZN7PR111241BC2Ev
252 // Make sure C::C doesn't overwrite parts of A while it is zero-initializing B
253
254 struct B2 : virtual A { int B::*b; };
255 struct C2 : B2 { C2(); };
C2()256 C2::C2() : A(3), B2() {}
257 // CHECK-LABEL: define{{.*}} void @_ZN7PR111242C2C1Ev
258 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %{{.*}}, i8* align 8 {{.*}}, i64 16, i1 false)
259 // CHECK-NEXT: call void @_ZN7PR111242B2C2Ev
260 }
261
262 // Ensure we produce an i1 here, and don't assert.
263 // CHECK-LABEL: define{{.*}} void @_Z9r170806_bv(
264 // CHECK: call void @_Z9r170806_ab(i1 zeroext false)
265 void r170806_a(bool b = bool());
r170806_b()266 void r170806_b() { r170806_a(); }
267
268 namespace PR20256 {
269 struct data { int i; };
270
271 template<typename T = int>
g()272 data g() {
273 data d; // not value-init
274 return d;
275 }
276 template data g();
277 // CHECK-LABEL: define {{.*}} @_ZN7PR202561gIiEENS_4dataEv(
278 // CHECK-NOT: store
279 // CHECK-NOT: memset
280 // CHECK: }
281
282 template<typename ...T>
h(T...t)283 data h(T ...t) {
284 data d(t...); // value-init
285 return d;
286 }
287 template data h();
288 // CHECK-LABEL: define {{.*}} @_ZN7PR202561hIJEEENS_4dataEDpT_(
289 // CHECK: call void @llvm.memset
290 // CHECK: }
291
292
293 template<typename T = int>
j()294 data j() {
295 data d = {}; // value-init
296 return d;
297 }
298 template data j();
299 // CHECK-LABEL: define {{.*}} @_ZN7PR202561jIiEENS_4dataEv(
300 // CHECK: call void @llvm.memset
301 // CHECK: }
302
f()303 data f() {
304 data d; // not value-init
305 return d;
306 }
307 // CHECK-LABEL: define {{.*}} @_ZN7PR202561fEv(
308 // CHECK-NOT: store
309 // CHECK-NOT: memset
310 // CHECK: }
311
i()312 data i() {
313 data d = {}; // value-init
314 return d;
315 }
316 // CHECK-LABEL: define {{.*}} @_ZN7PR202561iEv(
317 // CHECK: call void @llvm.memset
318 // CHECK: }
319 }
320
321 // CHECK-LABEL: define {{.*}}@_Z20explicitly_defaultedv
explicitly_defaulted()322 int explicitly_defaulted() {
323 struct A { A() = default; int n; };
324 // CHECK: call void @llvm.memset
325 A a = A();
326 return a.n;
327 } // CHECK-LABEL: }
328
329 // CHECK-LABEL: define linkonce_odr void @_ZN8zeroinit2X3IiEC2Ev(%"struct.zeroinit::X3"* {{[^,]*}} %this) unnamed_addr
330 // CHECK: call void @llvm.memset.p0i8.i64
331 // CHECK-NEXT: call void @_ZN8zeroinit2X2IiEC2Ev
332 // CHECK-NEXT: ret void
333
334 #if __cplusplus >= 201103L
335 namespace transparent_init_list {
336 struct optional_assign_base {};
337 struct optional_data_dtor_base { char dummy_[24]; };
338 struct optional : optional_data_dtor_base, optional_assign_base {};
f(optional a)339 optional f(optional a) { return {optional(a)}; }
340 }
341 #endif
342