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 void t2(int* a) { 40 int* b = new (a) int; 41 } 42 43 struct S { 44 int a; 45 }; 46 47 // POD types. 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 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 73 void t5() { 74 // CHECK: call void @_ZN2T2C1Eii 75 T2 *t2 = new T2(10, 10); 76 } 77 78 int *t6() { 79 // Null check. 80 return new (0) int(10); 81 } 82 83 void t7() { 84 new int(); 85 } 86 87 struct U { 88 ~U(); 89 }; 90 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 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 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 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 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 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 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]]) 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]] 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]]) 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> 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 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&); }; 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 { 275 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 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 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 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 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
