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
|
/* PR tree-optimization/81384 - built-in form of strnlen missing
Test to verify that strnlen built-in expansion works correctly
in the absence of tree strlen optimization.
{ dg-do compile }
{ dg-options "-O2 -Wall -Wno-stringop-overflow -fdump-tree-optimized" } */
#include "strlenopt.h"
#define PTRDIFF_MAX __PTRDIFF_MAX__
#define SIZE_MAX __SIZE_MAX__
typedef __SIZE_TYPE__ size_t;
extern void abort (void);
extern size_t strnlen (const char *, size_t);
#define CAT(x, y) x ## y
#define CONCAT(x, y) CAT (x, y)
#define FAILNAME(name) CONCAT (call_ ## name ##_on_line_, __LINE__)
#define FAIL(name) do { \
extern void FAILNAME (name) (void); \
FAILNAME (name)(); \
} while (0)
/* Macro to emit a call to funcation named
call_in_true_branch_not_eliminated_on_line_NNN()
for each call that's expected to be eliminated. The dg-final
scan-tree-dump-time directive at the bottom of the test verifies
that no such call appears in output. */
#define ELIM(expr) \
if (!(expr)) FAIL (in_true_branch_not_eliminated); else (void)0
/* Macro to emit a call to a function named
call_made_in_{true,false}_branch_on_line_NNN()
for each call that's expected to be retained. The dg-final
scan-tree-dump-time directive at the bottom of the test verifies
that the expected number of both kinds of calls appears in output
(a pair for each line with the invocation of the KEEP() macro. */
#define KEEP(expr) \
if (expr) \
FAIL (made_in_true_branch); \
else \
FAIL (made_in_false_branch)
extern char c;
extern char a1[1];
extern char a3[3];
extern char a5[5];
extern char a3_7[3][7];
extern char ax[];
void elim_strnlen_arr_cst (void)
{
/* The length of a string stored in a one-element array must be zero.
The result reported by strnlen() for such an array can be non-zero
only when the bound is equal to 1 (in which case the result must
be one). */
ELIM (strnlen (&c, 0) == 0);
ELIM (strnlen (&c, 1) < 2);
ELIM (strnlen (&c, 2) == 0);
ELIM (strnlen (&c, 9) == 0);
ELIM (strnlen (&c, PTRDIFF_MAX) == 0);
ELIM (strnlen (&c, SIZE_MAX) == 0);
ELIM (strnlen (&c, -1) == 0);
ELIM (strnlen (a1, 0) == 0);
ELIM (strnlen (a1, 1) < 2);
ELIM (strnlen (a1, 2) == 0);
ELIM (strnlen (a1, 9) == 0);
ELIM (strnlen (a1, PTRDIFF_MAX) == 0);
ELIM (strnlen (a1, SIZE_MAX) == 0);
ELIM (strnlen (a1, -1) == 0);
ELIM (strnlen (a3, 0) == 0);
ELIM (strnlen (a3, 1) < 2);
ELIM (strnlen (a3, 2) < 3);
ELIM (strnlen (a3, 3) < 4);
ELIM (strnlen (a3, 9) < 4);
ELIM (strnlen (a3, PTRDIFF_MAX) < 4);
ELIM (strnlen (a3, SIZE_MAX) < 4);
ELIM (strnlen (a3, -1) < 4);
ELIM (strnlen (a3_7[0], 0) == 0);
ELIM (strnlen (a3_7[0], 1) < 2);
ELIM (strnlen (a3_7[0], 2) < 3);
ELIM (strnlen (a3_7[0], 3) < 4);
ELIM (strnlen (a3_7[0], 9) <= 9);
ELIM (strnlen (a3_7[0], PTRDIFF_MAX) <= sizeof a3_7);
ELIM (strnlen (a3_7[0], SIZE_MAX) <= sizeof a3_7);
ELIM (strnlen (a3_7[0], -1) <= sizeof a3_7);
ELIM (strnlen (a3_7[2], 0) == 0);
ELIM (strnlen (a3_7[2], 1) < 2);
ELIM (strnlen (a3_7[2], 2) < 3);
ELIM (strnlen (a3_7[2], 3) < 4);
ELIM (strnlen (a3_7[2], 9) <= 9);
ELIM (strnlen (a3_7[2], PTRDIFF_MAX) < sizeof a3_7);
ELIM (strnlen (a3_7[2], SIZE_MAX) < sizeof a3_7);
ELIM (strnlen (a3_7[2], -1) < sizeof a3_7);
ELIM (strnlen ((char*)a3_7, 0) == 0);
ELIM (strnlen ((char*)a3_7, 1) < 2);
ELIM (strnlen ((char*)a3_7, 2) < 3);
ELIM (strnlen ((char*)a3_7, 3) < 4);
ELIM (strnlen ((char*)a3_7, 9) < 10);
ELIM (strnlen ((char*)a3_7, 19) < 20);
ELIM (strnlen ((char*)a3_7, 21) <= sizeof a3_7);
ELIM (strnlen ((char*)a3_7, 23) <= sizeof a3_7);
ELIM (strnlen ((char*)a3_7, PTRDIFF_MAX) <= sizeof a3_7);
ELIM (strnlen ((char*)a3_7, SIZE_MAX) <= sizeof a3_7);
ELIM (strnlen ((char*)a3_7, -1) <= sizeof a3_7);
ELIM (strnlen (ax, 0) == 0);
ELIM (strnlen (ax, 1) < 2);
ELIM (strnlen (ax, 2) < 3);
ELIM (strnlen (ax, 9) < 10);
ELIM (strnlen (ax, PTRDIFF_MAX) < PTRDIFF_MAX);
ELIM (strnlen (ax, SIZE_MAX) < PTRDIFF_MAX);
ELIM (strnlen (ax, -1) < PTRDIFF_MAX);
}
void elim_strnlen_str_cst (void)
{
const char *s0 = "";
const char *s1 = "1";
const char *s3 = "123";
ELIM (strnlen (s0, 0) == 0);
ELIM (strnlen (s0, 1) == 0);
ELIM (strnlen (s0, 9) == 0);
ELIM (strnlen (s0, PTRDIFF_MAX) == 0);
ELIM (strnlen (s0, SIZE_MAX) == 0);
ELIM (strnlen (s0, -1) == 0);
ELIM (strnlen (s1, 0) == 0);
ELIM (strnlen (s1, 1) == 1);
ELIM (strnlen (s1, 9) == 1);
ELIM (strnlen (s1, PTRDIFF_MAX) == 1);
ELIM (strnlen (s1, SIZE_MAX) == 1);
ELIM (strnlen (s1, -2) == 1);
ELIM (strnlen (s3, 0) == 0);
ELIM (strnlen (s3, 1) == 1);
ELIM (strnlen (s3, 2) == 2);
ELIM (strnlen (s3, 3) == 3);
ELIM (strnlen (s3, 9) == 3);
ELIM (strnlen (s3, PTRDIFF_MAX) == 3);
ELIM (strnlen (s3, SIZE_MAX) == 3);
ELIM (strnlen (s3, -2) == 3);
}
void elim_strnlen_range (char *s)
{
const char *s0 = "";
const char *s1 = "1";
const char *s3 = "123";
size_t n_0_1 = (size_t)s & 1;
size_t n_0_2 = ((size_t)s & 3) < 3 ? ((size_t)s & 3) : 2;
size_t n_0_3 = (size_t)s & 3;
size_t n_1_2 = n_0_1 + 1;
ELIM (strnlen (s0, n_0_1) == 0);
ELIM (strnlen (s0, n_0_2) == 0);
ELIM (strnlen (s0, n_1_2) == 0);
ELIM (strnlen (s1, n_0_1) < 2);
ELIM (strnlen (s1, n_0_2) < 2);
ELIM (strnlen (s1, n_0_3) < 2);
ELIM (strnlen (s1, n_1_2) > 0);
ELIM (strnlen (s1, n_1_2) < 2);
ELIM (strnlen (s3, n_0_1) < 2);
ELIM (strnlen (s3, n_0_2) < 3);
ELIM (strnlen (s3, n_0_3) < 4);
ELIM (strnlen (s3, n_1_2) > 0);
ELIM (strnlen (s3, n_1_2) < 4);
}
#line 1000
void keep_strnlen_arr_cst (void)
{
KEEP (strnlen (&c, 1) == 0);
KEEP (strnlen (&c, 1) == 1);
KEEP (strnlen (a1, 1) == 0);
KEEP (strnlen (a1, 1) == 1);
KEEP (strnlen (ax, 9) < 9);
}
struct FlexArrays
{
char c;
char a0[0]; /* Access to internal zero-length arrays are undefined. */
char a1[1];
};
void keep_strnlen_memarr_cst (struct FlexArrays *p)
{
KEEP (strnlen (&p->c, 1) == 0);
KEEP (strnlen (&p->c, 1) == 1);
#if 0
/* Accesses to internal zero-length arrays are undefined so avoid
exercising them. */
KEEP (strnlen (p->a0, 1) == 0);
KEEP (strnlen (p->a0, 1) == 1);
KEEP (strnlen (p->a0, 9) < 9);
#endif
KEEP (strnlen (p->a1, 1) == 0);
KEEP (strnlen (p->a1, 1) == 1);
KEEP (strnlen (p->a1, 2) == 0);
KEEP (strnlen (p->a1, 2) == 1);
KEEP (strnlen (p->a1, 2) == 2);
KEEP (strnlen (p->a1, 9) < 9);
}
/* { dg-final { scan-tree-dump-times "call_in_true_branch_not_eliminated_" 0 "optimized" } }
{ dg-final { scan-tree-dump-times "call_made_in_true_branch_on_line_1\[0-9\]\[0-9\]\[0-9\]" 13 "optimized" } }
{ dg-final { scan-tree-dump-times "call_made_in_false_branch_on_line_1\[0-9\]\[0-9\]\[0-9\]" 13 "optimized" } } */
|
