1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
2
3 typedef __typeof__(sizeof(0)) size_t;
4
5 // Declare an 'operator new' template to tickle a bug in __builtin_operator_new.
6 template<typename T> void *operator new(size_t, int (*)(T));
7
8 // Ensure that this declaration doesn't cause operator new to lose its
9 // 'noalias' attribute.
10 void *operator new[](size_t);
11
t1()12 void t1() {
13 delete new int;
14 delete [] new int [3];
15 }
16
17 // CHECK: declare noalias i8* @_Znwm(i64) [[ATTR_NOBUILTIN:#[^ ]*]]
18 // CHECK: declare void @_ZdlPv(i8*) [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]]
19 // CHECK: declare noalias i8* @_Znam(i64) [[ATTR_NOBUILTIN]]
20 // CHECK: declare void @_ZdaPv(i8*) [[ATTR_NOBUILTIN_NOUNWIND]]
21
22 namespace std {
23 struct nothrow_t {};
24 }
25 std::nothrow_t nothrow;
26
27 // Declare the reserved placement operators.
28 void *operator new(size_t, void*) throw();
29 void operator delete(void*, void*) throw();
30 void *operator new[](size_t, void*) throw();
31 void operator delete[](void*, void*) throw();
32
33 // Declare the replaceable global allocation operators.
34 void *operator new(size_t, const std::nothrow_t &) throw();
35 void *operator new[](size_t, const std::nothrow_t &) throw();
36 void operator delete(void *, const std::nothrow_t &) throw();
37 void operator delete[](void *, const std::nothrow_t &) throw();
38
t2(int * a)39 void t2(int* a) {
40 int* b = new (a) int;
41 }
42
43 struct S {
44 int a;
45 };
46
47 // POD types.
t3()48 void t3() {
49 int *a = new int(10);
50 _Complex int* b = new _Complex int(10i);
51
52 S s;
53 s.a = 10;
54 S *sp = new S(s);
55 }
56
57 // Non-POD
58 struct T {
59 T();
60 int a;
61 };
62
t4()63 void t4() {
64 // CHECK: call void @_ZN1TC1Ev
65 T *t = new T;
66 }
67
68 struct T2 {
69 int a;
70 T2(int, int);
71 };
72
t5()73 void t5() {
74 // CHECK: call void @_ZN2T2C1Eii
75 T2 *t2 = new T2(10, 10);
76 }
77
t6()78 int *t6() {
79 // Null check.
80 return new (0) int(10);
81 }
82
t7()83 void t7() {
84 new int();
85 }
86
87 struct U {
88 ~U();
89 };
90
t8(int n)91 void t8(int n) {
92 new int[10];
93 new int[n];
94
95 // Non-POD
96 new T[10];
97 new T[n];
98
99 // Cookie required
100 new U[10];
101 new U[n];
102 }
103
t9()104 void t9() {
105 bool b;
106
107 new bool(true);
108 new (&b) bool(true);
109 }
110
111 struct A {
112 void* operator new(__typeof(sizeof(int)), int, float, ...);
113 A();
114 };
115
t10()116 A* t10() {
117 // CHECK: @_ZN1AnwEmifz
118 return new(1, 2, 3.45, 100) A;
119 }
120
121 // CHECK-LABEL: define void @_Z3t11i
122 struct B { int a; };
123 struct Bmemptr { int Bmemptr::* memptr; int a; };
124
t11(int n)125 void t11(int n) {
126 // CHECK: call noalias i8* @_Znwm
127 // CHECK: call void @llvm.memset.p0i8.i64(
128 B* b = new B();
129
130 // CHECK: call noalias i8* @_Znam
131 // CHECK: {{call void.*llvm.memset.p0i8.i64.*i8 0, i64 %}}
132 B *b2 = new B[n]();
133
134 // CHECK: call noalias i8* @_Znam
135 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
136 // CHECK: br
137 Bmemptr *b_memptr = new Bmemptr[n]();
138
139 // CHECK: ret void
140 }
141
142 struct Empty { };
143
144 // We don't need to initialize an empty class.
145 // CHECK-LABEL: define void @_Z3t12v
t12()146 void t12() {
147 // CHECK: call noalias i8* @_Znam
148 // CHECK-NOT: br
149 (void)new Empty[10];
150
151 // CHECK: call noalias i8* @_Znam
152 // CHECK-NOT: br
153 (void)new Empty[10]();
154
155 // CHECK: ret void
156 }
157
158 // Zero-initialization
159 // CHECK-LABEL: define void @_Z3t13i
t13(int n)160 void t13(int n) {
161 // CHECK: call noalias i8* @_Znwm
162 // CHECK: store i32 0, i32*
163 (void)new int();
164
165 // CHECK: call noalias i8* @_Znam
166 // CHECK: {{call void.*llvm.memset.p0i8.i64.*i8 0, i64 %}}
167 (void)new int[n]();
168
169 // CHECK-NEXT: ret void
170 }
171
172 struct Alloc{
173 int x;
174 void* operator new[](size_t size);
175 void operator delete[](void* p);
176 ~Alloc();
177 };
178
f()179 void f() {
180 // CHECK: call i8* @_ZN5AllocnaEm(i64 808)
181 // CHECK: store i64 200
182 // CHECK: call void @_ZN5AllocD1Ev(
183 // CHECK: call void @_ZN5AllocdaEPv(i8*
184 delete[] new Alloc[10][20];
185 // CHECK: call noalias i8* @_Znwm
186 // CHECK: call void @_ZdlPv(i8*
187 delete new bool;
188 // CHECK: ret void
189 }
190
191 namespace test15 {
192 struct A { A(); ~A(); };
193
194 // CHECK-LABEL: define void @_ZN6test155test0EPv(
195 // CHECK: [[P:%.*]] = load i8*
196 // CHECK-NEXT: icmp eq i8* [[P]], null
197 // CHECK-NEXT: br i1
198 // CHECK: [[T0:%.*]] = bitcast i8* [[P]] to [[A:%.*]]*
199 // CHECK-NEXT: call void @_ZN6test151AC1Ev([[A]]* [[T0]])
test0(void * p)200 void test0(void *p) {
201 new (p) A();
202 }
203
204 // CHECK-LABEL: define void @_ZN6test155test1EPv(
205 // CHECK: [[P:%.*]] = load i8**
206 // CHECK-NEXT: icmp eq i8* [[P]], null
207 // CHECK-NEXT: br i1
208 // CHECK: [[BEGIN:%.*]] = bitcast i8* [[P]] to [[A:%.*]]*
209 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 5
210 // CHECK-NEXT: br label
211 // CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
212 // CHECK-NEXT: call void @_ZN6test151AC1Ev([[A]]* [[CUR]])
213 // CHECK-NEXT: [[NEXT]] = getelementptr inbounds [[A]]* [[CUR]], i64 1
214 // CHECK-NEXT: [[DONE:%.*]] = icmp eq [[A]]* [[NEXT]], [[END]]
215 // CHECK-NEXT: br i1 [[DONE]]
test1(void * p)216 void test1(void *p) {
217 new (p) A[5];
218 }
219
220 // TODO: it's okay if all these size calculations get dropped.
221 // FIXME: maybe we should try to throw on overflow?
222 // CHECK-LABEL: define void @_ZN6test155test2EPvi(
223 // CHECK: [[N:%.*]] = load i32*
224 // CHECK-NEXT: [[T0:%.*]] = sext i32 [[N]] to i64
225 // CHECK-NEXT: [[T1:%.*]] = icmp slt i64 [[T0]], 0
226 // CHECK-NEXT: [[T2:%.*]] = select i1 [[T1]], i64 -1, i64 [[T0]]
227 // CHECK-NEXT: [[P:%.*]] = load i8*
228 // CHECK-NEXT: icmp eq i8* [[P]], null
229 // CHECK-NEXT: br i1
230 // CHECK: [[BEGIN:%.*]] = bitcast i8* [[P]] to [[A:%.*]]*
231 // CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq i64 [[T0]], 0
232 // CHECK-NEXT: br i1 [[ISEMPTY]],
233 // CHECK: [[END:%.*]] = getelementptr inbounds [[A]]* [[BEGIN]], i64 [[T0]]
234 // CHECK-NEXT: br label
235 // CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]],
236 // CHECK-NEXT: call void @_ZN6test151AC1Ev([[A]]* [[CUR]])
test2(void * p,int n)237 void test2(void *p, int n) {
238 new (p) A[n];
239 }
240 }
241
242 namespace PR10197 {
243 // CHECK-LABEL: define weak_odr void @_ZN7PR101971fIiEEvv()
244 template<typename T>
f()245 void f() {
246 // CHECK: [[CALL:%.*]] = call noalias i8* @_Znwm
247 // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to
248 new T;
249 // CHECK-NEXT: ret void
250 }
251
252 template void f<int>();
253 }
254
255 namespace PR11523 {
256 class MyClass;
257 typedef int MyClass::* NewTy;
258 // CHECK-LABEL: define i64* @_ZN7PR115231fEv
259 // CHECK: store i64 -1
f()260 NewTy* f() { return new NewTy[2](); }
261 }
262
263 namespace PR11757 {
264 // Make sure we elide the copy construction.
265 struct X { X(); X(const X&); };
a(X * x)266 X* a(X* x) { return new X(X()); }
267 // CHECK: define {{.*}} @_ZN7PR117571aEPNS_1XE
268 // CHECK: [[CALL:%.*]] = call noalias i8* @_Znwm
269 // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to
270 // CHECK-NEXT: call void @_ZN7PR117571XC1Ev({{.*}}* [[CASTED]])
271 // CHECK-NEXT: ret {{.*}} [[CASTED]]
272 }
273
274 namespace PR13380 {
APR13380::A275 struct A { A() {} };
276 struct B : public A { int x; };
277 // CHECK-LABEL: define i8* @_ZN7PR133801fEv
278 // CHECK: call noalias i8* @_Znam(
279 // CHECK: call void @llvm.memset.p0i8
280 // CHECK-NEXT: call void @_ZN7PR133801BC1Ev
f()281 void* f() { return new B[2](); }
282 }
283
284 struct MyPlacementType {} mpt;
285 void *operator new(size_t, MyPlacementType);
286
287 namespace N3664 {
288 struct S { S() throw(int); };
289
290 // CHECK-LABEL: define void @_ZN5N36641fEv
f()291 void f() {
292 // CHECK: call noalias i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
293 int *p = new int;
294 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE:#[^ ]*]]
295 delete p;
296
297 // CHECK: call noalias i8* @_Znam(i64 12) [[ATTR_BUILTIN_NEW]]
298 int *q = new int[3];
299 // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_BUILTIN_DELETE]]
300 delete [] p;
301
302 // CHECK: call i8* @_ZnamRKSt9nothrow_t(i64 3, {{.*}}) [[ATTR_BUILTIN_NOTHROW_NEW:#[^ ]*]]
303 (void) new (nothrow) S[3];
304
305 // CHECK: call i8* @_Znwm15MyPlacementType(i64 4){{$}}
306 (void) new (mpt) int;
307 }
308
309 // FIXME: Can we mark this noalias?
310 // CHECK: declare i8* @_ZnamRKSt9nothrow_t(i64, {{.*}}) [[ATTR_NOBUILTIN_NOUNWIND]]
311
312 // CHECK-LABEL: define void @_ZN5N36641gEv
g()313 void g() {
314 // It's OK for there to be attributes here, so long as we don't have a
315 // 'builtin' attribute.
316 // CHECK: call noalias i8* @_Znwm(i64 4){{$}}
317 int *p = (int*)operator new(4);
318 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_NOUNWIND:#[^ ]*]]
319 operator delete(p);
320
321 // CHECK: call noalias i8* @_Znam(i64 12){{$}}
322 int *q = (int*)operator new[](12);
323 // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_NOUNWIND]]
324 operator delete [](p);
325
326 // CHECK: call i8* @_ZnamRKSt9nothrow_t(i64 3, {{.*}}) [[ATTR_NOUNWIND]]
327 (void) operator new[](3, nothrow);
328 }
329 }
330
331 namespace builtins {
332 // CHECK-LABEL: define void @_ZN8builtins1fEv
f()333 void f() {
334 // CHECK: call noalias i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW]]
335 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE]]
336 __builtin_operator_delete(__builtin_operator_new(4));
337 }
338 }
339
340 // CHECK-DAG: attributes [[ATTR_NOBUILTIN]] = {{[{].*}} nobuiltin {{.*[}]}}
341 // CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} nobuiltin nounwind {{.*[}]}}
342
343 // CHECK: attributes [[ATTR_NOUNWIND]] =
344 // CHECK-NOT: builtin
345 // CHECK-NOT: attributes
346 // CHECK: nounwind
347 // CHECK-NOT: builtin
348 // CHECK: attributes
349
350 // CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin {{.*[}]}}
351 // CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin {{.*[}]}}
352