Debian Codegraph @

gcc/testsuite/gcc.c-torture/execute/memset-2.c

raw
1 /* Copyright (C) 2002 Free Software Foundation.
2
3 Test memset with various combinations of pointer alignments and constant
4 lengths to make sure any optimizations in the compiler are correct.
5
6 Written by Roger Sayle, April 22, 2002. */
7
8 #include <string.h>
9
10 void abort (void);
11 void exit (int);
12
13 #ifndef MAX_OFFSET
14 #define MAX_OFFSET (sizeof (long long))
15 #endif
16
17 #ifndef MAX_COPY
18 #define MAX_COPY 15
19 #endif
20
21 #ifndef MAX_EXTRA
22 #define MAX_EXTRA (sizeof (long long))
23 #endif
24
25 #define MAX_LENGTH (MAX_OFFSET + MAX_COPY + MAX_EXTRA)
26
27 static union {
28 char buf[MAX_LENGTH];
29 long long align_int;
30 long double align_fp;
31 } u;
32
33 char A = 'A';
34
35 void reset ()
36 {
37 int i;
38
39 for (i = 0; i < MAX_LENGTH; i++)
40 u.buf[i] = 'a';
41 }
42
43 void check (int off, int len, int ch)
44 {
45 char *q;
46 int i;
47
48 q = u.buf;
49 for (i = 0; i < off; i++, q++)
50 if (*q != 'a')
51 abort ();
52
53 for (i = 0; i < len; i++, q++)
54 if (*q != ch)
55 abort ();
56
57 for (i = 0; i < MAX_EXTRA; i++, q++)
58 if (*q != 'a')
59 abort ();
60 }
61
62 int main ()
63 {
64 int off;
65 char *p;
66
67 /* len == 1 */
68 for (off = 0; off < MAX_OFFSET; off++)
69 {
70 reset ();
71
72 p = memset (u.buf + off, '\0', 1);
73 if (p != u.buf + off) abort ();
74 check (off, 1, '\0');
75
76 p = memset (u.buf + off, A, 1);
77 if (p != u.buf + off) abort ();
78 check (off, 1, 'A');
79
80 p = memset (u.buf + off, 'B', 1);
81 if (p != u.buf + off) abort ();
82 check (off, 1, 'B');
83 }
84
85 /* len == 2 */
86 for (off = 0; off < MAX_OFFSET; off++)
87 {
88 reset ();
89
90 p = memset (u.buf + off, '\0', 2);
91 if (p != u.buf + off) abort ();
92 check (off, 2, '\0');
93
94 p = memset (u.buf + off, A, 2);
95 if (p != u.buf + off) abort ();
96 check (off, 2, 'A');
97
98 p = memset (u.buf + off, 'B', 2);
99 if (p != u.buf + off) abort ();
100 check (off, 2, 'B');
101 }
102
103 /* len == 3 */
104 for (off = 0; off < MAX_OFFSET; off++)
105 {
106 reset ();
107
108 p = memset (u.buf + off, '\0', 3);
109 if (p != u.buf + off) abort ();
110 check (off, 3, '\0');
111
112 p = memset (u.buf + off, A, 3);
113 if (p != u.buf + off) abort ();
114 check (off, 3, 'A');
115
116 p = memset (u.buf + off, 'B', 3);
117 if (p != u.buf + off) abort ();
118 check (off, 3, 'B');
119 }
120
121 /* len == 4 */
122 for (off = 0; off < MAX_OFFSET; off++)
123 {
124 reset ();
125
126 p = memset (u.buf + off, '\0', 4);
127 if (p != u.buf + off) abort ();
128 check (off, 4, '\0');
129
130 p = memset (u.buf + off, A, 4);
131 if (p != u.buf + off) abort ();
132 check (off, 4, 'A');
133
134 p = memset (u.buf + off, 'B', 4);
135 if (p != u.buf + off) abort ();
136 check (off, 4, 'B');
137 }
138
139 /* len == 5 */
140 for (off = 0; off < MAX_OFFSET; off++)
141 {
142 reset ();
143
144 p = memset (u.buf + off, '\0', 5);
145 if (p != u.buf + off) abort ();
146 check (off, 5, '\0');
147
148 p = memset (u.buf + off, A, 5);
149 if (p != u.buf + off) abort ();
150 check (off, 5, 'A');
151
152 p = memset (u.buf + off, 'B', 5);
153 if (p != u.buf + off) abort ();
154 check (off, 5, 'B');
155 }
156
157 /* len == 6 */
158 for (off = 0; off < MAX_OFFSET; off++)
159 {
160 reset ();
161
162 p = memset (u.buf + off, '\0', 6);
163 if (p != u.buf + off) abort ();
164 check (off, 6, '\0');
165
166 p = memset (u.buf + off, A, 6);
167 if (p != u.buf + off) abort ();
168 check (off, 6, 'A');
169
170 p = memset (u.buf + off, 'B', 6);
171 if (p != u.buf + off) abort ();
172 check (off, 6, 'B');
173 }
174
175 /* len == 7 */
176 for (off = 0; off < MAX_OFFSET; off++)
177 {
178 reset ();
179
180 p = memset (u.buf + off, '\0', 7);
181 if (p != u.buf + off) abort ();
182 check (off, 7, '\0');
183
184 p = memset (u.buf + off, A, 7);
185 if (p != u.buf + off) abort ();
186 check (off, 7, 'A');
187
188 p = memset (u.buf + off, 'B', 7);
189 if (p != u.buf + off) abort ();
190 check (off, 7, 'B');
191 }
192
193 /* len == 8 */
194 for (off = 0; off < MAX_OFFSET; off++)
195 {
196 reset ();
197
198 p = memset (u.buf + off, '\0', 8);
199 if (p != u.buf + off) abort ();
200 check (off, 8, '\0');
201
202 p = memset (u.buf + off, A, 8);
203 if (p != u.buf + off) abort ();
204 check (off, 8, 'A');
205
206 p = memset (u.buf + off, 'B', 8);
207 if (p != u.buf + off) abort ();
208 check (off, 8, 'B');
209 }
210
211 /* len == 9 */
212 for (off = 0; off < MAX_OFFSET; off++)
213 {
214 reset ();
215
216 p = memset (u.buf + off, '\0', 9);
217 if (p != u.buf + off) abort ();
218 check (off, 9, '\0');
219
220 p = memset (u.buf + off, A, 9);
221 if (p != u.buf + off) abort ();
222 check (off, 9, 'A');
223
224 p = memset (u.buf + off, 'B', 9);
225 if (p != u.buf + off) abort ();
226 check (off, 9, 'B');
227 }
228
229 /* len == 10 */
230 for (off = 0; off < MAX_OFFSET; off++)
231 {
232 reset ();
233
234 p = memset (u.buf + off, '\0', 10);
235 if (p != u.buf + off) abort ();
236 check (off, 10, '\0');
237
238 p = memset (u.buf + off, A, 10);
239 if (p != u.buf + off) abort ();
240 check (off, 10, 'A');
241
242 p = memset (u.buf + off, 'B', 10);
243 if (p != u.buf + off) abort ();
244 check (off, 10, 'B');
245 }
246
247 /* len == 11 */
248 for (off = 0; off < MAX_OFFSET; off++)
249 {
250 reset ();
251
252 p = memset (u.buf + off, '\0', 11);
253 if (p != u.buf + off) abort ();
254 check (off, 11, '\0');
255
256 p = memset (u.buf + off, A, 11);
257 if (p != u.buf + off) abort ();
258 check (off, 11, 'A');
259
260 p = memset (u.buf + off, 'B', 11);
261 if (p != u.buf + off) abort ();
262 check (off, 11, 'B');
263 }
264
265 /* len == 12 */
266 for (off = 0; off < MAX_OFFSET; off++)
267 {
268 reset ();
269
270 p = memset (u.buf + off, '\0', 12);
271 if (p != u.buf + off) abort ();
272 check (off, 12, '\0');
273
274 p = memset (u.buf + off, A, 12);
275 if (p != u.buf + off) abort ();
276 check (off, 12, 'A');
277
278 p = memset (u.buf + off, 'B', 12);
279 if (p != u.buf + off) abort ();
280 check (off, 12, 'B');
281 }
282
283 /* len == 13 */
284 for (off = 0; off < MAX_OFFSET; off++)
285 {
286 reset ();
287
288 p = memset (u.buf + off, '\0', 13);
289 if (p != u.buf + off) abort ();
290 check (off, 13, '\0');
291
292 p = memset (u.buf + off, A, 13);
293 if (p != u.buf + off) abort ();
294 check (off, 13, 'A');
295
296 p = memset (u.buf + off, 'B', 13);
297 if (p != u.buf + off) abort ();
298 check (off, 13, 'B');
299 }
300
301 /* len == 14 */
302 for (off = 0; off < MAX_OFFSET; off++)
303 {
304 reset ();
305
306 p = memset (u.buf + off, '\0', 14);
307 if (p != u.buf + off) abort ();
308 check (off, 14, '\0');
309
310 p = memset (u.buf + off, A, 14);
311 if (p != u.buf + off) abort ();
312 check (off, 14, 'A');
313
314 p = memset (u.buf + off, 'B', 14);
315 if (p != u.buf + off) abort ();
316 check (off, 14, 'B');
317 }
318
319 /* len == 15 */
320 for (off = 0; off < MAX_OFFSET; off++)
321 {
322 reset ();
323
324 p = memset (u.buf + off, '\0', 15);
325 if (p != u.buf + off) abort ();
326 check (off, 15, '\0');
327
328 p = memset (u.buf + off, A, 15);
329 if (p != u.buf + off) abort ();
330 check (off, 15, 'A');
331
332 p = memset (u.buf + off, 'B', 15);
333 if (p != u.buf + off) abort ();
334 check (off, 15, 'B');
335 }
336
337 exit (0);
338 }
339