Mercurial > hg > CbC > CbC_llvm

comparison clang/test/CXX/special/class.temporary/p6.cpp @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 // RUN: %clang_cc1 -std=c++17 %s -triple x86_64-linux-gnu -emit-llvm -o - | FileCheck %s --implicit-check-not='call{{.*}}dtor'
2
3 namespace std {
4 typedef decltype(sizeof(int)) size_t;
5
6 template <class E>
7 struct initializer_list {
8 const E *begin;
9 size_t size;
10 initializer_list() : begin(nullptr), size(0) {}
11 };
12 }
13
14 void then();
15
16 struct dtor {
17 ~dtor();
18 };
19
20 dtor ctor();
21
22 auto &&lambda = [a = {ctor()}] {};
23 // CHECK-LABEL: define
24 // CHECK: call {{.*}}ctor
25 // CHECK: call {{.*}}atexit{{.*}}global_array_dtor
26
27 // CHECK-LABEL: define{{.*}}global_array_dtor
28 // CHECK: call {{.*}}dtor
29
30 // [lifetime extension occurs if the object was obtained by]
31 // -- a temporary materialization conversion
32 // CHECK-LABEL: ref_binding
33 void ref_binding() {
34 // CHECK: call {{.*}}ctor
35 auto &&x = ctor();
36 // CHECK: call {{.*}}then
37 then();
38 // CHECK: call {{.*}}dtor
39 // CHECK: }
40 }
41
42 // -- ( expression )
43 // CHECK-LABEL: parens
44 void parens() {
45 // CHECK: call {{.*}}ctor
46 auto &&x = ctor();
47 // CHECK: call {{.*}}then
48 then();
49 // CHECK: call {{.*}}dtor
50 // CHECK: }
51 }
52
53 // -- subscripting of an array
54 // CHECK-LABEL: array_subscript_1
55 void array_subscript_1() {
56 using T = dtor[1];
57 // CHECK: call {{.*}}ctor
58 auto &&x = T{ctor()}[0];
59 // CHECK: call {{.*}}then
60 then();
61 // CHECK: call {{.*}}dtor
62 // CHECK: }
63 }
64 // CHECK-LABEL: array_subscript_2
65 void array_subscript_2() {
66 using T = dtor[1];
67 // CHECK: call {{.*}}ctor
68 auto &&x = ((dtor*)T{ctor()})[0];
69 // CHECK: call {{.*}}dtor
70 // CHECK: call {{.*}}then
71 then();
72 // CHECK: }
73 }
74
75 struct with_member { dtor d; ~with_member(); };
76 struct with_ref_member { dtor &&d; ~with_ref_member(); };
77
78 // -- a class member access using the . operator [...]
79 // CHECK-LABEL: member_access_1
80 void member_access_1() {
81 // CHECK: call {{.*}}ctor
82 auto &&x = with_member{ctor()}.d;
83 // CHECK: call {{.*}}then
84 then();
85 // CHECK: call {{.*}}with_member
86 // CHECK: }
87 }
88 // CHECK-LABEL: member_access_2
89 void member_access_2() {
90 // CHECK: call {{.*}}ctor
91 auto &&x = with_ref_member{ctor()}.d;
92 // CHECK: call {{.*}}with_ref_member
93 // CHECK: call {{.*}}dtor
94 // CHECK: call {{.*}}then
95 then();
96 // CHECK: }
97 }
98 // CHECK-LABEL: member_access_3
99 void member_access_3() {
100 // CHECK: call {{.*}}ctor
101 auto &&x = (&(const with_member&)with_member{ctor()})->d;
102 // CHECK: call {{.*}}with_member
103 // CHECK: call {{.*}}then
104 then();
105 // CHECK: }
106 }
107
108 // -- a pointer-to-member operation using the .* operator [...]
109 // CHECK-LABEL: member_ptr_access_1
110 void member_ptr_access_1() {
111 // CHECK: call {{.*}}ctor
112 auto &&x = with_member{ctor()}.*&with_member::d;
113 // CHECK: call {{.*}}then
114 then();
115 // CHECK: call {{.*}}with_member
116 // CHECK: }
117 }
118 // CHECK-LABEL: member_ptr_access_2
119 void member_ptr_access_2() {
120 // CHECK: call {{.*}}ctor
121 auto &&x = (&(const with_member&)with_member{ctor()})->*&with_member::d;
122 // CHECK: call {{.*}}with_member
123 // CHECK: call {{.*}}then
124 then();
125 // CHECK: }
126 }
127
128 // -- a [named] cast [...]
129 // CHECK-LABEL: static_cast
130 void test_static_cast() {
131 // CHECK: call {{.*}}ctor
132 auto &&x = static_cast<dtor&&>(ctor());
133 // CHECK: call {{.*}}then
134 then();
135 // CHECK: call {{.*}}dtor
136 // CHECK: }
137 }
138 // CHECK-LABEL: const_cast
139 void test_const_cast() {
140 // CHECK: call {{.*}}ctor
141 auto &&x = const_cast<dtor&&>(ctor());
142 // CHECK: call {{.*}}then
143 then();
144 // CHECK: call {{.*}}dtor
145 // CHECK: }
146 }
147 // CHECK-LABEL: reinterpret_cast
148 void test_reinterpret_cast() {
149 // CHECK: call {{.*}}ctor
150 auto &&x = reinterpret_cast<dtor&&>(static_cast<dtor&&>(ctor()));
151 // CHECK: call {{.*}}then
152 then();
153 // CHECK: call {{.*}}dtor
154 // CHECK: }
155 }
156 // CHECK-LABEL: dynamic_cast
157 void test_dynamic_cast() {
158 // CHECK: call {{.*}}ctor
159 auto &&x = dynamic_cast<dtor&&>(ctor());
160 // CHECK: call {{.*}}then
161 then();
162 // CHECK: call {{.*}}dtor
163 // CHECK: }
164 }
165
166 // -- [explicit cast notation is defined in terms of the above]
167 // CHECK-LABEL: c_style_cast
168 void c_style_cast() {
169 // CHECK: call {{.*}}ctor
170 auto &&x = (dtor&&)ctor();
171 // CHECK: call {{.*}}then
172 then();
173 // CHECK: call {{.*}}dtor
174 // CHECK: }
175 }
176 // CHECK-LABEL: function_style_cast
177 void function_style_cast() {
178 // CHECK: call {{.*}}ctor
179 using R = dtor&&;
180 auto &&x = R(ctor());
181 // CHECK: call {{.*}}then
182 then();
183 // CHECK: call {{.*}}dtor
184 // CHECK: }
185 }
186
187 // -- a conditional operator
188 // CHECK-LABEL: conditional
189 void conditional(bool b) {
190 // CHECK: call {{.*}}ctor
191 // CHECK: call {{.*}}ctor
192 auto &&x = b ? (dtor&&)ctor() : (dtor&&)ctor();
193 // CHECK: call {{.*}}then
194 then();
195 // CHECK: call {{.*}}dtor
196 // CHECK: call {{.*}}dtor
197 // CHECK: }
198 }
199
200 // -- a comma expression
201 // CHECK-LABEL: comma
202 void comma() {
203 // CHECK: call {{.*}}ctor
204 auto &&x = (true, (dtor&&)ctor());
205 // CHECK: call {{.*}}then
206 then();
207 // CHECK: call {{.*}}dtor
208 // CHECK: }
209 }
210
211
212 // This applies recursively: if an object is lifetime-extended and contains a
213 // reference, the referent is also extended.
214 // CHECK-LABEL: init_capture_ref
215 void init_capture_ref() {
216 // CHECK: call {{.*}}ctor
217 auto x = [&a = (const dtor&)ctor()] {};
218 // CHECK: call {{.*}}then
219 then();
220 // CHECK: call {{.*}}dtor
221 // CHECK: }
222 }
223 // CHECK-LABEL: init_capture_ref_indirect
224 void init_capture_ref_indirect() {
225 // CHECK: call {{.*}}ctor
226 auto x = [&a = (const dtor&)ctor()] {};
227 // CHECK: call {{.*}}then
228 then();
229 // CHECK: call {{.*}}dtor
230 // CHECK: }
231 }
232 // CHECK-LABEL: init_capture_init_list
233 void init_capture_init_list() {
234 // CHECK: call {{.*}}ctor
235 auto x = [a = {ctor()}] {};
236 // CHECK: call {{.*}}then
237 then();
238 // CHECK: call {{.*}}dtor
239 // CHECK: }
240 }