Clang Project

clang_source_code/test/CodeGenCXX/new.cpp
1// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
2
3typedef __typeof__(sizeof(0)) size_t;
4
5// Declare an 'operator new' template to tickle a bug in __builtin_operator_new.
6template<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.
10void *operator new[](size_t);
11
12void 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
22namespace std {
23  struct nothrow_t {};
24}
25std::nothrow_t nothrow;
26
27// Declare the reserved placement operators.
28void *operator new(size_t, void*) throw();
29void operator delete(void*, void*) throw();
30void *operator new[](size_t, void*) throw();
31void operator delete[](void*, void*) throw();
32
33// Declare the replaceable global allocation operators.
34void *operator new(size_t, const std::nothrow_t &) throw();
35void *operator new[](size_t, const std::nothrow_t &) throw();
36void operator delete(void *, const std::nothrow_t &) throw();
37void operator delete[](void *, const std::nothrow_t &) throw();
38
39// Declare some other placemenet operators.
40void *operator new(size_t, void*, bool) throw();
41void *operator new[](size_t, void*, bool) throw();
42
43void t2(int* a) {
44  int* b = new (a) int;
45}
46
47struct S {
48  int a;
49};
50
51// POD types.
52void 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
62struct T {
63  T();
64  int a;
65};
66
67void t4() {
68  // CHECK: call void @_ZN1TC1Ev
69  T *t = new T;
70}
71
72struct T2 {
73  int a;
74  T2(int, int);
75};
76
77void t5() { 
78  // CHECK: call void @_ZN2T2C1Eii
79  T2 *t2 = new T2(10, 10);
80}
81
82int *t6() {
83  // Null check.
84  return new (0) int(10);
85}
86
87void t7() {
88  new int();
89}
90
91struct U {
92  ~U();
93};
94  
95void 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
108void t9() {
109  bool b;
110
111  new bool(true);  
112  new (&b) bool(true);
113}
114
115struct A {
116  void* operator new(__typeof(sizeof(int)), int, float, ...);
117  A();
118};
119
120A* t10() {
121   // CHECK: @_ZN1AnwEmifz
122  return new(1, 2, 3.45, 100) A;
123}
124
125// CHECK-LABEL: define void @_Z3t11i
126struct B { int a; };
127struct Bmemptr { int Bmemptr::* memptr; int a; };
128
129void t11(int n) {
130  // CHECK: call i8* @_Znwm
131  // CHECK: call void @llvm.memset.p0i8.i64(
132  B* b = new B();
133
134  // CHECK: call i8* @_Znam
135  // CHECK: {{call void.*llvm.memset.p0i8.i64.*i8 0, i64 %}}
136  B *b2 = new B[n]();
137
138  // CHECK: call 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
146struct Empty { };
147
148// We don't need to initialize an empty class.
149// CHECK-LABEL: define void @_Z3t12v
150void t12() {
151  // CHECK: call i8* @_Znam
152  // CHECK-NOT: br
153  (void)new Empty[10];
154
155  // CHECK: call 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
164void t13(int n) {
165  // CHECK: call i8* @_Znwm
166  // CHECK: store i32 0, i32*
167  (void)new int();
168
169  // CHECK: call 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
176struct Alloc{
177  int x;
178  void* operator new[](size_t size);
179  void operator delete[](void* p);
180  ~Alloc();
181};
182
183void 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 i8* @_Znwm
190  // CHECK: call void @_ZdlPv(i8*
191  delete new bool;
192  // CHECK: ret void
193}
194
195namespace 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
271namespace PR10197 {
272  // CHECK-LABEL: define weak_odr void @_ZN7PR101971fIiEEvv()
273  template<typename T>
274  void f() {
275    // CHECK: [[CALL:%.*]] = call 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
284namespace 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
292namespace 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 i8* @_Znwm
298  // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to
299  // CHECK-NEXT: call void @_ZN7PR117571XC1Ev({{.*}}* [[CASTED]])
300  // CHECK-NEXT: ret {{.*}} [[CASTED]]
301}
302
303namespace PR13380 {
304  struct A { A() {} };
305  struct B : public A { int x; };
306  // CHECK-LABEL: define i8* @_ZN7PR133801fEv
307  // CHECK: call i8* @_Znam(
308  // CHECK: call void @llvm.memset.p0i8
309  // CHECK-NEXT: call void @_ZN7PR133801BC1Ev
310  void* f() { return new B[2](); }
311}
312
313struct MyPlacementType {} mpt;
314void *operator new(size_t, MyPlacementType);
315
316namespace N3664 {
317  struct S { S() throw(int); };
318
319  // CHECK-LABEL: define void @_ZN5N36641fEv
320  void f() {
321    // CHECK: call 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 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 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 noalias i8* @_ZnamRKSt9nothrow_t(i64, {{.*}}) [[ATTR_NOBUILTIN_NOUNWIND]]
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 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 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 i8* @_ZnamRKSt9nothrow_t(i64 3, {{.*}}) [[ATTR_NOUNWIND]]
355    (void) operator new[](3, nothrow);
356  }
357}
358
359namespace builtins {
360  // CHECK-LABEL: define void @_ZN8builtins1fEv
361  void f() {
362    // CHECK: call 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 {{.*[}]}}
369// CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} nobuiltin nounwind {{.*[}]}}
370
371// CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin {{.*[}]}}
372// CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin {{.*[}]}}
373
374// The ([^b}|...) monstrosity is matching a character that's not the start of 'builtin'.
375// Add more letters if this matches some other attribute.
376// CHECK-DAG: attributes [[ATTR_NOUNWIND]] = {{([^b]|b[^u]|bu[^i]|bui[^l])*}} nounwind {{([^b]|b[^u]|bu[^i]|bui[^l])*$}}
377
CodeThinker, Enjoy your reading code