OSDN Git Service

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