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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++20 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKCXX20
// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -fsanitize=signed-integer-overflow -o - | FileCheck --check-prefix=SIO %s
// CHECK: @[[ABC4:.*]] = {{.*}} constant [4 x i8] c"abc\00"
// CHECK: @[[ABC15:.*]] = {{.*}} constant [15 x i8] c"abc\00\00\00\00
// CHECK-LABEL: define{{.*}} void @_Z2fni
void fn(int n) {
// CHECK: icmp ult i{{32|64}} %{{[^ ]+}}, 3
// CHECK: store i32 1
// CHECK: store i32 2
// CHECK: store i32 3
// CHECK: sub {{.*}}, 12
// CHECK: call void @llvm.memset
new int[n] { 1, 2, 3 };
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z8fn_pareni
void fn_paren(int n) {
// CHECKCXX20: icmp ult i{{32|64}} %{{[^ ]+}}, 3
// CHECKCXX20: store i32 1
// CHECKCXX20: store i32 2
// CHECKCXX20: store i32 3
// CHECKCXX20: sub {{.*}}, 12
// CHECKCXX20: call void @llvm.memset
new int[n](1, 2, 3);
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z11const_exactv
void const_exact() {
// CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
// CHECK-NOT: icmp eq ptr
new int[3] { 1, 2, 3 };
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z17const_exact_parenv
void const_exact_paren() {
// CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
// CHECKCXX20-NOT: icmp eq ptr
new int[3](1, 2, 3);
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z16const_sufficientv
void const_sufficient() {
// CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
new int[4] { 1, 2, 3 };
// CHECK: ret void
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z22const_sufficient_parenv
void const_sufficient_paren() {
// CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
new int[4](1, 2, 3);
// CHECKCXX20: ret void
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv
void check_array_value_init() {
struct S;
new (int S::*[3][4][5]) ();
// CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}})
// CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 60
// CHECK: phi
// CHECK: store i{{32|64}} -1,
// CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 1
// CHECK: icmp eq
// CHECK: br i1
}
// CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti
void string_nonconst(int n) {
// CHECK: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
// CHECK: select
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
// CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4
// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
new char[n] { "abc" };
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
void string_nonconst_paren(int n) {
// CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
// CHECKCXX20: select
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
// CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
new char[n]("abc");
}
// CHECKCXX20-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
void string_nonconst_paren_extra_paren(int n) {
// CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
// CHECKCXX20: select
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
// CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
new char[n](("abc"));
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z12string_exactv
void string_exact() {
// CHECK-NOT: icmp
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECK-NOT: memset
new char[4] { "abc" };
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z18string_exact_parenv
void string_exact_paren() {
// CHECKCXX20-NOT: icmp
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECKCXX20-NOT: memset
new char[4]("abc");
}
// CHECKCXX20-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv
void string_exact_paren_extension() {
// CHECKCXX20-NOT: icmp
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
// CHECKCXX20-NOT: memset
new char[4](__extension__ "abc");
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv
void string_sufficient() {
// CHECK-NOT: icmp
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
// CHECK-NOT: memset
new char[15] { "abc" };
}
#if __cplusplus >= 202002L
// CHECKCXX20-LABEL: define{{.*}} void @_Z23string_sufficient_parenv
void string_sufficient_paren() {
// CHECKCXX20-NOT: icmp
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
// CHECKCXX20-NOT: memset
new char[15]("abc");
}
#endif
// CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv
void aggr_exact() {
// CHECK-NOT: icmp
// CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16)
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
// CHECK: store i32 1, ptr %[[FIELD]]
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
// CHECK: store i32 2, ptr %[[FIELD]]
// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
// CHECK: store i32 3, ptr %[[FIELD]]
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
// CHECK: store i32 0, ptr %[[FIELD]]
// CHECK-NOT: store
// CHECK-NOT: memset
struct Aggr { int a, b; };
new Aggr[2] { 1, 2, 3 };
}
// CHECK-LABEL: define{{.*}} void @_Z15aggr_sufficienti
void aggr_sufficient(int n) {
// CHECK: icmp ult i32 %{{.*}}, 2
// CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
// CHECK: store i32 1, ptr %[[FIELD]]
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
// CHECK: store i32 2, ptr %[[FIELD]]
// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
// CHECK: store i32 3, ptr %[[FIELD]]
// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
// CHECK: store i32 0, ptr %[[FIELD]]
// CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}}
// CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16
// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]],
struct Aggr { int a, b; };
new Aggr[n] { 1, 2, 3 };
}
// SIO-LABEL: define{{.*}} void @_Z14constexpr_testv
void constexpr_test() {
// SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4)
new int[0+1]{0};
}
// CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv
void unknown_bound() {
struct Aggr { int x, y, z; };
new Aggr[]{1, 2, 3, 4};
// CHECK: call {{.*}}_Znaj(i32 noundef 24)
// CHECK: store i32 1
// CHECK: store i32 2
// CHECK: store i32 3
// CHECK: store i32 4
// CHECK: store i32 0
// CHECK: store i32 0
// CHECK-NOT: store
// CHECK: }
}
// CHECK-LABEL: define{{.*}} void @_Z20unknown_bound_stringv
void unknown_bound_string() {
new char[]{"hello"};
// CHECK: call {{.*}}_Znaj(i32 noundef 6)
// CHECK: memcpy{{.*}} i32 6,
}
|
