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