?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2008-05-30 Vladimir Makarov <vmakarov@redhat.com>
[official-gcc.git] / gcc / testsuite / g++.dg / compat / struct-layout-1_generate.c
blobe6f4cb969edcd107751452e7157865713b469d41
1 /* Structure layout test generator.
2 Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3 Contributed by Jakub Jelinek <jakub@redhat.com>.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21
22 /* Compile with gcc -o struct-layout-1_generate{,.c} generate_random{,_r}.c */
23
24 /* N.B. -- This program cannot use libiberty as that will not work
25 when testing an installed compiler. */
26 #include <limits.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <stddef.h>
31 /* We use our own pseudo-random number generator, so that it gives the same
32 values on all hosts. */
33 #include "../../gcc.dg/compat/generate-random.h"
34
35 #if LLONG_MAX != 9223372036854775807LL && __LONG_LONG_MAX__ != 9223372036854775807LL
36 # error Need 64-bit long long
37 #endif
38
39 #if defined __MSVCRT__
40 #define COMPAT_PRLL "I64"
41 #else
42 #define COMPAT_PRLL "ll"
43 #endif
44
45 const char *dg_options[] = {
46 "/* { dg-options \"%s-I%s\" } */\n",
47 "/* { dg-options \"%s-I%s -mno-mmx\" { target i?86-*-* x86_64-*-* } } */\n",
48 "/* { dg-options \"%s-I%s -fno-common\" { target hppa*-*-hpux* } } */\n",
49 "/* { dg-options \"%s-I%s -mno-base-addresses\" { target mmix-*-* } } */\n"
50 #define NDG_OPTIONS (sizeof (dg_options) / sizeof (dg_options[0]))
51 };
52
53 typedef unsigned int hashval_t;
54
55 enum TYPE
56 {
57 TYPE_INT,
58 TYPE_UINT,
59 TYPE_FLOAT,
60 TYPE_SENUM,
61 TYPE_UENUM,
62 TYPE_PTR,
63 TYPE_FNPTR,
64 TYPE_OTHER
65 };
66
67 struct types
68 {
69 const char *name;
70 enum TYPE type;
71 unsigned long long int maxval;
72 char bitfld;
73 };
74
75 struct types base_types[] = {
76 /* As we don't know whether char will be signed or not, just limit ourselves
77 to unsigned values less than maximum signed char value. */
78 { "char", TYPE_UINT, 127, 'C' },
79 { "signed char", TYPE_INT, 127, 'C' },
80 { "unsigned char", TYPE_UINT, 255, 'C' },
81 { "short int", TYPE_INT, 32767, 'S' },
82 { "unsigned short int", TYPE_UINT, 65535, 'S' },
83 { "int", TYPE_INT, 2147483647, 'I' },
84 { "unsigned int", TYPE_UINT, 4294967295U, 'I' },
85 { "long int", TYPE_INT, 9223372036854775807LL, 'L' },
86 { "unsigned long int", TYPE_UINT, 18446744073709551615ULL, 'L' },
87 { "long long int", TYPE_INT, 9223372036854775807LL, 'Q' },
88 { "unsigned long long int", TYPE_UINT, 18446744073709551615ULL, 'Q' },
89 { "bool", TYPE_UINT, 1, 'B' },
90 { "void *", TYPE_PTR, 0, 0 },
91 { "char *", TYPE_PTR, 0, 0 },
92 { "int *", TYPE_PTR, 0, 0 },
93 { "float", TYPE_FLOAT, 0, 0 },
94 { "double", TYPE_FLOAT, 0, 0 },
95 { "long double", TYPE_FLOAT, 0, 0 },
96 #define NTYPES1 18
97 { "Tchar", TYPE_UINT, 127, 'C' },
98 { "Tschar", TYPE_INT, 127, 'C' },
99 { "Tuchar", TYPE_UINT, 255, 'C' },
100 { "Tshort", TYPE_INT, 32767, 'S' },
101 { "Tushort", TYPE_UINT, 65535, 'S' },
102 { "Tint", TYPE_INT, 2147483647, 'I' },
103 { "Tuint", TYPE_UINT, 4294967295U, 'I' },
104 { "Tlong", TYPE_INT, 9223372036854775807LL, 'L' },
105 { "Tulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
106 { "Tllong", TYPE_INT, 9223372036854775807LL, 'Q' },
107 { "Tullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
108 { "Tbool", TYPE_UINT, 1, 'B' },
109 { "size_t", TYPE_UINT, 18446744073709551615ULL, 0 },
110 { "Tptr", TYPE_PTR, 0, 0 },
111 { "Tcptr", TYPE_PTR, 0, 0 },
112 { "Tiptr", TYPE_PTR, 0, 0 },
113 { "Tfnptr", TYPE_FNPTR, 0, 0 },
114 { "Tfloat", TYPE_FLOAT, 0, 0 },
115 { "Tdouble", TYPE_FLOAT, 0, 0 },
116 { "Tldouble", TYPE_FLOAT, 0, 0 },
117 { "enum E0", TYPE_UENUM, 0, ' ' },
118 { "enum E1", TYPE_UENUM, 1, ' ' },
119 { "enum E2", TYPE_SENUM, 3, ' ' },
120 { "enum E3", TYPE_SENUM, 127, ' ' },
121 { "enum E4", TYPE_UENUM, 255, ' ' },
122 { "enum E5", TYPE_SENUM, 32767, ' ' },
123 { "enum E6", TYPE_UENUM, 65535, ' ' },
124 { "enum E7", TYPE_SENUM, 2147483647, ' ' },
125 { "enum E8", TYPE_UENUM, 4294967295U, ' ' },
126 { "enum E9", TYPE_SENUM, 1099511627775LL, ' ' },
127 { "TE0", TYPE_UENUM, 0, ' ' },
128 { "TE1", TYPE_UENUM, 1, ' ' },
129 { "TE2", TYPE_SENUM, 3, ' ' },
130 { "TE3", TYPE_SENUM, 127, ' ' },
131 { "TE4", TYPE_UENUM, 255, ' ' },
132 { "TE5", TYPE_SENUM, 32767, ' ' },
133 { "TE6", TYPE_UENUM, 65535, ' ' },
134 { "TE7", TYPE_SENUM, 2147483647, ' ' },
135 { "TE8", TYPE_UENUM, 4294967295U, ' ' },
136 { "TE9", TYPE_SENUM, 1099511627775LL, ' ' },
137 /* vector-defs.h typedefs */
138 { "qi", TYPE_INT, 127, 0 },
139 { "hi", TYPE_INT, 32767, 0 },
140 { "si", TYPE_INT, 2147483647, 0 },
141 { "di", TYPE_INT, 9223372036854775807LL, 0 },
142 { "sf", TYPE_FLOAT, 0, 0 },
143 { "df", TYPE_FLOAT, 0, 0 }
144 #define NTYPES2 (sizeof (base_types) / sizeof (base_types[0]))
145 };
146 struct types vector_types[] = {
147 /* vector-defs.h typedefs */
148 { "v8qi", TYPE_OTHER, 0, 0 },
149 { "v16qi", TYPE_OTHER, 0, 0 },
150 { "v2hi", TYPE_OTHER, 0, 0 },
151 { "v4hi", TYPE_OTHER, 0, 0 },
152 { "v8hi", TYPE_OTHER, 0, 0 },
153 { "v2si", TYPE_OTHER, 0, 0 },
154 { "v4si", TYPE_OTHER, 0, 0 },
155 { "v1di", TYPE_OTHER, 0, 0 },
156 { "v2di", TYPE_OTHER, 0, 0 },
157 { "v2sf", TYPE_OTHER, 0, 0 },
158 { "v4sf", TYPE_OTHER, 0, 0 },
159 { "v16sf", TYPE_OTHER, 0, 0 },
160 { "v2df", TYPE_OTHER, 0, 0 },
161 { "u8qi", TYPE_OTHER, 0, 0 },
162 { "u16qi", TYPE_OTHER, 0, 0 },
163 { "u2hi", TYPE_OTHER, 0, 0 },
164 { "u4hi", TYPE_OTHER, 0, 0 },
165 { "u8hi", TYPE_OTHER, 0, 0 },
166 { "u2si", TYPE_OTHER, 0, 0 },
167 { "u4si", TYPE_OTHER, 0, 0 },
168 { "u1di", TYPE_OTHER, 0, 0 },
169 { "u2di", TYPE_OTHER, 0, 0 },
170 { "u2sf", TYPE_OTHER, 0, 0 },
171 { "u4sf", TYPE_OTHER, 0, 0 },
172 { "u16sf", TYPE_OTHER, 0, 0 },
173 { "u2df", TYPE_OTHER, 0, 0 },
174 { "__m64", TYPE_OTHER, 0, 0 },
175 { "__m128", TYPE_OTHER, 0, 0 }
176 #define NVTYPES2 (sizeof (vector_types) / sizeof (vector_types[0]))
177 };
178 struct types attrib_types[] = {
179 { "Talchar", TYPE_UINT, 127, 'C' },
180 { "Talschar", TYPE_INT, 127, 'C' },
181 { "Taluchar", TYPE_UINT, 255, 'C' },
182 { "Talshort", TYPE_INT, 32767, 'S' },
183 { "Talushort", TYPE_UINT, 65535, 'S' },
184 { "Talint", TYPE_INT, 2147483647, 'I' },
185 { "Taluint", TYPE_UINT, 4294967295U, 'I' },
186 { "Tallong", TYPE_INT, 9223372036854775807LL, 'L' },
187 { "Talulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
188 { "Talllong", TYPE_INT, 9223372036854775807LL, 'Q' },
189 { "Talullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
190 { "Talbool", TYPE_UINT, 1, 'B' },
191 { "Talptr", TYPE_PTR, 0, 0 },
192 { "Talcptr", TYPE_PTR, 0, 0 },
193 { "Taliptr", TYPE_PTR, 0, 0 },
194 { "Talfloat", TYPE_FLOAT, 0, 0 },
195 { "Taldouble", TYPE_FLOAT, 0, 0 },
196 { "Talldouble", TYPE_FLOAT, 0, 0 },
197 { "TalE0", TYPE_UENUM, 0, ' ' },
198 { "TalE1", TYPE_UENUM, 1, ' ' },
199 { "TalE2", TYPE_SENUM, 3, ' ' },
200 { "TalE3", TYPE_SENUM, 127, ' ' },
201 { "TalE4", TYPE_UENUM, 255, ' ' },
202 { "TalE5", TYPE_SENUM, 32767, ' ' },
203 { "TalE6", TYPE_UENUM, 65535, ' ' },
204 { "TalE7", TYPE_SENUM, 2147483647, ' ' },
205 { "TalE8", TYPE_UENUM, 4294967295U, ' ' },
206 { "TalE9", TYPE_SENUM, 1099511627775LL, ' ' },
207 { "Tal1char", TYPE_UINT, 127, 'C' },
208 { "Tal1schar", TYPE_INT, 127, 'C' },
209 { "Tal1uchar", TYPE_UINT, 255, 'C' },
210 { "Tal1short", TYPE_INT, 32767, 'S' },
211 { "Tal1ushort", TYPE_UINT, 65535, 'S' },
212 { "Tal1int", TYPE_INT, 2147483647, 'I' },
213 { "Tal1uint", TYPE_UINT, 4294967295U, 'I' },
214 { "Tal1long", TYPE_INT, 9223372036854775807LL, 'L' },
215 { "Tal1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
216 { "Tal1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
217 { "Tal1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
218 { "Tal1bool", TYPE_UINT, 1, 'B' },
219 { "Tal1ptr", TYPE_PTR, 0, 0 },
220 { "Tal1cptr", TYPE_PTR, 0, 0 },
221 { "Tal1iptr", TYPE_PTR, 0, 0 },
222 { "Tal1float", TYPE_FLOAT, 0, 0 },
223 { "Tal1double", TYPE_FLOAT, 0, 0 },
224 { "Tal1ldouble", TYPE_FLOAT, 0, 0 },
225 { "Tal1E0", TYPE_UENUM, 0, ' ' },
226 { "Tal1E1", TYPE_UENUM, 1, ' ' },
227 { "Tal1E2", TYPE_SENUM, 3, ' ' },
228 { "Tal1E3", TYPE_SENUM, 127, ' ' },
229 { "Tal1E4", TYPE_UENUM, 255, ' ' },
230 { "Tal1E5", TYPE_SENUM, 32767, ' ' },
231 { "Tal1E6", TYPE_UENUM, 65535, ' ' },
232 { "Tal1E7", TYPE_SENUM, 2147483647, ' ' },
233 { "Tal1E8", TYPE_UENUM, 4294967295U, ' ' },
234 { "Tal1E9", TYPE_SENUM, 1099511627775LL, ' ' },
235 { "Tal2char", TYPE_UINT, 127, 'C' },
236 { "Tal2schar", TYPE_INT, 127, 'C' },
237 { "Tal2uchar", TYPE_UINT, 255, 'C' },
238 { "Tal2short", TYPE_INT, 32767, 'S' },
239 { "Tal2ushort", TYPE_UINT, 65535, 'S' },
240 { "Tal2int", TYPE_INT, 2147483647, 'I' },
241 { "Tal2uint", TYPE_UINT, 4294967295U, 'I' },
242 { "Tal2long", TYPE_INT, 9223372036854775807LL, 'L' },
243 { "Tal2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
244 { "Tal2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
245 { "Tal2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
246 { "Tal2bool", TYPE_UINT, 1, 'B' },
247 { "Tal2ptr", TYPE_PTR, 0, 0 },
248 { "Tal2cptr", TYPE_PTR, 0, 0 },
249 { "Tal2iptr", TYPE_PTR, 0, 0 },
250 { "Tal2float", TYPE_FLOAT, 0, 0 },
251 { "Tal2double", TYPE_FLOAT, 0, 0 },
252 { "Tal2ldouble", TYPE_FLOAT, 0, 0 },
253 { "Tal2E0", TYPE_UENUM, 0, ' ' },
254 { "Tal2E1", TYPE_UENUM, 1, ' ' },
255 { "Tal2E2", TYPE_SENUM, 3, ' ' },
256 { "Tal2E3", TYPE_SENUM, 127, ' ' },
257 { "Tal2E4", TYPE_UENUM, 255, ' ' },
258 { "Tal2E5", TYPE_SENUM, 32767, ' ' },
259 { "Tal2E6", TYPE_UENUM, 65535, ' ' },
260 { "Tal2E7", TYPE_SENUM, 2147483647, ' ' },
261 { "Tal2E8", TYPE_UENUM, 4294967295U, ' ' },
262 { "Tal2E9", TYPE_SENUM, 1099511627775LL, ' ' },
263 { "Tal4char", TYPE_UINT, 127, 'C' },
264 { "Tal4schar", TYPE_INT, 127, 'C' },
265 { "Tal4uchar", TYPE_UINT, 255, 'C' },
266 { "Tal4short", TYPE_INT, 32767, 'S' },
267 { "Tal4ushort", TYPE_UINT, 65535, 'S' },
268 { "Tal4int", TYPE_INT, 2147483647, 'I' },
269 { "Tal4uint", TYPE_UINT, 4294967295U, 'I' },
270 { "Tal4long", TYPE_INT, 9223372036854775807LL, 'L' },
271 { "Tal4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
272 { "Tal4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
273 { "Tal4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
274 { "Tal4bool", TYPE_UINT, 1, 'B' },
275 { "Tal4ptr", TYPE_PTR, 0, 0 },
276 { "Tal4cptr", TYPE_PTR, 0, 0 },
277 { "Tal4iptr", TYPE_PTR, 0, 0 },
278 { "Tal4float", TYPE_FLOAT, 0, 0 },
279 { "Tal4double", TYPE_FLOAT, 0, 0 },
280 { "Tal4ldouble", TYPE_FLOAT, 0, 0 },
281 { "Tal4E0", TYPE_UENUM, 0, ' ' },
282 { "Tal4E1", TYPE_UENUM, 1, ' ' },
283 { "Tal4E2", TYPE_SENUM, 3, ' ' },
284 { "Tal4E3", TYPE_SENUM, 127, ' ' },
285 { "Tal4E4", TYPE_UENUM, 255, ' ' },
286 { "Tal4E5", TYPE_SENUM, 32767, ' ' },
287 { "Tal4E6", TYPE_UENUM, 65535, ' ' },
288 { "Tal4E7", TYPE_SENUM, 2147483647, ' ' },
289 { "Tal4E8", TYPE_UENUM, 4294967295U, ' ' },
290 { "Tal4E9", TYPE_SENUM, 1099511627775LL, ' ' },
291 { "Tal8char", TYPE_UINT, 127, 'C' },
292 { "Tal8schar", TYPE_INT, 127, 'C' },
293 { "Tal8uchar", TYPE_UINT, 255, 'C' },
294 { "Tal8short", TYPE_INT, 32767, 'S' },
295 { "Tal8ushort", TYPE_UINT, 65535, 'S' },
296 { "Tal8int", TYPE_INT, 2147483647, 'I' },
297 { "Tal8uint", TYPE_UINT, 4294967295U, 'I' },
298 { "Tal8long", TYPE_INT, 9223372036854775807LL, 'L' },
299 { "Tal8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
300 { "Tal8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
301 { "Tal8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
302 { "Tal8bool", TYPE_UINT, 1, 'B' },
303 { "Tal8ptr", TYPE_PTR, 0, 0 },
304 { "Tal8cptr", TYPE_PTR, 0, 0 },
305 { "Tal8iptr", TYPE_PTR, 0, 0 },
306 { "Tal8float", TYPE_FLOAT, 0, 0 },
307 { "Tal8double", TYPE_FLOAT, 0, 0 },
308 { "Tal8ldouble", TYPE_FLOAT, 0, 0 },
309 { "Tal8E0", TYPE_UENUM, 0, ' ' },
310 { "Tal8E1", TYPE_UENUM, 1, ' ' },
311 { "Tal8E2", TYPE_SENUM, 3, ' ' },
312 { "Tal8E3", TYPE_SENUM, 127, ' ' },
313 { "Tal8E4", TYPE_UENUM, 255, ' ' },
314 { "Tal8E5", TYPE_SENUM, 32767, ' ' },
315 { "Tal8E6", TYPE_UENUM, 65535, ' ' },
316 { "Tal8E7", TYPE_SENUM, 2147483647, ' ' },
317 { "Tal8E8", TYPE_UENUM, 4294967295U, ' ' },
318 { "Tal8E9", TYPE_SENUM, 1099511627775LL, ' ' },
319 { "Tal16char", TYPE_UINT, 127, 'C' },
320 { "Tal16schar", TYPE_INT, 127, 'C' },
321 { "Tal16uchar", TYPE_UINT, 255, 'C' },
322 { "Tal16short", TYPE_INT, 32767, 'S' },
323 { "Tal16ushort", TYPE_UINT, 65535, 'S' },
324 { "Tal16int", TYPE_INT, 2147483647, 'I' },
325 { "Tal16uint", TYPE_UINT, 4294967295U, 'I' },
326 { "Tal16long", TYPE_INT, 9223372036854775807LL, 'L' },
327 { "Tal16ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
328 { "Tal16llong", TYPE_INT, 9223372036854775807LL, 'Q' },
329 { "Tal16ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
330 { "Tal16bool", TYPE_UINT, 1, 'B' },
331 { "Tal16ptr", TYPE_PTR, 0, 0 },
332 { "Tal16cptr", TYPE_PTR, 0, 0 },
333 { "Tal16iptr", TYPE_PTR, 0, 0 },
334 { "Tal16float", TYPE_FLOAT, 0, 0 },
335 { "Tal16double", TYPE_FLOAT, 0, 0 },
336 { "Tal16ldouble", TYPE_FLOAT, 0, 0 },
337 { "Tal16E0", TYPE_UENUM, 0, ' ' },
338 { "Tal16E1", TYPE_UENUM, 1, ' ' },
339 { "Tal16E2", TYPE_SENUM, 3, ' ' },
340 { "Tal16E3", TYPE_SENUM, 127, ' ' },
341 { "Tal16E4", TYPE_UENUM, 255, ' ' },
342 { "Tal16E5", TYPE_SENUM, 32767, ' ' },
343 { "Tal16E6", TYPE_UENUM, 65535, ' ' },
344 { "Tal16E7", TYPE_SENUM, 2147483647, ' ' },
345 { "Tal16E8", TYPE_UENUM, 4294967295U, ' ' },
346 { "Tal16E9", TYPE_SENUM, 1099511627775LL, ' ' }
347 #define NATYPES2 (sizeof (attrib_types) / sizeof (attrib_types[0]))
348 };
349
350 struct types bitfld_types[NTYPES2];
351 int n_bitfld_types;
352 struct types aligned_bitfld_types[NATYPES2];
353 int n_aligned_bitfld_types;
354
355 const char *attributes[] = {
356 "atal",
357 "atpa",
358 "atal1",
359 "atal2",
360 "atal4",
361 "atal8",
362 "atal16",
363 #define NATTRIBS1 7
364 "atalpa",
365 "atpaal",
366 "atal1pa",
367 "atal2pa",
368 "atal4pa",
369 "atal8pa",
370 "atal16pa",
371 "atpaal1",
372 "atpaal2",
373 "atpaal4",
374 "atpaal8",
375 "atpaal16"
376 #define NATTRIBS2 (sizeof (attributes) / sizeof (attributes[0]))
377 };
378
379 enum ETYPE
380 {
381 ETYPE_TYPE,
382 ETYPE_ARRAY,
383 ETYPE_BITFLD,
384 ETYPE_STRUCT,
385 ETYPE_UNION,
386 ETYPE_STRUCT_ARRAY,
387 ETYPE_UNION_ARRAY
388 };
389
390 struct entry
391 {
392 #ifdef __GNUC__
393 enum ETYPE etype : 8;
394 #else
395 unsigned char etype;
396 #endif
397 unsigned short len;
398 unsigned char arr_len;
399 struct types *type;
400 const char *attrib;
401 /* Used to chain together entries in the hash table. */
402 struct entry *next;
403 };
404 struct types attrib_array_types[] = {
405 { "Talx1char", TYPE_UINT, 127, 'C' },
406 { "Talx1schar", TYPE_INT, 127, 'C' },
407 { "Talx1uchar", TYPE_UINT, 255, 'C' },
408 { "Talx1short", TYPE_INT, 32767, 'S' },
409 { "Talx1ushort", TYPE_UINT, 65535, 'S' },
410 { "Talx1int", TYPE_INT, 2147483647, 'I' },
411 { "Talx1uint", TYPE_UINT, 4294967295U, 'I' },
412 { "Talx1long", TYPE_INT, 9223372036854775807LL, 'L' },
413 { "Talx1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
414 { "Talx1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
415 { "Talx1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
416 { "Talx1bool", TYPE_UINT, 1, 'B' },
417 { "Talx1ptr", TYPE_PTR, 0, 0 },
418 { "Talx1cptr", TYPE_PTR, 0, 0 },
419 { "Talx1iptr", TYPE_PTR, 0, 0 },
420 { "Talx1float", TYPE_FLOAT, 0, 0 },
421 { "Talx1double", TYPE_FLOAT, 0, 0 },
422 { "Talx1ldouble", TYPE_FLOAT, 0, 0 },
423 { "Talx1E0", TYPE_UENUM, 0, ' ' },
424 { "Talx1E1", TYPE_UENUM, 1, ' ' },
425 { "Talx1E2", TYPE_SENUM, 3, ' ' },
426 { "Talx1E3", TYPE_SENUM, 127, ' ' },
427 { "Talx1E4", TYPE_UENUM, 255, ' ' },
428 { "Talx1E5", TYPE_SENUM, 32767, ' ' },
429 { "Talx1E6", TYPE_UENUM, 65535, ' ' },
430 { "Talx1E7", TYPE_SENUM, 2147483647, ' ' },
431 { "Talx1E8", TYPE_UENUM, 4294967295U, ' ' },
432 { "Talx1E9", TYPE_SENUM, 1099511627775LL, ' ' },
433 { "Talx2short", TYPE_INT, 32767, 'S' },
434 { "Talx2ushort", TYPE_UINT, 65535, 'S' },
435 { "Talx2int", TYPE_INT, 2147483647, 'I' },
436 { "Talx2uint", TYPE_UINT, 4294967295U, 'I' },
437 { "Talx2long", TYPE_INT, 9223372036854775807LL, 'L' },
438 { "Talx2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
439 { "Talx2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
440 { "Talx2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
441 { "Talx2ptr", TYPE_PTR, 0, 0 },
442 { "Talx2cptr", TYPE_PTR, 0, 0 },
443 { "Talx2iptr", TYPE_PTR, 0, 0 },
444 { "Talx2float", TYPE_FLOAT, 0, 0 },
445 { "Talx2double", TYPE_FLOAT, 0, 0 },
446 { "Talx2ldouble", TYPE_FLOAT, 0, 0 },
447 { "Talx2E0", TYPE_UENUM, 0, ' ' },
448 { "Talx2E1", TYPE_UENUM, 1, ' ' },
449 { "Talx2E2", TYPE_SENUM, 3, ' ' },
450 { "Talx2E3", TYPE_SENUM, 127, ' ' },
451 { "Talx2E4", TYPE_UENUM, 255, ' ' },
452 { "Talx2E5", TYPE_SENUM, 32767, ' ' },
453 { "Talx2E6", TYPE_UENUM, 65535, ' ' },
454 { "Talx2E7", TYPE_SENUM, 2147483647, ' ' },
455 { "Talx2E8", TYPE_UENUM, 4294967295U, ' ' },
456 { "Talx2E9", TYPE_SENUM, 1099511627775LL, ' ' },
457 { "Talx4int", TYPE_INT, 2147483647, 'I' },
458 { "Talx4uint", TYPE_UINT, 4294967295U, 'I' },
459 { "Talx4long", TYPE_INT, 9223372036854775807LL, 'L' },
460 { "Talx4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
461 { "Talx4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
462 { "Talx4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
463 { "Talx4ptr", TYPE_PTR, 0, 0 },
464 { "Talx4cptr", TYPE_PTR, 0, 0 },
465 { "Talx4iptr", TYPE_PTR, 0, 0 },
466 { "Talx4float", TYPE_FLOAT, 0, 0 },
467 { "Talx4double", TYPE_FLOAT, 0, 0 },
468 { "Talx4ldouble", TYPE_FLOAT, 0, 0 },
469 { "Talx4E0", TYPE_UENUM, 0, ' ' },
470 { "Talx4E1", TYPE_UENUM, 1, ' ' },
471 { "Talx4E2", TYPE_SENUM, 3, ' ' },
472 { "Talx4E3", TYPE_SENUM, 127, ' ' },
473 { "Talx4E4", TYPE_UENUM, 255, ' ' },
474 { "Talx4E5", TYPE_SENUM, 32767, ' ' },
475 { "Talx4E6", TYPE_UENUM, 65535, ' ' },
476 { "Talx4E7", TYPE_SENUM, 2147483647, ' ' },
477 { "Talx4E8", TYPE_UENUM, 4294967295U, ' ' },
478 { "Talx4E9", TYPE_SENUM, 1099511627775LL, ' ' },
479 { "Taly8long", TYPE_INT, 9223372036854775807LL, 'L' },
480 { "Taly8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
481 { "Talx8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
482 { "Talx8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
483 { "Taly8ptr", TYPE_PTR, 0, 0 },
484 { "Taly8cptr", TYPE_PTR, 0, 0 },
485 { "Taly8iptr", TYPE_PTR, 0, 0 },
486 { "Talx8double", TYPE_FLOAT, 0, 0 },
487 { "Talx8ldouble", TYPE_FLOAT, 0, 0 }
488 #define NAATYPES2 (sizeof (attrib_array_types) / sizeof (attrib_array_types[0]))
489 };
490
491 /* A prime number giving the number of slots in the hash table. */
492 #define HASH_SIZE 32749
493 static struct entry *hash_table[HASH_SIZE];
494
495 static int idx, limidx, output_one, short_enums;
496 static const char *destdir;
497 static const char *srcdir;
498 FILE *outfile;
499
500 void
501 switchfiles (int fields)
502 {
503 static int filecnt;
504 static char *destbuf, *destptr;
505 int i;
506
507 ++filecnt;
508 if (outfile)
509 fclose (outfile);
510 if (output_one)
511 {
512 outfile = stdout;
513 return;
514 }
515 if (destbuf == NULL)
516 {
517 size_t len = strlen (destdir);
518 destbuf = malloc (len + 20);
519 if (!destbuf)
520 abort ();
521 memcpy (destbuf, destdir, len);
522 if (!len || destbuf[len - 1] != '/')
523 destbuf[len++] = '/';
524 destptr = destbuf + len;
525 }
526 sprintf (destptr, "t%03d_main.C", filecnt);
527 outfile = fopen (destbuf, "w");
528 if (outfile == NULL)
529 {
530 fail:
531 fputs ("failed to create test files\n", stderr);
532 exit (1);
533 }
534 for (i = 0; i < NDG_OPTIONS; i++)
535 fprintf (outfile, dg_options[i], "", srcdir);
536 fprintf (outfile, "\n\
537 #include \"struct-layout-1.h\"\n\
538 \n\
539 #define TX(n, type, attrs, fields, ops) extern void test##n (void);\n\
540 #include \"t%03d_test.h\"\n\
541 #undef TX\n\
542 \n\
543 int main (void)\n\
544 {\n\
545 #define TX(n, type, attrs, fields, ops) test##n ();\n\
546 #include \"t%03d_test.h\"\n\
547 #undef TX\n\
548 if (fails)\n\
549 {\n\
550 fflush (stdout);\n\
551 abort ();\n\
552 }\n\
553 exit (0);\n\
554 }\n", filecnt, filecnt);
555 fclose (outfile);
556 sprintf (destptr, "t%03d_x.C", filecnt);
557 outfile = fopen (destbuf, "w");
558 if (outfile == NULL)
559 goto fail;
560 for (i = 0; i < NDG_OPTIONS; i++)
561 fprintf (outfile, dg_options[i], "-w ", srcdir);
562 fprintf (outfile, "\n\
563 #include \"struct-layout-1_x1.h\"\n\
564 #include \"t%03d_test.h\"\n\
565 #include \"struct-layout-1_x2.h\"\n\
566 #include \"t%03d_test.h\"\n", filecnt, filecnt);
567 fclose (outfile);
568 sprintf (destptr, "t%03d_y.C", filecnt);
569 outfile = fopen (destbuf, "w");
570 if (outfile == NULL)
571 goto fail;
572 for (i = 0; i < NDG_OPTIONS; i++)
573 fprintf (outfile, dg_options[i], "-w ", srcdir);
574 fprintf (outfile, "\n\
575 #include \"struct-layout-1_y1.h\"\n\
576 #include \"t%03d_test.h\"\n\
577 #include \"struct-layout-1_y2.h\"\n\
578 #include \"t%03d_test.h\"\n", filecnt, filecnt);
579 fclose (outfile);
580 sprintf (destptr, "t%03d_test.h", filecnt);
581 outfile = fopen (destbuf, "w");
582 if (outfile == NULL)
583 goto fail;
584 if (fields <= 2)
585 limidx = idx + 300;
586 else if (fields <= 4)
587 limidx = idx + 200;
588 else if (fields <= 6)
589 limidx = idx + 100;
590 else
591 limidx = idx + 50;
592 }
593
594 unsigned long long int
595 getrandll (void)
596 {
597 unsigned long long int ret;
598 ret = generate_random () & 0xffffff;
599 ret |= (generate_random () & 0xffffffLL) << 24;
600 ret |= ((unsigned long long int) generate_random ()) << 48;
601 return ret;
602 }
603
604 int
605 subfield (struct entry *e, char *letter)
606 {
607 int i, type;
608 char buf[20];
609 const char *p;
610 switch (e[0].etype)
611 {
612 case ETYPE_STRUCT:
613 case ETYPE_UNION:
614 case ETYPE_STRUCT_ARRAY:
615 case ETYPE_UNION_ARRAY:
616 type = e[0].attrib ? 1 + (generate_random () & 3) : 0;
617 if (e[0].etype == ETYPE_STRUCT || e[0].etype == ETYPE_STRUCT_ARRAY)
618 p = "struct";
619 else
620 p = "union";
621 if (e[0].etype == ETYPE_STRUCT_ARRAY || e[0].etype == ETYPE_UNION_ARRAY)
622 {
623 if (e[0].arr_len == 255)
624 snprintf (buf, 20, "%c[]", *letter);
625 else
626 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
627 /* If this is an array type, do not put aligned attributes on
628 elements. Aligning elements to a value greater than their
629 size will result in a compiler error. */
630 if (type == 1
631 && ((strncmp (e[0].attrib, "atal", 4) == 0)
632 || strncmp (e[0].attrib, "atpaal", 6) == 0))
633 type = 2;
634 }
635 else
636 {
637 buf[0] = *letter;
638 buf[1] = '\0';
639 }
640 ++*letter;
641 switch (type)
642 {
643 case 0:
644 case 3:
645 case 4:
646 fprintf (outfile, "%s{", p);
647 break;
648 case 1:
649 fprintf (outfile, "%s %s{", e[0].attrib, p);
650 break;
651 case 2:
652 fprintf (outfile, "%s %s{", p, e[0].attrib);
653 break;
654 }
655
656 for (i = 1; i <= e[0].len; )
657 i += subfield (e + i, letter);
658
659 switch (type)
660 {
661 case 0:
662 case 1:
663 case 2:
664 fprintf (outfile, "}%s;", buf);
665 break;
666 case 3:
667 fprintf (outfile, "}%s %s;", e[0].attrib, buf);
668 break;
669 case 4:
670 fprintf (outfile, "}%s %s;", buf, e[0].attrib);
671 break;
672 }
673 return 1 + e[0].len;
674 case ETYPE_TYPE:
675 case ETYPE_ARRAY:
676 if (e[0].etype == ETYPE_ARRAY)
677 {
678 if (e[0].arr_len == 255)
679 snprintf (buf, 20, "%c[]", *letter);
680 else
681 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
682 }
683 else
684 {
685 buf[0] = *letter;
686 buf[1] = '\0';
687 }
688 ++*letter;
689 if (e[0].attrib)
690 {
691 /* If this is an array type, do not put aligned attributes on
692 elements. Aligning elements to a value greater than their
693 size will result in a compiler error. */
694 if (e[0].etype == ETYPE_ARRAY
695 && ((strncmp (e[0].attrib, "atal", 4) == 0)
696 || strncmp (e[0].attrib, "atpaal", 6) == 0))
697 type = 2;
698 else
699 type = generate_random () % 3;
700 switch (type)
701 {
702 case 0:
703 fprintf (outfile, "%s %s %s;", e[0].attrib, e[0].type->name,
704 buf);
705 break;
706 case 1:
707 fprintf (outfile, "%s %s %s;", e[0].type->name, e[0].attrib,
708 buf);
709 break;
710 case 2:
711 fprintf (outfile, "%s %s %s;", e[0].type->name, buf,
712 e[0].attrib);
713 break;
714 }
715 }
716 else
717 fprintf (outfile, "%s %s;", e[0].type->name, buf);
718 return 1;
719 case ETYPE_BITFLD:
720 if (e[0].len == 0)
721 {
722 if (e[0].attrib)
723 switch (generate_random () % 3)
724 {
725 case 0:
726 fprintf (outfile, "%s %s:0;", e[0].attrib, e[0].type->name);
727 break;
728 case 1:
729 fprintf (outfile, "%s %s:0;", e[0].type->name, e[0].attrib);
730 break;
731 case 2:
732 fprintf (outfile, "%s:0 %s;", e[0].type->name, e[0].attrib);
733 break;
734 }
735 else
736 fprintf (outfile, "%s:0;", e[0].type->name);
737 ++*letter;
738 return 1;
739 }
740 snprintf (buf, 20, "%d", e[0].len);
741 if (e[0].attrib)
742 switch (generate_random () % 3)
743 {
744 case 0:
745 fprintf (outfile, "%s %s %c:%s;", e[0].attrib, e[0].type->name,
746 *letter, buf);
747 break;
748 case 1:
749 fprintf (outfile, "%s %s %c:%s;", e[0].type->name, e[0].attrib,
750 *letter, buf);
751 break;
752 case 2:
753 fprintf (outfile, "%s %c:%s %s;", e[0].type->name, *letter,
754 buf, e[0].attrib);
755 break;
756 }
757 else
758 fprintf (outfile, "%s %c:%s;", e[0].type->name, *letter, buf);
759 ++*letter;
760 return 1;
761 default:
762 abort ();
763 }
764 }
765
766 char namebuf[1024];
767
768 void
769 output_FNB (char mode, struct entry *e)
770 {
771 unsigned long long int l1, l2, m;
772 int signs = 0;
773 const char *p, *q;
774
775 if (e->type->type == TYPE_OTHER)
776 {
777 if (mode == 'B')
778 abort ();
779 fprintf (outfile, "N(%d,%s)", idx, namebuf);
780 return;
781 }
782 fprintf (outfile, "%c(%d,%s,", mode, idx, namebuf);
783 l1 = getrandll ();
784 l2 = getrandll ();
785 switch (e->type->type)
786 {
787 case TYPE_INT:
788 signs = generate_random () & 3;
789 m = e->type->maxval;
790 if (mode == 'B')
791 m &= e->len > 1 ? (1ULL << (e->len - 1)) - 1 : 1;
792 l1 &= m;
793 l2 &= m;
794 fprintf (outfile, "%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s",
795 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
796 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
797 break;
798 case TYPE_UINT:
799 m = e->type->maxval;
800 if (mode == 'B')
801 m &= (1ULL << e->len) - 1;
802 l1 &= m;
803 l2 &= m;
804 fprintf (outfile,"%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s",
805 l1, l1 > 4294967295U ? "LL" : "",
806 l2, l2 > 4294967295U ? "LL" : "");
807 break;
808 case TYPE_FLOAT:
809 l1 &= 0xffffff;
810 l2 &= 0xffffff;
811 signs = generate_random () & 3;
812 fprintf (outfile, "%s%f,%s%f", (signs & 1) ? "-" : "",
813 ((double) l1) / 64, (signs & 2) ? "-" : "", ((double) l2) / 64);
814 break;
815 case TYPE_UENUM:
816 if (e->type->maxval == 0)
817 fputs ("e0_0,e0_0", outfile);
818 else if (e->type->maxval == 1)
819 fprintf (outfile, "e1_%" COMPAT_PRLL "d,e1_%" COMPAT_PRLL "d",
820 l1 & 1, l2 & 1);
821 else
822 {
823 p = strchr (e->type->name, '\0');
824 while (--p >= e->type->name && *p >= '0' && *p <= '9');
825 p++;
826 l1 %= 7;
827 l2 %= 7;
828 if (l1 > 3)
829 l1 += e->type->maxval - 6;
830 if (l2 > 3)
831 l2 += e->type->maxval - 6;
832 fprintf (outfile, "e%s_%" COMPAT_PRLL "d,e%s_%" COMPAT_PRLL "d",
833 p, l1, p, l2);
834 }
835 break;
836 case TYPE_SENUM:
837 p = strchr (e->type->name, '\0');
838 while (--p >= e->type->name && *p >= '0' && *p <= '9');
839 p++;
840 l1 %= 7;
841 l2 %= 7;
842 fprintf (outfile, "e%s_%s%" COMPAT_PRLL "d,e%s_%s%" COMPAT_PRLL "d",
843 p, l1 < 3 ? "m" : "",
844 l1 == 3 ? 0LL : e->type->maxval - (l1 & 3),
845 p, l2 < 3 ? "m" : "",
846 l2 == 3 ? 0LL : e->type->maxval - (l2 & 3));
847 break;
848 case TYPE_PTR:
849 l1 %= 256;
850 l2 %= 256;
851 fprintf (outfile,
852 "(%s)&intarray[%" COMPAT_PRLL "d], (%s)&intarray[%" COMPAT_PRLL "d]",
853 e->type->name, l1, e->type->name, l2);
854 break;
855 case TYPE_FNPTR:
856 l1 %= 10;
857 l2 %= 10;
858 fprintf (outfile,
859 "fn%" COMPAT_PRLL "d,fn%" COMPAT_PRLL "d", l1, l2);
860 break;
861 default:
862 abort ();
863 }
864 fputs (")", outfile);
865 }
866
867 int
868 subvalues (struct entry *e, char *p, char *letter)
869 {
870 int i, j;
871 char *q;
872 if (p >= namebuf + sizeof (namebuf) - 32)
873 abort ();
874 p[0] = *letter;
875 p[1] = '\0';
876 q = p + 1;
877 switch (e[0].etype)
878 {
879 case ETYPE_STRUCT_ARRAY:
880 case ETYPE_UNION_ARRAY:
881 if (e[0].arr_len == 0 || e[0].arr_len == 255)
882 {
883 *letter += 1 + e[0].len;
884 return 1 + e[0].len;
885 }
886 i = generate_random () % e[0].arr_len;
887 snprintf (p, sizeof (namebuf) - (p - namebuf) - 1,
888 "%c[%d]", *letter, i);
889 q = strchr (p, '\0');
890 /* FALLTHROUGH */
891 case ETYPE_STRUCT:
892 case ETYPE_UNION:
893 *q++ = '.';
894 ++*letter;
895 for (i = 1; i <= e[0].len; )
896 {
897 i += subvalues (e + i, q, letter);
898 if (e[0].etype == ETYPE_UNION || e[0].etype == ETYPE_UNION_ARRAY)
899 {
900 *letter += e[0].len - i + 1;
901 break;
902 }
903 }
904 return 1 + e[0].len;
905 case ETYPE_TYPE:
906 ++*letter;
907 output_FNB ('F', e);
908 return 1;
909 case ETYPE_ARRAY:
910 if (e[0].arr_len == 0 || e[0].arr_len == 255)
911 {
912 ++*letter;
913 return 1;
914 }
915 i = generate_random () % e[0].arr_len;
916 snprintf (p, sizeof (namebuf) - (p - namebuf),
917 "%c[%d]", *letter, i);
918 output_FNB ('F', e);
919 if ((generate_random () & 7) == 0)
920 {
921 j = generate_random () % e[0].arr_len;
922 if (i != j)
923 {
924 snprintf (p, sizeof (namebuf) - (p - namebuf),
925 "%c[%d]", *letter, j);
926 output_FNB ('F', e);
927 }
928 }
929 ++*letter;
930 return 1;
931 case ETYPE_BITFLD:
932 ++*letter;
933 if (e[0].len != 0)
934 output_FNB ('B', e);
935 return 1;
936 }
937 }
938
939 /* DERIVED FROM:
940 --------------------------------------------------------------------
941 lookup2.c, by Bob Jenkins, December 1996, Public Domain.
942 hash(), hash2(), hash3, and mix() are externally useful functions.
943 Routines to test the hash are included if SELF_TEST is defined.
944 You can use this free for any purpose. It has no warranty.
945 --------------------------------------------------------------------
946 */
947
948 /*
949 --------------------------------------------------------------------
950 mix -- mix 3 32-bit values reversibly.
951 For every delta with one or two bit set, and the deltas of all three
952 high bits or all three low bits, whether the original value of a,b,c
953 is almost all zero or is uniformly distributed,
954 * If mix() is run forward or backward, at least 32 bits in a,b,c
955 have at least 1/4 probability of changing.
956 * If mix() is run forward, every bit of c will change between 1/3 and
957 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
958 mix() was built out of 36 single-cycle latency instructions in a
959 structure that could supported 2x parallelism, like so:
960 a -= b;
961 a -= c; x = (c>>13);
962 b -= c; a ^= x;
963 b -= a; x = (a<<8);
964 c -= a; b ^= x;
965 c -= b; x = (b>>13);
966 ...
967 Unfortunately, superscalar Pentiums and Sparcs can't take advantage
968 of that parallelism. They've also turned some of those single-cycle
969 latency instructions into multi-cycle latency instructions. Still,
970 this is the fastest good hash I could find. There were about 2^^68
971 to choose from. I only looked at a billion or so.
972 --------------------------------------------------------------------
973 */
974 /* same, but slower, works on systems that might have 8 byte hashval_t's */
975 #define mix(a,b,c) \
976 { \
977 a -= b; a -= c; a ^= (c>>13); \
978 b -= c; b -= a; b ^= (a<< 8); \
979 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
980 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
981 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
982 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
983 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
984 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
985 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
986 }
987
988 /*
989 --------------------------------------------------------------------
990 hash() -- hash a variable-length key into a 32-bit value
991 k : the key (the unaligned variable-length array of bytes)
992 len : the length of the key, counting by bytes
993 level : can be any 4-byte value
994 Returns a 32-bit value. Every bit of the key affects every bit of
995 the return value. Every 1-bit and 2-bit delta achieves avalanche.
996 About 36+6len instructions.
997
998 The best hash table sizes are powers of 2. There is no need to do
999 mod a prime (mod is sooo slow!). If you need less than 32 bits,
1000 use a bitmask. For example, if you need only 10 bits, do
1001 h = (h & hashmask(10));
1002 In which case, the hash table should have hashsize(10) elements.
1003
1004 If you are hashing n strings (ub1 **)k, do it like this:
1005 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
1006
1007 By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
1008 code any way you wish, private, educational, or commercial. It's free.
1009
1010 See http://burtleburtle.net/bob/hash/evahash.html
1011 Use for hash table lookup, or anything where one collision in 2^32 is
1012 acceptable. Do NOT use for cryptographic purposes.
1013 --------------------------------------------------------------------
1014 */
1015
1016 static hashval_t
1017 iterative_hash (const void *k_in /* the key */,
1018 register size_t length /* the length of the key */,
1019 register hashval_t initval /* the previous hash, or
1020 an arbitrary value */)
1021 {
1022 register const unsigned char *k = (const unsigned char *)k_in;
1023 register hashval_t a,b,c,len;
1024
1025 /* Set up the internal state */
1026 len = length;
1027 a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
1028 c = initval; /* the previous hash value */
1029
1030 /*---------------------------------------- handle most of the key */
1031 while (len >= 12)
1032 {
1033 a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24));
1034 b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24));
1035 c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24));
1036 mix(a,b,c);
1037 k += 12; len -= 12;
1038 }
1039
1040 /*------------------------------------- handle the last 11 bytes */
1041 c += length;
1042 switch(len) /* all the case statements fall through */
1043 {
1044 case 11: c+=((hashval_t)k[10]<<24);
1045 case 10: c+=((hashval_t)k[9]<<16);
1046 case 9 : c+=((hashval_t)k[8]<<8);
1047 /* the first byte of c is reserved for the length */
1048 case 8 : b+=((hashval_t)k[7]<<24);
1049 case 7 : b+=((hashval_t)k[6]<<16);
1050 case 6 : b+=((hashval_t)k[5]<<8);
1051 case 5 : b+=k[4];
1052 case 4 : a+=((hashval_t)k[3]<<24);
1053 case 3 : a+=((hashval_t)k[2]<<16);
1054 case 2 : a+=((hashval_t)k[1]<<8);
1055 case 1 : a+=k[0];
1056 /* case 0: nothing left to add */
1057 }
1058 mix(a,b,c);
1059 /*-------------------------------------------- report the result */
1060 return c;
1061 }
1062
1063 hashval_t
1064 e_hash (const void *a)
1065 {
1066 const struct entry *e = a;
1067 hashval_t ret = 0;
1068 int i;
1069
1070 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
1071 abort ();
1072 for (i = 0; i <= e[0].len; ++i)
1073 {
1074 int attriblen;
1075 ret = iterative_hash (&e[i], offsetof (struct entry, attrib), ret);
1076 attriblen = e[i].attrib ? strlen (e[i].attrib) : -1;
1077 ret = iterative_hash (&attriblen, sizeof (int), ret);
1078 if (e[i].attrib)
1079 ret = iterative_hash (e[i].attrib, attriblen, ret);
1080 }
1081 return ret;
1082 }
1083
1084 int
1085 e_eq (const void *a, const void *b)
1086 {
1087 const struct entry *ea = a, *eb = b;
1088 int i;
1089 if (ea[0].etype != ETYPE_STRUCT && ea[0].etype != ETYPE_UNION)
1090 abort ();
1091 if (ea[0].len != eb[0].len)
1092 return 0;
1093 for (i = 0; i <= ea[0].len; ++i)
1094 {
1095 if (ea[i].etype != eb[i].etype
1096 || ea[i].len != eb[i].len
1097 || ea[i].arr_len != eb[i].arr_len
1098 || ea[i].type != eb[i].type)
1099 return 0;
1100 if ((ea[i].attrib == NULL) ^ (eb[i].attrib == NULL))
1101 return 0;
1102 if (ea[i].attrib && strcmp (ea[i].attrib, eb[i].attrib) != 0)
1103 return 0;
1104 }
1105 return 1;
1106 }
1107
1108 static int
1109 e_exists (const struct entry *e)
1110 {
1111 struct entry *h;
1112 hashval_t hval;
1113
1114 hval = e_hash (e);
1115 for (h = hash_table[hval % HASH_SIZE]; h; h = h->next)
1116 if (e_eq (e, h))
1117 return 1;
1118 return 0;
1119 }
1120
1121 static void
1122 e_insert (struct entry *e)
1123 {
1124 hashval_t hval;
1125
1126 hval = e_hash (e);
1127 e->next = hash_table[hval % HASH_SIZE];
1128 hash_table[hval % HASH_SIZE] = e;
1129 }
1130
1131 void
1132 output (struct entry *e)
1133 {
1134 int i;
1135 char c;
1136 struct entry *n;
1137
1138 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
1139 abort ();
1140
1141 if (e_exists (e))
1142 return;
1143
1144 n = (struct entry *) malloc ((e[0].len + 1) * sizeof (struct entry));
1145 memcpy (n, e, (e[0].len + 1) * sizeof (struct entry));
1146 e_insert (n);
1147
1148 if (idx == limidx)
1149 switchfiles (e[0].len);
1150
1151 if (e[0].etype == ETYPE_STRUCT)
1152 fprintf (outfile, "T(%d,", idx);
1153 else
1154 fprintf (outfile, "U(%d,", idx);
1155 c = 'a';
1156 for (i = 1; i <= e[0].len; )
1157 i += subfield (e + i, &c);
1158 fputs (",", outfile);
1159 c = 'a';
1160 for (i = 1; i <= e[0].len; )
1161 {
1162 i += subvalues (e + i, namebuf, &c);
1163 if (e[0].etype == ETYPE_UNION)
1164 break;
1165 }
1166 fputs (")\n", outfile);
1167 if (output_one && idx == limidx)
1168 exit (0);
1169 ++idx;
1170 }
1171
1172 enum FEATURE
1173 {
1174 FEATURE_VECTOR = 1,
1175 FEATURE_ALIGNEDPACKED = 2,
1176 FEATURE_ZEROARRAY = 4,
1177 FEATURE_ZEROBITFLD = 8,
1178 ALL_FEATURES = FEATURE_VECTOR | FEATURE_ZEROARRAY
1179 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD
1180 };
1181
1182 void
1183 singles (enum FEATURE features)
1184 {
1185 struct entry e[2];
1186 int i;
1187 memset (e, 0, sizeof (e));
1188 e[0].etype = ETYPE_STRUCT;
1189 output (e);
1190 e[0].etype = ETYPE_UNION;
1191 output (e);
1192 e[0].len = 1;
1193 for (i = 0; i < NTYPES2; ++i)
1194 {
1195 e[0].etype = ETYPE_STRUCT;
1196 e[1].etype = ETYPE_TYPE;
1197 e[1].type = &base_types[i];
1198 output (e);
1199 e[0].etype = ETYPE_UNION;
1200 output (e);
1201 }
1202 if (features & FEATURE_VECTOR)
1203 for (i = 0; i < NVTYPES2; ++i)
1204 {
1205 e[0].etype = ETYPE_STRUCT;
1206 e[1].etype = ETYPE_TYPE;
1207 e[1].type = &vector_types[i];
1208 output (e);
1209 e[0].etype = ETYPE_UNION;
1210 output (e);
1211 }
1212 }
1213
1214 void
1215 choose_type (enum FEATURE features, struct entry *e, int r, int in_array)
1216 {
1217 int i;
1218
1219 i = NTYPES2 - NTYPES1;
1220 if (features & FEATURE_VECTOR)
1221 i += NVTYPES2;
1222 if ((r & 3) == 0)
1223 {
1224 if (in_array)
1225 i += NAATYPES2;
1226 else
1227 i += NATYPES2;
1228 }
1229 r >>= 2;
1230 r %= i;
1231 if (r < NTYPES2 - NTYPES1)
1232 e->type = &base_types[r + NTYPES1];
1233 r -= NTYPES2 - NTYPES1;
1234 if (e->type == NULL && (features & FEATURE_VECTOR))
1235 {
1236 if (r < NVTYPES2)
1237 e->type = &vector_types[r];
1238 r -= NVTYPES2;
1239 }
1240 if (e->type == NULL && !in_array)
1241 {
1242 if (r < NATYPES2)
1243 e->type = &attrib_types[r];
1244 r -= NATYPES2;
1245 }
1246 if (e->type == NULL && in_array)
1247 {
1248 if (r < NAATYPES2)
1249 e->type = &attrib_array_types[r];
1250 r -= NAATYPES2;
1251 }
1252 if (e->type == NULL)
1253 abort ();
1254 }
1255
1256 /* This is from gcc.c-torture/execute/builtin-bitops-1.c. */
1257 static int
1258 my_ffsll (unsigned long long x)
1259 {
1260 int i;
1261 if (x == 0)
1262 return 0;
1263 /* We've tested LLONG_MAX for 64 bits so this should be safe. */
1264 for (i = 0; i < 64; i++)
1265 if (x & (1ULL << i))
1266 break;
1267 return i + 1;
1268 }
1269
1270 void
1271 generate_fields (enum FEATURE features, struct entry *e, struct entry *parent,
1272 int len)
1273 {
1274 int r, i, j, ret = 1, n, incr, sametype;
1275
1276 for (n = 0; n < len; n += incr)
1277 {
1278 r = generate_random ();
1279 /* 50% ETYPE_TYPE base_types NTYPES1
1280 12.5% ETYPE_TYPE other
1281 12.5% ETYPE_ARRAY
1282 12.5% ETYPE_BITFLD
1283 12.5% ETYPE_STRUCT|ETYPE_UNION|ETYPE_STRUCT_ARRAY|ETYPE_UNION_ARRAY */
1284 i = (r & 7);
1285 r >>= 3;
1286 incr = 1;
1287 switch (i)
1288 {
1289 case 0:
1290 case 1:
1291 case 2:
1292 case 3:
1293 e[n].etype = ETYPE_TYPE;
1294 e[n].type = &base_types[r % NTYPES1];
1295 break;
1296 case 4:
1297 e[n].etype = ETYPE_TYPE;
1298 choose_type (features, &e[n], r, 0);
1299 break;
1300 case 5:
1301 e[n].etype = ETYPE_ARRAY;
1302 i = r & 1;
1303 r >>= 1;
1304 if (i)
1305 e[n].type = &base_types[r % NTYPES1];
1306 else
1307 choose_type (features, &e[n], r, 1);
1308 r = generate_random ();
1309 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
1310 {
1311 e[n].arr_len = 0;
1312 if (n == len - 1 && (r & 4)
1313 && (parent->etype == ETYPE_STRUCT
1314 || parent->etype == ETYPE_STRUCT_ARRAY))
1315 {
1316 int k;
1317 for (k = 0; k < n; ++k)
1318 if (e[k].etype != ETYPE_BITFLD || e[k].len)
1319 {
1320 e[n].arr_len = 255;
1321 break;
1322 }
1323 }
1324 }
1325 else if ((r & 3) != 3)
1326 e[n].arr_len = (r >> 2) & 7;
1327 else
1328 e[n].arr_len = (r >> 2) & 31;
1329 break;
1330 case 6:
1331 sametype = 1;
1332 switch (r & 7)
1333 {
1334 case 0:
1335 case 1:
1336 case 2:
1337 break;
1338 case 3:
1339 case 4:
1340 case 5:
1341 incr = 1 + (r >> 3) % (len - n);
1342 break;
1343 case 6:
1344 case 7:
1345 sametype = 0;
1346 incr = 1 + (r >> 3) % (len - n);
1347 break;
1348 }
1349 for (j = n; j < n + incr; ++j)
1350 {
1351 int mi, ma;
1352
1353 e[j].etype = ETYPE_BITFLD;
1354 if (j == n || !sametype)
1355 {
1356 int k;
1357 r = generate_random ();
1358 k = r & 3;
1359 r >>= 2;
1360 if (!k)
1361 e[j].type
1362 = &aligned_bitfld_types[r % n_aligned_bitfld_types];
1363 else
1364 e[j].type
1365 = &bitfld_types[r % n_bitfld_types];
1366 }
1367 else
1368 e[j].type = e[n].type;
1369 r = generate_random ();
1370 mi = 0;
1371 ma = 0;
1372 switch (e[j].type->bitfld)
1373 {
1374 case 'C': ma = 8; break;
1375 case 'S': ma = 16; break;
1376 case 'I': ma = 32; break;
1377 case 'L':
1378 case 'Q': ma = 64; break;
1379 case 'B': ma = 1; break;
1380 case ' ':
1381 if (e[j].type->type == TYPE_UENUM)
1382 mi = my_ffsll (e[j].type->maxval + 1) - 1;
1383 else if (e[j].type->type == TYPE_SENUM)
1384 mi = my_ffsll (e[j].type->maxval + 1);
1385 else
1386 abort ();
1387 if (!mi)
1388 mi = 1;
1389 if (mi > 32)
1390 ma = 64;
1391 else if (mi > 16 || !short_enums)
1392 ma = 32;
1393 else if (mi > 8)
1394 ma = 16;
1395 else
1396 ma = 8;
1397 break;
1398 default:
1399 abort ();
1400 }
1401 e[j].len = ma + 1;
1402 if (sametype && (r & 3) == 0 && ma > 1)
1403 {
1404 int sum = 0, k;
1405 for (k = n; k < j; ++k)
1406 sum += e[k].len;
1407 sum %= ma;
1408 e[j].len = sum ? ma - sum : ma;
1409 }
1410 r >>= 2;
1411 if (!sametype && (r & 7) == 0)
1412 ma *= 8;
1413 r >>= 3;
1414 if (! (features & FEATURE_ZEROBITFLD) && mi == 0)
1415 mi = 1;
1416 if (e[j].len < mi || e[j].len > ma)
1417 e[j].len = mi + (r % (ma + 1 - mi));
1418 r >>= 6;
1419 if ((features & FEATURE_ZEROBITFLD) && (r & 3) == 0
1420 && mi == 0)
1421 e[j].len = 0;
1422 }
1423 break;
1424 case 7:
1425 switch (r & 7)
1426 {
1427 case 0:
1428 case 1:
1429 case 2:
1430 e[n].etype = ETYPE_STRUCT;
1431 break;
1432 case 3:
1433 case 4:
1434 e[n].etype = ETYPE_UNION;
1435 break;
1436 case 5:
1437 case 6:
1438 e[n].etype = ETYPE_STRUCT_ARRAY;
1439 break;
1440 case 7:
1441 e[n].etype = ETYPE_UNION_ARRAY;
1442 break;
1443 }
1444 r >>= 3;
1445 e[n].len = r % (len - n);
1446 incr = 1 + e[n].len;
1447 generate_fields (features, &e[n + 1], &e[n], e[n].len);
1448 if (e[n].etype == ETYPE_STRUCT_ARRAY
1449 || e[n].etype == ETYPE_UNION_ARRAY)
1450 {
1451 r = generate_random ();
1452 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
1453 {
1454 e[n].arr_len = 0;
1455 if (n + incr == len && (r & 4)
1456 && (parent->etype == ETYPE_STRUCT
1457 || parent->etype == ETYPE_STRUCT_ARRAY))
1458 {
1459 int k;
1460 for (k = 0; k < n; ++k)
1461 if (e[k].etype != ETYPE_BITFLD || e[k].len)
1462 {
1463 e[n].arr_len = 255;
1464 break;
1465 }
1466 }
1467 }
1468 else if ((r & 3) != 3)
1469 e[n].arr_len = (r >> 2) & 7;
1470 else
1471 e[n].arr_len = (r >> 2) & 31;
1472 }
1473 break;
1474 }
1475 r = generate_random ();
1476 if ((r & 7) == 0)
1477 {
1478 r >>= 3;
1479 i = (features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1;
1480 e[n].attrib = attributes[r % i];
1481 if (! (features & FEATURE_ALIGNEDPACKED)
1482 && strcmp (e[n].attrib, "atpa") == 0
1483 && ((e[n].type >= &attrib_types[0]
1484 && e[n].type < &attrib_types[NATYPES2])
1485 || (e[n].type >= &attrib_array_types[0]
1486 && e[n].type < &attrib_array_types[NAATYPES2])
1487 || (e[n].type >= &aligned_bitfld_types[0]
1488 && e[n].type < &aligned_bitfld_types[n_aligned_bitfld_types])))
1489 e[n].attrib = NULL;
1490 }
1491 }
1492 }
1493
1494 void
1495 generate_random_tests (enum FEATURE features, int len)
1496 {
1497 struct entry e[len + 1];
1498 int i, r;
1499 if (len > 'z' - 'a' + 1)
1500 abort ();
1501 memset (e, 0, sizeof (e));
1502 r = generate_random ();
1503 if ((r & 7) == 0)
1504 e[0].etype = ETYPE_UNION;
1505 else
1506 e[0].etype = ETYPE_STRUCT;
1507 r >>= 3;
1508 e[0].len = len;
1509 generate_fields (features, &e[1], &e[0], len);
1510 output (e);
1511 }
1512
1513 struct { const char *name; enum FEATURE f; }
1514 features[] = {
1515 { "normal", 0 },
1516 { "vector", FEATURE_VECTOR },
1517 { "[0] :0", FEATURE_ZEROARRAY | FEATURE_ZEROBITFLD },
1518 { "vector [0]",
1519 FEATURE_VECTOR | FEATURE_ZEROARRAY },
1520 { "aligned packed vector [0] :0",
1521 FEATURE_VECTOR | FEATURE_ZEROARRAY
1522 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD },
1523 };
1524
1525 int
1526 main (int argc, char **argv)
1527 {
1528 int i, j, count, c, n = 3000;
1529 char *optarg;
1530
1531 if (sizeof (int) != 4 || sizeof (long long) != 8)
1532 return 1;
1533
1534 i = 1;
1535 while (i < argc)
1536 {
1537 c = '\0';
1538 if (argv[i][0] == '-' && argv[i][2] == '\0')
1539 c = argv[i][1];
1540 optarg = argv[i + 1];
1541 if (!optarg)
1542 goto usage;
1543 switch (c)
1544 {
1545 case 'n':
1546 n = atoi (optarg);
1547 break;
1548 case 'd':
1549 destdir = optarg;
1550 break;
1551 case 's':
1552 srcdir = optarg;
1553 break;
1554 case 'i':
1555 output_one = 1;
1556 limidx = atoi (optarg);
1557 break;
1558 case 'e':
1559 short_enums = 1;
1560 i--;
1561 break;
1562 default:
1563 fprintf (stderr, "unrecognized option %s\n", argv[i]);
1564 goto usage;
1565 }
1566 i += 2;
1567 }
1568
1569 if (output_one)
1570 {
1571 outfile = fopen ("/dev/null", "w");
1572 if (outfile == NULL)
1573 {
1574 fputs ("could not open /dev/null", stderr);
1575 return 1;
1576 }
1577 n = limidx + 1;
1578 }
1579
1580 if (destdir == NULL && !output_one)
1581 {
1582 usage:
1583 fprintf (stderr, "Usage:\n\
1584 %s [-e] [-s srcdir -d destdir] [-n count] [-i idx]\n\
1585 Either -s srcdir -d destdir or -i idx must be used\n", argv[0]);
1586 return 1;
1587 }
1588
1589 if (srcdir == NULL && !output_one)
1590 goto usage;
1591
1592 for (i = 0; i < NTYPES2; ++i)
1593 if (base_types[i].bitfld)
1594 bitfld_types[n_bitfld_types++] = base_types[i];
1595 for (i = 0; i < NATYPES2; ++i)
1596 if (attrib_types[i].bitfld)
1597 aligned_bitfld_types[n_aligned_bitfld_types++] = attrib_types[i];
1598 for (i = 0; i < sizeof (features) / sizeof (features[0]); ++i)
1599 {
1600 int startidx = idx;
1601 if (! output_one)
1602 limidx = idx;
1603 if (!i)
1604 count = 200;
1605 else
1606 count = 20;
1607 for (j = 1; j <= 9; ++j)
1608 while (idx < startidx + j * count)
1609 generate_random_tests (features[i].f, j);
1610 while (idx < startidx + count * 10)
1611 generate_random_tests (features[i].f, 10 + (generate_random () % 16));
1612 }
1613 for (i = 0; n > 3000 && i < sizeof (features) / sizeof (features[0]); ++i)
1614 {
1615 int startidx;
1616 startidx = idx;
1617 if (! output_one)
1618 limidx = idx;
1619 singles (features[i].f);
1620 if (!i)
1621 {
1622 count = 1000;
1623 while (idx < startidx + 1000)
1624 generate_random_tests (features[i].f, 1);
1625 }
1626 else
1627 {
1628 startidx = idx;
1629 count = 100;
1630 while (idx < startidx + 100)
1631 generate_random_tests (features[i].f, 1);
1632 }
1633 startidx = idx;
1634 for (j = 2; j <= 9; ++j)
1635 while (idx < startidx + (j - 1) * count)
1636 generate_random_tests (features[i].f, j);
1637 while (idx < startidx + count * 9)
1638 generate_random_tests (features[i].f, 10 + (generate_random () % 16));
1639 }
1640 if (! output_one)
1641 limidx = idx;
1642 while (idx < n)
1643 generate_random_tests (ALL_FEATURES, 1 + (generate_random () % 25));
1644 fclose (outfile);
1645 return 0;
1646 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org