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 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 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 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 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 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 164 void 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 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 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: [[T1:%.*]] = icmp slt i64 [[T0]], 0 259 // CHECK-NEXT: [[T2:%.*]] = select i1 [[T1]], i64 -1, i64 [[T0]] 260 // CHECK-NEXT: [[P:%.*]] = load i8*, i8** 261 // CHECK: [[BEGIN:%.*]] = bitcast i8* [[P]] to [[A:%.*]]* 262 // CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq i64 [[T0]], 0 263 // CHECK-NEXT: br i1 [[ISEMPTY]], 264 // CHECK: [[END:%.*]] = getelementptr inbounds [[A]], [[A]]* [[BEGIN]], i64 [[T0]] 265 // CHECK-NEXT: br label 266 // CHECK: [[CUR:%.*]] = phi [[A]]* [ [[BEGIN]], 267 // CHECK-NEXT: call void @_ZN6test151AC1Ev([[A]]* [[CUR]]) 268 void test2(void *p, int n) { 269 new (p) A[n]; 270 } 271 } 272 273 namespace PR10197 { 274 // CHECK-LABEL: define weak_odr void @_ZN7PR101971fIiEEvv() 275 template<typename T> 276 void f() { 277 // CHECK: [[CALL:%.*]] = call i8* @_Znwm 278 // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to 279 new T; 280 // CHECK-NEXT: ret void 281 } 282 283 template void f<int>(); 284 } 285 286 namespace PR11523 { 287 class MyClass; 288 typedef int MyClass::* NewTy; 289 // CHECK-LABEL: define i64* @_ZN7PR115231fEv 290 // CHECK: store i64 -1 291 NewTy* f() { return new NewTy[2](); } 292 } 293 294 namespace PR11757 { 295 // Make sure we elide the copy construction. 296 struct X { X(); X(const X&); }; 297 X* a(X* x) { return new X(X()); } 298 // CHECK: define {{.*}} @_ZN7PR117571aEPNS_1XE 299 // CHECK: [[CALL:%.*]] = call i8* @_Znwm 300 // CHECK-NEXT: [[CASTED:%.*]] = bitcast i8* [[CALL]] to 301 // CHECK-NEXT: call void @_ZN7PR117571XC1Ev({{.*}}* [[CASTED]]) 302 // CHECK-NEXT: ret {{.*}} [[CASTED]] 303 } 304 305 namespace PR13380 { 306 struct A { A() {} }; 307 struct B : public A { int x; }; 308 // CHECK-LABEL: define i8* @_ZN7PR133801fEv 309 // CHECK: call i8* @_Znam( 310 // CHECK: call void @llvm.memset.p0i8 311 // CHECK-NEXT: call void @_ZN7PR133801BC1Ev 312 void* f() { return new B[2](); } 313 } 314 315 struct MyPlacementType {} mpt; 316 void *operator new(size_t, MyPlacementType); 317 318 namespace N3664 { 319 struct S { S() throw(int); }; 320 321 // CHECK-LABEL: define void @_ZN5N36641fEv 322 void f() { 323 // CHECK: call i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW:#[^ ]*]] 324 int *p = new int; // expected-note {{allocated with 'new' here}} 325 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE:#[^ ]*]] 326 delete p; 327 328 // CHECK: call i8* @_Znam(i64 12) [[ATTR_BUILTIN_NEW]] 329 int *q = new int[3]; 330 // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_BUILTIN_DELETE]] 331 delete[] p; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}} 332 333 // CHECK: call i8* @_ZnamRKSt9nothrow_t(i64 3, {{.*}}) [[ATTR_BUILTIN_NOTHROW_NEW:#[^ ]*]] 334 (void) new (nothrow) S[3]; 335 336 // CHECK: call i8* @_Znwm15MyPlacementType(i64 4){{$}} 337 (void) new (mpt) int; 338 } 339 340 // CHECK: declare noalias i8* @_ZnamRKSt9nothrow_t(i64, {{.*}}) [[ATTR_NOBUILTIN_NOUNWIND]] 341 342 // CHECK-LABEL: define void @_ZN5N36641gEv 343 void g() { 344 // It's OK for there to be attributes here, so long as we don't have a 345 // 'builtin' attribute. 346 // CHECK: call i8* @_Znwm(i64 4){{$}} 347 int *p = (int*)operator new(4); 348 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_NOUNWIND:#[^ ]*]] 349 operator delete(p); 350 351 // CHECK: call i8* @_Znam(i64 12){{$}} 352 int *q = (int*)operator new[](12); 353 // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_NOUNWIND]] 354 operator delete [](p); 355 356 // CHECK: call i8* @_ZnamRKSt9nothrow_t(i64 3, {{.*}}) [[ATTR_NOUNWIND]] 357 (void) operator new[](3, nothrow); 358 } 359 } 360 361 namespace builtins { 362 // CHECK-LABEL: define void @_ZN8builtins1fEv 363 void f() { 364 // CHECK: call i8* @_Znwm(i64 4) [[ATTR_BUILTIN_NEW]] 365 // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE]] 366 __builtin_operator_delete(__builtin_operator_new(4)); 367 } 368 } 369 370 // CHECK-DAG: attributes [[ATTR_NOBUILTIN]] = {{[{].*}} nobuiltin {{.*[}]}} 371 // CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} nobuiltin nounwind {{.*[}]}} 372 373 // CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin {{.*[}]}} 374 // CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin {{.*[}]}} 375 376 // The ([^b}|...) monstrosity is matching a character that's not the start of 'builtin'. 377 // Add more letters if this matches some other attribute. 378 // CHECK-DAG: attributes [[ATTR_NOUNWIND]] = {{([^b]|b[^u]|bu[^i]|bui[^l])*}} nounwind {{([^b]|b[^u]|bu[^i]|bui[^l])*$}} 379
