1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 %s -emit-llvm -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NOSIZE
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 %s -emit-llvm -o - -Oz -disable-llvm-passes | FileCheck %s --check-prefixes=CHECK,CHECK-SIZE
void t1(int *a) {
delete a;
}
struct S {
int a;
};
// POD types.
// CHECK-LABEL: define{{.*}} void @_Z2t3P1S
void t3(S *s) {
// CHECK: icmp {{.*}} null
// CHECK: br i1
// CHECK: call void @_ZdlPvm
// Check the delete is inside the 'if !null' check unless we're optimizing
// for size. FIXME: We could omit the branch entirely in this case.
// CHECK-NOSIZE-NEXT: br
// CHECK-SIZE-NEXT: ret
delete s;
}
// Non-POD
struct T {
~T();
int a;
};
// CHECK-LABEL: define{{.*}} void @_Z2t4P1T
void t4(T *t) {
// CHECK: call void @_ZN1TD1Ev
// CHECK-SIZE-NEXT: br
// CHECK: call void @_ZdlPvm
delete t;
}
// PR5102
template <typename T>
class A {
public: operator T *() const;
};
void f() {
A<char*> a;
delete a;
}
namespace test0 {
struct A {
void *operator new(__SIZE_TYPE__ sz);
void operator delete(void *p) { ::operator delete(p); }
~A() {}
};
// CHECK-LABEL: define{{.*}} void @_ZN5test04testEPNS_1AE(
void test(A *a) {
// CHECK: call void @_ZN5test01AD1Ev
// CHECK-SIZE-NEXT: br
// CHECK: call void @_ZN5test01AdlEPv
delete a;
}
// CHECK-LABEL: define linkonce_odr void @_ZN5test01AD1Ev(ptr {{[^,]*}} %this) unnamed_addr
// CHECK-LABEL: define linkonce_odr void @_ZN5test01AdlEPv
}
namespace test1 {
struct A {
int x;
~A();
};
// CHECK-LABEL: define{{.*}} void @_ZN5test11fEPA10_A20_NS_1AE(
void f(A (*arr)[10][20]) {
delete [] arr;
// CHECK: icmp eq ptr [[PTR:%.*]], null
// CHECK-NEXT: br i1
// CHECK: [[ALLOC:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 -8
// CHECK-NEXT: [[COUNT:%.*]] = load i64, ptr [[ALLOC]]
// CHECK: [[END:%.*]] = getelementptr inbounds [[A:%.*]], ptr [[PTR]], i64 [[COUNT]]
// CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq ptr [[PTR]], [[END]]
// CHECK-NEXT: br i1 [[ISEMPTY]],
// CHECK: [[PAST:%.*]] = phi ptr [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
// CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]], ptr [[PAST]], i64 -1
// CHECK-NEXT: call void @_ZN5test11AD1Ev(ptr {{[^,]*}} [[CUR]])
// CHECK-NEXT: [[ISDONE:%.*]] = icmp eq ptr [[CUR]], [[PTR]]
// CHECK-NEXT: br i1 [[ISDONE]]
// CHECK: [[MUL:%.*]] = mul i64 4, [[COUNT]]
// CHECK-NEXT: [[SIZE:%.*]] = add i64 [[MUL]], 8
// CHECK-NEXT: call void @_ZdaPvm(ptr noundef [[ALLOC]], i64 noundef [[SIZE]])
}
// CHECK-LABEL: define{{.*}} void @_ZN5test11gEPA_NS_1AE(
void g(A (*arr)[]) {
delete [] arr;
// CHECK: icmp eq ptr [[PTR:%.*]], null
// CHECK-NEXT: br i1
// CHECK: [[ALLOC:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 -8
// CHECK-NEXT: [[COUNT:%.*]] = load i64, ptr [[ALLOC]]
// CHECK: [[END:%.*]] = getelementptr inbounds [[A:%.*]], ptr [[PTR]], i64 [[COUNT]]
// CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq ptr [[PTR]], [[END]]
// CHECK-NEXT: br i1 [[ISEMPTY]],
// CHECK: [[PAST:%.*]] = phi ptr [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
// CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]], ptr [[PAST]], i64 -1
// CHECK-NEXT: call void @_ZN5test11AD1Ev(ptr {{[^,]*}} [[CUR]])
// CHECK-NEXT: [[ISDONE:%.*]] = icmp eq ptr [[CUR]], [[PTR]]
// CHECK-NEXT: br i1 [[ISDONE]]
// CHECK: call void @_ZdaPv(ptr noundef [[ALLOC]])
}
}
namespace test2 {
// CHECK-LABEL: define{{.*}} void @_ZN5test21fEPb
void f(bool *b) {
// CHECK: call void @_ZdlPvm(ptr{{.*}}i64
delete b;
// CHECK: call void @_ZdaPv(ptr
delete [] b;
}
}
namespace test3 {
void f(int a[10][20]) {
// CHECK: call void @_ZdaPv(ptr
delete a;
}
}
namespace test4 {
// PR10341: ::delete with a virtual destructor
struct X {
virtual ~X();
void operator delete (void *);
};
// CHECK-LABEL: define{{.*}} void @_ZN5test421global_delete_virtualEPNS_1XE
void global_delete_virtual(X *xp) {
// Load the offset-to-top from the vtable and apply it.
// This has to be done first because the dtor can mess it up.
// CHECK: [[XP:%.*]] = load ptr, ptr [[XP_ADDR:%.*]]
// CHECK: [[VTABLE:%.*]] = load ptr, ptr [[XP]]
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds i64, ptr [[VTABLE]], i64 -2
// CHECK-NEXT: [[OFFSET:%.*]] = load i64, ptr [[T0]], align 8
// CHECK-NEXT: [[ALLOCATED:%.*]] = getelementptr inbounds i8, ptr [[XP]], i64 [[OFFSET]]
// Load the complete-object destructor (not the deleting destructor)
// and call noundef it.
// CHECK-NEXT: [[VTABLE:%.*]] = load ptr, ptr [[XP:%.*]]
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds ptr, ptr [[VTABLE]], i64 0
// CHECK-NEXT: [[DTOR:%.*]] = load ptr, ptr [[T0]]
// CHECK-NEXT: call void [[DTOR]](ptr {{[^,]*}} [[OBJ:%.*]])
// Call the global operator delete.
// CHECK-NEXT: call void @_ZdlPvm(ptr noundef [[ALLOCATED]], i64 noundef 8) [[NUW:#[0-9]+]]
::delete xp;
}
}
namespace test5 {
struct Incomplete;
// CHECK-LABEL: define{{.*}} void @_ZN5test523array_delete_incompleteEPNS_10IncompleteES1_
void array_delete_incomplete(Incomplete *p1, Incomplete *p2) {
// CHECK: call void @_ZdlPv
delete p1;
// CHECK: call void @_ZdaPv
delete [] p2;
}
}
// CHECK: attributes [[NUW]] = {{[{].*}} nounwind {{.*[}]}}
|
