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