Clang Project

clang_source_code/test/CodeGenCXX/cxx1z-aligned-allocation.cpp
1// Check that delete exprs call aligned (de)allocation functions if
2// -faligned-allocation is passed in both C++11 and C++14.
3// RUN: %clang_cc1 -std=c++11 -fexceptions -fsized-deallocation -faligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
4// RUN: %clang_cc1 -std=c++14 -fexceptions -fsized-deallocation -faligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
5// RUN: %clang_cc1 -std=c++1z -fexceptions -fsized-deallocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s
6
7// RUN: %clang_cc1 -std=c++1z -fexceptions -fsized-deallocation %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s --check-prefix=CHECK-MS
8
9// Check that we don't used aligned (de)allocation without -faligned-allocation or C++1z.
10// RUN: %clang_cc1 -std=c++14 -DUNALIGNED -fexceptions %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNALIGNED
11// RUN: %clang_cc1 -std=c++1z -DUNALIGNED -fexceptions -fno-aligned-allocation %s -emit-llvm -triple x86_64-linux-gnu -o - | FileCheck %s --check-prefix=CHECK-UNALIGNED
12
13// CHECK-UNALIGNED-NOT: _Znwm_St11align_val_t
14// CHECK-UNALIGNED-NOT: _Znam_St11align_val_t
15// CHECK-UNALIGNED-NOT: _ZdlPv_St11align_val_t
16// CHECK-UNALIGNED-NOT: _ZdaPv_St11align_val_t
17// CHECK-UNALIGNED-NOT: _ZdlPvm_St11align_val_t
18// CHECK-UNALIGNED-NOT: _ZdaPvm_St11align_val_t
19
20typedef decltype(sizeof(0)) size_t;
21namespace std { enum class align_val_t : size_t {}; }
22
23#define OVERALIGNED alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2)
24
25// Global new and delete.
26// ======================
27struct OVERALIGNED A { A(); int n[128]; };
28
29// CHECK-LABEL: define {{.*}} @_Z2a0v()
30// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t(i64 512, i64 32)
31// CHECK: call void @_ZdlPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
32// CHECK-MS-LABEL: define {{.*}} @"?a0@@YAPEAXXZ"()
33// CHECK-MS: %[[ALLOC:.*]] = call i8* @"??2@YAPEAX_KW4align_val_t@std@@@Z"(i64 512, i64 32)
34// CHECK-MS: cleanuppad
35// CHECK-MS: call void @"??3@YAXPEAXW4align_val_t@std@@@Z"(i8* %[[ALLOC]], i64 32)
36void *a0() { return new A; }
37
38// FIXME: Why don't we call the sized array deallocation overload in this case?
39// The size is known.
40//
41// CHECK-LABEL: define {{.*}} @_Z2a1l(
42// CHECK: %[[ALLOC:.*]] = call i8* @_ZnamSt11align_val_t(i64 %{{.*}}, i64 32)
43// No array cookie.
44// CHECK-NOT: store
45// CHECK: invoke void @_ZN1AC1Ev(
46// CHECK: call void @_ZdaPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
47// CHECK-MS-LABEL: define {{.*}} @"?a1@@YAPEAXJ@Z"(
48// CHECK-MS: %[[ALLOC:.*]] = call i8* @"??_U@YAPEAX_KW4align_val_t@std@@@Z"(i64 %{{.*}}, i64 32)
49// No array cookie.
50// CHECK-MS-NOT: store
51// CHECK-MS: invoke %struct.A* @"??0A@@QEAA@XZ"(
52// CHECK-MS: cleanuppad
53// CHECK-MS: call void @"??_V@YAXPEAXW4align_val_t@std@@@Z"(i8* %[[ALLOC]], i64 32)
54void *a1(long n) { return new A[n]; }
55
56// CHECK-LABEL: define {{.*}} @_Z2a2P1A(
57// CHECK: call void @_ZdlPvmSt11align_val_t(i8* %{{.*}}, i64 512, i64 32) #9
58void a2(A *p) { delete p; }
59
60// CHECK-LABEL: define {{.*}} @_Z2a3P1A(
61// CHECK: call void @_ZdaPvSt11align_val_t(i8* %{{.*}}, i64 32) #9
62void a3(A *p) { delete[] p; }
63
64
65// Class-specific usual new and delete.
66// ====================================
67struct OVERALIGNED B {
68  B();
69  // These are just a distraction. We should ignore them.
70  void *operator new(size_t);
71  void operator delete(void*, size_t);
72  void operator delete[](void*, size_t);
73
74  void *operator new(size_t, std::align_val_t);
75  void operator delete(void*, std::align_val_t);
76  void operator delete[](void*, std::align_val_t);
77
78  int n[128];
79};
80
81// CHECK-LABEL: define {{.*}} @_Z2b0v()
82// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1BnwEmSt11align_val_t(i64 512, i64 32)
83// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
84void *b0() { return new B; }
85
86// CHECK-LABEL: define {{.*}} @_Z2b1l(
87// CHECK: %[[ALLOC:.*]] = call i8* @_ZnamSt11align_val_t(i64 %{{.*}}, i64 32)
88// No array cookie.
89// CHECK-NOT: store
90// CHECK: invoke void @_ZN1BC1Ev(
91// CHECK: call void @_ZN1BdaEPvSt11align_val_t(i8* %[[ALLOC]], i64 32)
92void *b1(long n) { return new B[n]; }
93
94// CHECK-LABEL: define {{.*}} @_Z2b2P1B(
95// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %{{.*}}, i64 32)
96void b2(B *p) { delete p; }
97
98// CHECK-LABEL: define {{.*}} @_Z2b3P1B(
99// CHECK: call void @_ZN1BdaEPvSt11align_val_t(i8* %{{.*}}, i64 32)
100void b3(B *p) { delete[] p; }
101
102struct OVERALIGNED C {
103  C();
104  void *operator new[](size_t, std::align_val_t);
105  void operator delete[](void*, size_t, std::align_val_t);
106
107  // It doesn't matter that we have an unaligned operator delete[] that doesn't
108  // want the size. What matters is that the aligned one does.
109  void operator delete[](void*);
110};
111
112// This one has an array cookie.
113// CHECK-LABEL: define {{.*}} @_Z2b4l(
114// CHECK: call {{.*}} @llvm.umul.with.overflow{{.*}}i64 32
115// CHECK: call {{.*}} @llvm.uadd.with.overflow{{.*}}i64 32
116// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1CnaEmSt11align_val_t(i64 %{{.*}}, i64 32)
117// CHECK: store
118// CHECK: call void @_ZN1CC1Ev(
119//
120// Note, we're still calling a placement allocation function, and there is no
121// matching placement operator delete. =(
122// FIXME: This seems broken.
123// CHECK-NOT: call void @_ZN1CdaEPvmSt11align_val_t(
124#ifndef UNALIGNED
125void *b4(long n) { return new C[n]; }
126#endif
127
128// CHECK-LABEL: define {{.*}} @_Z2b5P1C(
129// CHECK: mul i64{{.*}} 32
130// CHECK: add i64{{.*}} 32
131// CHECK: call void @_ZN1CdaEPvmSt11align_val_t(
132void b5(C *p) { delete[] p; }
133
134
135// Global placement new.
136// =====================
137
138struct Q { int n; } q;
139void *operator new(size_t, Q);
140void *operator new(size_t, std::align_val_t, Q);
141void operator delete(void*, Q);
142void operator delete(void*, std::align_val_t, Q);
143
144// CHECK-LABEL: define {{.*}} @_Z2c0v(
145// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t1Q(i64 512, i64 32, i32 %
146// CHECK: call void @_ZdlPvSt11align_val_t1Q(i8* %[[ALLOC]], i64 32, i32 %
147void *c0() { return new (q) A; }
148
149
150// Class-specific placement new.
151// =============================
152
153struct OVERALIGNED D {
154  D();
155  void *operator new(size_t, Q);
156  void *operator new(size_t, std::align_val_t, Q);
157  void operator delete(void*, Q);
158  void operator delete(void*, std::align_val_t, Q);
159};
160
161// CHECK-LABEL: define {{.*}} @_Z2d0v(
162// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1DnwEmSt11align_val_t1Q(i64 32, i64 32, i32 %
163// CHECK: call void @_ZN1DdlEPvSt11align_val_t1Q(i8* %[[ALLOC]], i64 32, i32 %
164void *d0() { return new (q) D; }
165
166
167// Calling aligned new with placement syntax.
168// ==========================================
169
170#ifndef UNALIGNED
171// CHECK-LABEL: define {{.*}} @_Z2e0v(
172// CHECK: %[[ALLOC:.*]] = call i8* @_ZnwmSt11align_val_t(i64 512, i64 5)
173// CHECK: call void @_ZdlPvSt11align_val_t(i8* %[[ALLOC]], i64 5)
174void *e0() { return new (std::align_val_t(5)) A; }
175
176// CHECK-LABEL: define {{.*}} @_Z2e1v(
177// CHECK: %[[ALLOC:.*]] = call i8* @_ZN1BnwEmSt11align_val_t(i64 512, i64 5)
178// CHECK: call void @_ZN1BdlEPvSt11align_val_t(i8* %[[ALLOC]], i64 5)
179void *e1() { return new (std::align_val_t(5)) B; }
180#endif
181
182// Variadic placement/non-placement allocation functions.
183// ======================================================
184
185struct OVERALIGNED F {
186  F();
187  void *operator new(size_t, ...);
188  void operator delete(void*, ...);
189  int n[128];
190};
191
192// CHECK-LABEL: define {{.*}} @_Z2f0v(
193// CHECK: %[[ALLOC:.*]] = call i8* (i64, ...) @_ZN1FnwEmz(i64 512, i64 32)
194// Non-placement allocation function, uses normal deallocation lookup which
195// cares about whether a parameter has type std::align_val_t.
196// CHECK: call void (i8*, ...) @_ZN1FdlEPvz(i8* %[[ALLOC]])
197void *f0() { return new F; }
198
199// CHECK-LABEL: define {{.*}} @_Z2f1v(
200// CHECK: %[[ALLOC:.*]] = call i8* (i64, ...) @_ZN1FnwEmz(i64 512, i64 32, i32 %
201// Placement allocation function, uses placement deallocation matching, which
202// passes same arguments and therefore includes alignment.
203// CHECK: call void (i8*, ...) @_ZN1FdlEPvz(i8* %[[ALLOC]], i64 32, i32 %
204void *f1() { return new (q) F; }
205
206struct OVERALIGNED G {
207  G();
208  void *operator new(size_t, std::align_val_t, ...);
209  void operator delete(void*, std::align_val_t, ...);
210  int n[128];
211};
212#ifndef UNALIGNED
213// CHECK-LABEL: define {{.*}} @_Z2g0v
214// CHECK: %[[ALLOC:.*]] = call i8* (i64, i64, ...) @_ZN1GnwEmSt11align_val_tz(i64 512, i64 32)
215// CHECK: call void (i8*, i64, ...) @_ZN1GdlEPvSt11align_val_tz(i8* %[[ALLOC]], i64 32)
216void *g0() { return new G; }
217
218// CHECK-LABEL: define {{.*}} @_Z2g1v
219// CHECK: %[[ALLOC:.*]] = call i8* (i64, i64, ...) @_ZN1GnwEmSt11align_val_tz(i64 512, i64 32, i32 %
220// CHECK: call void (i8*, i64, ...) @_ZN1GdlEPvSt11align_val_tz(i8* %[[ALLOC]], i64 32, i32 %
221void *g1() { return new (q) G; }
222#endif
223
CodeThinker, Enjoy your reading code