Clang Project

clang_source_code/test/CodeGenCXX/value-init.cpp
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
4struct A {
5  virtual ~A();
6};
7
8struct B : A { };
9
10struct C {
11  int i;
12  B b;
13};
14
15// CHECK: _Z15test_value_initv
16void 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
28enum enum_type { negative_number = -1, magic_number = 42 };
29
30class enum_holder
31{
32  enum_type m_enum;
33
34public:
35  enum_holder() : m_enum(magic_number) { }
36};
37
38struct enum_holder_and_int
39{
40  enum_holder e;
41  int i;
42};
43
44// CHECK: _Z24test_enum_holder_and_intv()
45void 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.
55namespace 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
67  void foo() {
68    B();
69  }
70}
71
72namespace ptrmem {
73  struct S {
74    int mem1;
75    int S::*mem2;
76  };
77
78  // CHECK-LABEL: define i32 @_ZN6ptrmem4testEPNS_1SE
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
87namespace PR9801 {
88
89struct Test {
90  Test() : i(10) {}
91  Test(int i) : i(i) {}
92  int i;
93private:
94  int j;
95};
96
97struct Test2 {
98  Test t;
99};
100
101struct Test3 : public Test { };
102
103// CHECK-LABEL: define void @_ZN6PR98011fEv
104void 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
134namespace zeroinit {
135  struct S { int i; };
136
137  // CHECK-LABEL: define i32 @_ZN8zeroinit4testEv()
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 {
145    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
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> { 
170    X3() : X2<int>() { }
171    int i;
172  };
173  
174
175  // CHECK-LABEL: define void @_ZN8zeroinit9testX0_X3Ev
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
187namespace PR8726 {
188class C;
189struct S {
190  const C &c1;
191  int i;
192  const C &c2;
193};
194void f(const C& c) {
195  S s = {c, 42, c};
196}
197
198}
199
200// rdar://problem/9355931
201namespace test6 {
202  struct A { A(); A(int); };
203
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
243namespace 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(); };      
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(); };      
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)
265void r170806_a(bool b = bool());
266void r170806_b() { r170806_a(); }
267
268namespace PR20256 {
269  struct data { int i; };
270
271  template<typename T = int>
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>
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>
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
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
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
322int 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
335namespace 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 {};
339  optional f(optional a) { return {optional(a)}; }
340}
341#endif
342
CodeThinker, Enjoy your reading code