1 /* Structure layout test generator.
2 Copyright (C) 2004, 2005, 2007, 2008, 2009, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Jakub Jelinek <jakub@redhat.com>.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22
23 /* Compile with gcc -o struct-layout-1_generate{,.c} generate_random{,_r}.c */
24
25 /* N.B. -- This program cannot use libiberty as that will not work
26 when testing an installed compiler. */
27 #include <limits.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stddef.h>
32 /* We use our own pseudo-random number generator, so that it gives the same
33 values on all hosts. */
34 #include "generate-random.h"
35
36 #if LLONG_MAX != 9223372036854775807LL && __LONG_LONG_MAX__ != 9223372036854775807LL
37 # error Need 64-bit long long
38 #endif
39
40 #if defined __MSVCRT__
41 #define COMPAT_PRLL "I64"
42 #else
43 #define COMPAT_PRLL "ll"
44 #endif
45
46 const char *dg_options[] = {
47 "/* { dg-options \"%s-I%s\" } */\n",
48 "/* { dg-options \"%s-I%s -Wno-abi\" } */\n",
49 "/* { dg-options \"%s-I%s -mno-mmx -Wno-abi\" { target i?86-*-* x86_64-*-* } } */\n",
50 "/* { dg-options \"%s-I%s -fno-common\" { target hppa*-*-hpux* powerpc*-*-darwin* } } */\n",
51 "/* { dg-options \"%s-I%s -mno-mmx -fno-common -Wno-abi\" { target i?86-*-darwin* x86_64-*-darwin* } } */\n",
52 "/* { dg-options \"%s-I%s -mno-base-addresses\" { target mmix-*-* } } */\n",
53 "/* { dg-options \"%s-I%s -mlongcalls -mtext-section-literals\" { target xtensa*-*-* } } */\n"
54 #define NDG_OPTIONS (sizeof (dg_options) / sizeof (dg_options[0]))
55 };
56
57 typedef unsigned int hashval_t;
58
59 enum TYPE
60 {
61 TYPE_INT,
62 TYPE_UINT,
63 TYPE_CINT,
64 TYPE_CUINT,
65 TYPE_FLOAT,
66 TYPE_CFLOAT,
67 TYPE_DEC_FLOAT,
68 TYPE_SENUM,
69 TYPE_UENUM,
70 TYPE_PTR,
71 TYPE_FNPTR,
72 TYPE_OTHER
73 };
74
75 struct types
76 {
77 const char *name;
78 enum TYPE type;
79 unsigned long long int maxval;
80 char bitfld;
81 };
82
83 struct types base_types[] = {
84 /* As we don't know whether char will be signed or not, just limit ourselves
85 to unsigned values less than maximum signed char value. */
86 { "char", TYPE_UINT, 127, 'C' },
87 { "signed char", TYPE_INT, 127, 'C' },
88 { "unsigned char", TYPE_UINT, 255, 'C' },
89 { "short int", TYPE_INT, 32767, 'S' },
90 { "unsigned short int", TYPE_UINT, 65535, 'S' },
91 { "int", TYPE_INT, 2147483647, 'I' },
92 { "unsigned int", TYPE_UINT, 4294967295U, 'I' },
93 { "long int", TYPE_INT, 9223372036854775807LL, 'L' },
94 { "unsigned long int", TYPE_UINT, 18446744073709551615ULL, 'L' },
95 { "long long int", TYPE_INT, 9223372036854775807LL, 'Q' },
96 { "unsigned long long int", TYPE_UINT, 18446744073709551615ULL, 'Q' },
97 { "bool", TYPE_UINT, 1, 'B' },
98 { "void *", TYPE_PTR, 0, 0 },
99 { "char *", TYPE_PTR, 0, 0 },
100 { "int *", TYPE_PTR, 0, 0 },
101 { "float", TYPE_FLOAT, 0, 0 },
102 { "double", TYPE_FLOAT, 0, 0 },
103 { "long double", TYPE_FLOAT, 0, 0 },
104 #ifndef SKIP_DECIMAL_FLOAT
105 { "_Decimal32", TYPE_DEC_FLOAT, 0, 0 },
106 { "_Decimal64", TYPE_DEC_FLOAT, 0, 0 },
107 { "_Decimal128", TYPE_DEC_FLOAT, 0, 0 },
108 #define NTYPES1 21
109 #else
110 #define NTYPES1 18
111 #endif
112 { "Tchar", TYPE_UINT, 127, 'C' },
113 { "Tschar", TYPE_INT, 127, 'C' },
114 { "Tuchar", TYPE_UINT, 255, 'C' },
115 { "Tshort", TYPE_INT, 32767, 'S' },
116 { "Tushort", TYPE_UINT, 65535, 'S' },
117 { "Tint", TYPE_INT, 2147483647, 'I' },
118 { "Tuint", TYPE_UINT, 4294967295U, 'I' },
119 { "Tlong", TYPE_INT, 9223372036854775807LL, 'L' },
120 { "Tulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
121 { "Tllong", TYPE_INT, 9223372036854775807LL, 'Q' },
122 { "Tullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
123 { "Tbool", TYPE_UINT, 1, 'B' },
124 { "size_t", TYPE_UINT, 18446744073709551615ULL, 0 },
125 { "Tptr", TYPE_PTR, 0, 0 },
126 { "Tcptr", TYPE_PTR, 0, 0 },
127 { "Tiptr", TYPE_PTR, 0, 0 },
128 { "Tfnptr", TYPE_FNPTR, 0, 0 },
129 { "Tfloat", TYPE_FLOAT, 0, 0 },
130 { "Tdouble", TYPE_FLOAT, 0, 0 },
131 { "Tldouble", TYPE_FLOAT, 0, 0 },
132 #ifndef SKIP_DECIMAL_FLOAT
133 { "TDecimal32", TYPE_DEC_FLOAT, 0, 0 },
134 { "TDecimal64", TYPE_DEC_FLOAT, 0, 0 },
135 { "TDecimal128", TYPE_DEC_FLOAT, 0, 0 },
136 #endif
137 { "enum E0", TYPE_UENUM, 0, ' ' },
138 { "enum E1", TYPE_UENUM, 1, ' ' },
139 { "enum E2", TYPE_SENUM, 3, ' ' },
140 { "enum E3", TYPE_SENUM, 127, ' ' },
141 { "enum E4", TYPE_UENUM, 255, ' ' },
142 { "enum E5", TYPE_SENUM, 32767, ' ' },
143 { "enum E6", TYPE_UENUM, 65535, ' ' },
144 { "enum E7", TYPE_SENUM, 2147483647, ' ' },
145 { "enum E8", TYPE_UENUM, 4294967295U, ' ' },
146 { "enum E9", TYPE_SENUM, 1099511627775LL, ' ' },
147 { "TE0", TYPE_UENUM, 0, ' ' },
148 { "TE1", TYPE_UENUM, 1, ' ' },
149 { "TE2", TYPE_SENUM, 3, ' ' },
150 { "TE3", TYPE_SENUM, 127, ' ' },
151 { "TE4", TYPE_UENUM, 255, ' ' },
152 { "TE5", TYPE_SENUM, 32767, ' ' },
153 { "TE6", TYPE_UENUM, 65535, ' ' },
154 { "TE7", TYPE_SENUM, 2147483647, ' ' },
155 { "TE8", TYPE_UENUM, 4294967295U, ' ' },
156 { "TE9", TYPE_SENUM, 1099511627775LL, ' ' },
157 /* vector-defs.h typedefs */
158 { "qi", TYPE_INT, 127, 0 },
159 { "hi", TYPE_INT, 32767, 0 },
160 { "si", TYPE_INT, 2147483647, 0 },
161 { "di", TYPE_INT, 9223372036854775807LL, 0 },
162 { "sf", TYPE_FLOAT, 0, 0 },
163 { "df", TYPE_FLOAT, 0, 0 }
164 #define NTYPES2 (sizeof (base_types) / sizeof (base_types[0]))
165 };
166 struct types complex_types[] = {
167 { "_Complex char", TYPE_CUINT, 127, 0 },
168 { "_Complex signed char", TYPE_CINT, 127, 0 },
169 { "_Complex unsigned char", TYPE_CUINT, 255, 0 },
170 { "_Complex short int", TYPE_CINT, 32767, 0 },
171 { "_Complex unsigned short int", TYPE_CUINT, 65535, 0 },
172 { "_Complex int", TYPE_CINT, 2147483647, 0 },
173 { "_Complex unsigned int", TYPE_CUINT, 4294967295U, 0 },
174 { "_Complex long int", TYPE_CINT, 9223372036854775807LL, 0 },
175 { "_Complex unsigned long int", TYPE_CUINT, 18446744073709551615ULL, 0 },
176 { "_Complex long long int", TYPE_CINT, 9223372036854775807LL, 0 },
177 { "_Complex unsigned long long int", TYPE_CUINT, 18446744073709551615ULL, 0 },
178 { "_Complex float", TYPE_CFLOAT, 0, 0 },
179 { "_Complex double", TYPE_CFLOAT, 0, 0 },
180 { "_Complex long double", TYPE_CFLOAT, 0, 0 },
181 { "Tcchar", TYPE_CUINT, 127, 0 },
182 { "Tcschar", TYPE_CINT, 127, 0 },
183 { "Tcuchar", TYPE_CUINT, 255, 0 },
184 { "Tcshort", TYPE_CINT, 32767, 0 },
185 { "Tcushort", TYPE_CUINT, 65535, 0 },
186 { "Tcint", TYPE_CINT, 2147483647, 0 },
187 { "Tcuint", TYPE_CUINT, 4294967295U, 0 },
188 { "Tclong", TYPE_CINT, 9223372036854775807LL, 0 },
189 { "Tculong", TYPE_CUINT, 18446744073709551615ULL, 0 },
190 { "Tcllong", TYPE_CINT, 9223372036854775807LL, 0 },
191 { "Tcullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
192 { "Tcfloat", TYPE_CFLOAT, 0, 0 },
193 { "Tcdouble", TYPE_CFLOAT, 0, 0 },
194 { "Tcldouble", TYPE_CFLOAT, 0, 0 }
195 #define NCTYPES2 (sizeof (complex_types) / sizeof (complex_types[0]))
196 };
197 struct types vector_types[] = {
198 /* vector-defs.h typedefs */
199 { "v8qi", TYPE_OTHER, 0, 0 },
200 { "v16qi", TYPE_OTHER, 0, 0 },
201 { "v32qi", TYPE_OTHER, 0, 0 },
202 { "v2hi", TYPE_OTHER, 0, 0 },
203 { "v4hi", TYPE_OTHER, 0, 0 },
204 { "v8hi", TYPE_OTHER, 0, 0 },
205 { "v16hi", TYPE_OTHER, 0, 0 },
206 { "v2si", TYPE_OTHER, 0, 0 },
207 { "v4si", TYPE_OTHER, 0, 0 },
208 { "v8si", TYPE_OTHER, 0, 0 },
209 { "v1di", TYPE_OTHER, 0, 0 },
210 { "v2di", TYPE_OTHER, 0, 0 },
211 { "v4di", TYPE_OTHER, 0, 0 },
212 { "v2sf", TYPE_OTHER, 0, 0 },
213 { "v4sf", TYPE_OTHER, 0, 0 },
214 { "v8sf", TYPE_OTHER, 0, 0 },
215 { "v16sf", TYPE_OTHER, 0, 0 },
216 { "v2df", TYPE_OTHER, 0, 0 },
217 { "v4df", TYPE_OTHER, 0, 0 },
218 { "u8qi", TYPE_OTHER, 0, 0 },
219 { "u16qi", TYPE_OTHER, 0, 0 },
220 { "u32qi", TYPE_OTHER, 0, 0 },
221 { "u2hi", TYPE_OTHER, 0, 0 },
222 { "u4hi", TYPE_OTHER, 0, 0 },
223 { "u8hi", TYPE_OTHER, 0, 0 },
224 { "u16hi", TYPE_OTHER, 0, 0 },
225 { "u2si", TYPE_OTHER, 0, 0 },
226 { "u4si", TYPE_OTHER, 0, 0 },
227 { "u8si", TYPE_OTHER, 0, 0 },
228 { "u1di", TYPE_OTHER, 0, 0 },
229 { "u2di", TYPE_OTHER, 0, 0 },
230 { "u4di", TYPE_OTHER, 0, 0 },
231 { "u2sf", TYPE_OTHER, 0, 0 },
232 { "u4sf", TYPE_OTHER, 0, 0 },
233 { "u8sf", TYPE_OTHER, 0, 0 },
234 { "u16sf", TYPE_OTHER, 0, 0 },
235 { "u2df", TYPE_OTHER, 0, 0 },
236 { "u4df", TYPE_OTHER, 0, 0 },
237 { "__m64", TYPE_OTHER, 0, 0 },
238 { "__m128", TYPE_OTHER, 0, 0 }
239 #define NVTYPES2 (sizeof (vector_types) / sizeof (vector_types[0]))
240 };
241 struct types attrib_types[] = {
242 { "Talchar", TYPE_UINT, 127, 'C' },
243 { "Talschar", TYPE_INT, 127, 'C' },
244 { "Taluchar", TYPE_UINT, 255, 'C' },
245 { "Talshort", TYPE_INT, 32767, 'S' },
246 { "Talushort", TYPE_UINT, 65535, 'S' },
247 { "Talint", TYPE_INT, 2147483647, 'I' },
248 { "Taluint", TYPE_UINT, 4294967295U, 'I' },
249 { "Tallong", TYPE_INT, 9223372036854775807LL, 'L' },
250 { "Talulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
251 { "Talllong", TYPE_INT, 9223372036854775807LL, 'Q' },
252 { "Talullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
253 { "Talbool", TYPE_UINT, 1, 'B' },
254 { "Talptr", TYPE_PTR, 0, 0 },
255 { "Talcptr", TYPE_PTR, 0, 0 },
256 { "Taliptr", TYPE_PTR, 0, 0 },
257 { "Talfloat", TYPE_FLOAT, 0, 0 },
258 { "Taldouble", TYPE_FLOAT, 0, 0 },
259 { "Talldouble", TYPE_FLOAT, 0, 0 },
260 #ifndef SKIP_DECIMAL_FLOAT
261 { "TalDecimal32", TYPE_DEC_FLOAT, 0, 0 },
262 { "TalDecimal64", TYPE_DEC_FLOAT, 0, 0 },
263 { "TalDecimal128", TYPE_DEC_FLOAT, 0, 0 },
264 #endif
265 { "TalE0", TYPE_UENUM, 0, ' ' },
266 { "TalE1", TYPE_UENUM, 1, ' ' },
267 { "TalE2", TYPE_SENUM, 3, ' ' },
268 { "TalE3", TYPE_SENUM, 127, ' ' },
269 { "TalE4", TYPE_UENUM, 255, ' ' },
270 { "TalE5", TYPE_SENUM, 32767, ' ' },
271 { "TalE6", TYPE_UENUM, 65535, ' ' },
272 { "TalE7", TYPE_SENUM, 2147483647, ' ' },
273 { "TalE8", TYPE_UENUM, 4294967295U, ' ' },
274 { "TalE9", TYPE_SENUM, 1099511627775LL, ' ' },
275 { "Tal1char", TYPE_UINT, 127, 'C' },
276 { "Tal1schar", TYPE_INT, 127, 'C' },
277 { "Tal1uchar", TYPE_UINT, 255, 'C' },
278 { "Tal1short", TYPE_INT, 32767, 'S' },
279 { "Tal1ushort", TYPE_UINT, 65535, 'S' },
280 { "Tal1int", TYPE_INT, 2147483647, 'I' },
281 { "Tal1uint", TYPE_UINT, 4294967295U, 'I' },
282 { "Tal1long", TYPE_INT, 9223372036854775807LL, 'L' },
283 { "Tal1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
284 { "Tal1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
285 { "Tal1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
286 { "Tal1bool", TYPE_UINT, 1, 'B' },
287 { "Tal1ptr", TYPE_PTR, 0, 0 },
288 { "Tal1cptr", TYPE_PTR, 0, 0 },
289 { "Tal1iptr", TYPE_PTR, 0, 0 },
290 { "Tal1float", TYPE_FLOAT, 0, 0 },
291 { "Tal1double", TYPE_FLOAT, 0, 0 },
292 { "Tal1ldouble", TYPE_FLOAT, 0, 0 },
293 #ifndef SKIP_DECIMAL_FLOAT
294 { "Tal1Decimal32", TYPE_DEC_FLOAT, 0, 0},
295 { "Tal1Decimal64", TYPE_DEC_FLOAT, 0, 0},
296 { "Tal1Decimal128", TYPE_DEC_FLOAT, 0, 0},
297 #endif
298 { "Tal1E0", TYPE_UENUM, 0, ' ' },
299 { "Tal1E1", TYPE_UENUM, 1, ' ' },
300 { "Tal1E2", TYPE_SENUM, 3, ' ' },
301 { "Tal1E3", TYPE_SENUM, 127, ' ' },
302 { "Tal1E4", TYPE_UENUM, 255, ' ' },
303 { "Tal1E5", TYPE_SENUM, 32767, ' ' },
304 { "Tal1E6", TYPE_UENUM, 65535, ' ' },
305 { "Tal1E7", TYPE_SENUM, 2147483647, ' ' },
306 { "Tal1E8", TYPE_UENUM, 4294967295U, ' ' },
307 { "Tal1E9", TYPE_SENUM, 1099511627775LL, ' ' },
308 { "Tal2char", TYPE_UINT, 127, 'C' },
309 { "Tal2schar", TYPE_INT, 127, 'C' },
310 { "Tal2uchar", TYPE_UINT, 255, 'C' },
311 { "Tal2short", TYPE_INT, 32767, 'S' },
312 { "Tal2ushort", TYPE_UINT, 65535, 'S' },
313 { "Tal2int", TYPE_INT, 2147483647, 'I' },
314 { "Tal2uint", TYPE_UINT, 4294967295U, 'I' },
315 { "Tal2long", TYPE_INT, 9223372036854775807LL, 'L' },
316 { "Tal2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
317 { "Tal2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
318 { "Tal2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
319 { "Tal2bool", TYPE_UINT, 1, 'B' },
320 { "Tal2ptr", TYPE_PTR, 0, 0 },
321 { "Tal2cptr", TYPE_PTR, 0, 0 },
322 { "Tal2iptr", TYPE_PTR, 0, 0 },
323 { "Tal2float", TYPE_FLOAT, 0, 0 },
324 { "Tal2double", TYPE_FLOAT, 0, 0 },
325 { "Tal2ldouble", TYPE_FLOAT, 0, 0 },
326 #ifndef SKIP_DECIMAL_FLOAT
327 { "Tal2Decimal32", TYPE_DEC_FLOAT, 0, 0 },
328 { "Tal2Decimal64", TYPE_DEC_FLOAT, 0, 0 },
329 { "Tal2Decimal128", TYPE_DEC_FLOAT, 0, 0 },
330 #endif
331 { "Tal2E0", TYPE_UENUM, 0, ' ' },
332 { "Tal2E1", TYPE_UENUM, 1, ' ' },
333 { "Tal2E2", TYPE_SENUM, 3, ' ' },
334 { "Tal2E3", TYPE_SENUM, 127, ' ' },
335 { "Tal2E4", TYPE_UENUM, 255, ' ' },
336 { "Tal2E5", TYPE_SENUM, 32767, ' ' },
337 { "Tal2E6", TYPE_UENUM, 65535, ' ' },
338 { "Tal2E7", TYPE_SENUM, 2147483647, ' ' },
339 { "Tal2E8", TYPE_UENUM, 4294967295U, ' ' },
340 { "Tal2E9", TYPE_SENUM, 1099511627775LL, ' ' },
341 { "Tal4char", TYPE_UINT, 127, 'C' },
342 { "Tal4schar", TYPE_INT, 127, 'C' },
343 { "Tal4uchar", TYPE_UINT, 255, 'C' },
344 { "Tal4short", TYPE_INT, 32767, 'S' },
345 { "Tal4ushort", TYPE_UINT, 65535, 'S' },
346 { "Tal4int", TYPE_INT, 2147483647, 'I' },
347 { "Tal4uint", TYPE_UINT, 4294967295U, 'I' },
348 { "Tal4long", TYPE_INT, 9223372036854775807LL, 'L' },
349 { "Tal4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
350 { "Tal4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
351 { "Tal4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
352 { "Tal4bool", TYPE_UINT, 1, 'B' },
353 { "Tal4ptr", TYPE_PTR, 0, 0 },
354 { "Tal4cptr", TYPE_PTR, 0, 0 },
355 { "Tal4iptr", TYPE_PTR, 0, 0 },
356 { "Tal4float", TYPE_FLOAT, 0, 0 },
357 { "Tal4double", TYPE_FLOAT, 0, 0 },
358 { "Tal4ldouble", TYPE_FLOAT, 0, 0 },
359 #ifndef SKIP_DECIMAL_FLOAT
360 { "Tal4Decimal32", TYPE_DEC_FLOAT, 0, 0 },
361 { "Tal4Decimal64", TYPE_DEC_FLOAT, 0, 0 },
362 { "Tal4Decimal128", TYPE_DEC_FLOAT, 0, 0 },
363 #endif
364 { "Tal4E0", TYPE_UENUM, 0, ' ' },
365 { "Tal4E1", TYPE_UENUM, 1, ' ' },
366 { "Tal4E2", TYPE_SENUM, 3, ' ' },
367 { "Tal4E3", TYPE_SENUM, 127, ' ' },
368 { "Tal4E4", TYPE_UENUM, 255, ' ' },
369 { "Tal4E5", TYPE_SENUM, 32767, ' ' },
370 { "Tal4E6", TYPE_UENUM, 65535, ' ' },
371 { "Tal4E7", TYPE_SENUM, 2147483647, ' ' },
372 { "Tal4E8", TYPE_UENUM, 4294967295U, ' ' },
373 { "Tal4E9", TYPE_SENUM, 1099511627775LL, ' ' },
374 { "Tal8char", TYPE_UINT, 127, 'C' },
375 { "Tal8schar", TYPE_INT, 127, 'C' },
376 { "Tal8uchar", TYPE_UINT, 255, 'C' },
377 { "Tal8short", TYPE_INT, 32767, 'S' },
378 { "Tal8ushort", TYPE_UINT, 65535, 'S' },
379 { "Tal8int", TYPE_INT, 2147483647, 'I' },
380 { "Tal8uint", TYPE_UINT, 4294967295U, 'I' },
381 { "Tal8long", TYPE_INT, 9223372036854775807LL, 'L' },
382 { "Tal8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
383 { "Tal8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
384 { "Tal8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
385 { "Tal8bool", TYPE_UINT, 1, 'B' },
386 { "Tal8ptr", TYPE_PTR, 0, 0 },
387 { "Tal8cptr", TYPE_PTR, 0, 0 },
388 { "Tal8iptr", TYPE_PTR, 0, 0 },
389 { "Tal8float", TYPE_FLOAT, 0, 0 },
390 { "Tal8double", TYPE_FLOAT, 0, 0 },
391 { "Tal8ldouble", TYPE_FLOAT, 0, 0 },
392 #ifndef SKIP_DECIMAL_FLOAT
393 { "Tal8Decimal32", TYPE_DEC_FLOAT, 0, 0 },
394 { "Tal8Decimal64", TYPE_DEC_FLOAT, 0, 0 },
395 { "Tal8Decimal128", TYPE_DEC_FLOAT, 0, 0 },
396 #endif
397 { "Tal8E0", TYPE_UENUM, 0, ' ' },
398 { "Tal8E1", TYPE_UENUM, 1, ' ' },
399 { "Tal8E2", TYPE_SENUM, 3, ' ' },
400 { "Tal8E3", TYPE_SENUM, 127, ' ' },
401 { "Tal8E4", TYPE_UENUM, 255, ' ' },
402 { "Tal8E5", TYPE_SENUM, 32767, ' ' },
403 { "Tal8E6", TYPE_UENUM, 65535, ' ' },
404 { "Tal8E7", TYPE_SENUM, 2147483647, ' ' },
405 { "Tal8E8", TYPE_UENUM, 4294967295U, ' ' },
406 { "Tal8E9", TYPE_SENUM, 1099511627775LL, ' ' },
407 { "Tal16char", TYPE_UINT, 127, 'C' },
408 { "Tal16schar", TYPE_INT, 127, 'C' },
409 { "Tal16uchar", TYPE_UINT, 255, 'C' },
410 { "Tal16short", TYPE_INT, 32767, 'S' },
411 { "Tal16ushort", TYPE_UINT, 65535, 'S' },
412 { "Tal16int", TYPE_INT, 2147483647, 'I' },
413 { "Tal16uint", TYPE_UINT, 4294967295U, 'I' },
414 { "Tal16long", TYPE_INT, 9223372036854775807LL, 'L' },
415 { "Tal16ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
416 { "Tal16llong", TYPE_INT, 9223372036854775807LL, 'Q' },
417 { "Tal16ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
418 { "Tal16bool", TYPE_UINT, 1, 'B' },
419 { "Tal16ptr", TYPE_PTR, 0, 0 },
420 { "Tal16cptr", TYPE_PTR, 0, 0 },
421 { "Tal16iptr", TYPE_PTR, 0, 0 },
422 { "Tal16float", TYPE_FLOAT, 0, 0 },
423 { "Tal16double", TYPE_FLOAT, 0, 0 },
424 { "Tal16ldouble", TYPE_FLOAT, 0, 0 },
425 #ifndef SKIP_DECIMAL_FLOAT
426 { "Tal16Decimal32", TYPE_DEC_FLOAT, 0, 0 },
427 { "Tal16Decimal64", TYPE_DEC_FLOAT, 0, 0 },
428 { "Tal16Decimal128", TYPE_DEC_FLOAT, 0, 0 },
429 #endif
430 { "Tal16E0", TYPE_UENUM, 0, ' ' },
431 { "Tal16E1", TYPE_UENUM, 1, ' ' },
432 { "Tal16E2", TYPE_SENUM, 3, ' ' },
433 { "Tal16E3", TYPE_SENUM, 127, ' ' },
434 { "Tal16E4", TYPE_UENUM, 255, ' ' },
435 { "Tal16E5", TYPE_SENUM, 32767, ' ' },
436 { "Tal16E6", TYPE_UENUM, 65535, ' ' },
437 { "Tal16E7", TYPE_SENUM, 2147483647, ' ' },
438 { "Tal16E8", TYPE_UENUM, 4294967295U, ' ' },
439 { "Tal16E9", TYPE_SENUM, 1099511627775LL, ' ' }
440 #define NATYPES2 (sizeof (attrib_types) / sizeof (attrib_types[0]))
441 };
442 struct types complex_attrib_types[] = {
443 { "Talcchar", TYPE_CUINT, 127, 0 },
444 { "Talcschar", TYPE_CINT, 127, 0 },
445 { "Talcuchar", TYPE_CUINT, 255, 0 },
446 { "Talcshort", TYPE_CINT, 32767, 0 },
447 { "Talcushort", TYPE_CUINT, 65535, 0 },
448 { "Talcint", TYPE_CINT, 2147483647, 0 },
449 { "Talcuint", TYPE_CUINT, 4294967295U, 0 },
450 { "Talclong", TYPE_CINT, 9223372036854775807LL, 0 },
451 { "Talculong", TYPE_CUINT, 18446744073709551615ULL, 0 },
452 { "Talcllong", TYPE_CINT, 9223372036854775807LL, 0 },
453 { "Talcullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
454 { "Talcfloat", TYPE_CFLOAT, 0, 0 },
455 { "Talcdouble", TYPE_CFLOAT, 0, 0 },
456 { "Talcldouble", TYPE_CFLOAT, 0, 0 },
457 { "Tal1cchar", TYPE_CUINT, 127, 0 },
458 { "Tal1cschar", TYPE_CINT, 127, 0 },
459 { "Tal1cuchar", TYPE_CUINT, 255, 0 },
460 { "Tal1cshort", TYPE_CINT, 32767, 0 },
461 { "Tal1cushort", TYPE_CUINT, 65535, 0 },
462 { "Tal1cint", TYPE_CINT, 2147483647, 0 },
463 { "Tal1cuint", TYPE_CUINT, 4294967295U, 0 },
464 { "Tal1clong", TYPE_CINT, 9223372036854775807LL, 0 },
465 { "Tal1culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
466 { "Tal1cllong", TYPE_CINT, 9223372036854775807LL, 0 },
467 { "Tal1cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
468 { "Tal1cfloat", TYPE_CFLOAT, 0, 0 },
469 { "Tal1cdouble", TYPE_CFLOAT, 0, 0 },
470 { "Tal1cldouble", TYPE_CFLOAT, 0, 0 },
471 { "Tal2cchar", TYPE_CUINT, 127, 0 },
472 { "Tal2cschar", TYPE_CINT, 127, 0 },
473 { "Tal2cuchar", TYPE_CUINT, 255, 0 },
474 { "Tal2cshort", TYPE_CINT, 32767, 0 },
475 { "Tal2cushort", TYPE_CUINT, 65535, 0 },
476 { "Tal2cint", TYPE_CINT, 2147483647, 0 },
477 { "Tal2cuint", TYPE_CUINT, 4294967295U, 0 },
478 { "Tal2clong", TYPE_CINT, 9223372036854775807LL, 0 },
479 { "Tal2culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
480 { "Tal2cllong", TYPE_CINT, 9223372036854775807LL, 0 },
481 { "Tal2cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
482 { "Tal2cfloat", TYPE_CFLOAT, 0, 0 },
483 { "Tal2cdouble", TYPE_CFLOAT, 0, 0 },
484 { "Tal2cldouble", TYPE_CFLOAT, 0, 0 },
485 { "Tal4cchar", TYPE_CUINT, 127, 0 },
486 { "Tal4cschar", TYPE_CINT, 127, 0 },
487 { "Tal4cuchar", TYPE_CUINT, 255, 0 },
488 { "Tal4cshort", TYPE_CINT, 32767, 0 },
489 { "Tal4cushort", TYPE_CUINT, 65535, 0 },
490 { "Tal4cint", TYPE_CINT, 2147483647, 0 },
491 { "Tal4cuint", TYPE_CUINT, 4294967295U, 0 },
492 { "Tal4clong", TYPE_CINT, 9223372036854775807LL, 0 },
493 { "Tal4culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
494 { "Tal4cllong", TYPE_CINT, 9223372036854775807LL, 0 },
495 { "Tal4cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
496 { "Tal4cfloat", TYPE_CFLOAT, 0, 0 },
497 { "Tal4cdouble", TYPE_CFLOAT, 0, 0 },
498 { "Tal4cldouble", TYPE_CFLOAT, 0, 0 },
499 { "Tal8cchar", TYPE_CUINT, 127, 0 },
500 { "Tal8cschar", TYPE_CINT, 127, 0 },
501 { "Tal8cuchar", TYPE_CUINT, 255, 0 },
502 { "Tal8cshort", TYPE_CINT, 32767, 0 },
503 { "Tal8cushort", TYPE_CUINT, 65535, 0 },
504 { "Tal8cint", TYPE_CINT, 2147483647, 0 },
505 { "Tal8cuint", TYPE_CUINT, 4294967295U, 0 },
506 { "Tal8clong", TYPE_CINT, 9223372036854775807LL, 0 },
507 { "Tal8culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
508 { "Tal8cllong", TYPE_CINT, 9223372036854775807LL, 0 },
509 { "Tal8cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
510 { "Tal8cfloat", TYPE_CFLOAT, 0, 0 },
511 { "Tal8cdouble", TYPE_CFLOAT, 0, 0 },
512 { "Tal8cldouble", TYPE_CFLOAT, 0, 0 },
513 { "Tal16cchar", TYPE_CUINT, 127, 0 },
514 { "Tal16cschar", TYPE_CINT, 127, 0 },
515 { "Tal16cuchar", TYPE_CUINT, 255, 0 },
516 { "Tal16cshort", TYPE_CINT, 32767, 0 },
517 { "Tal16cushort", TYPE_CUINT, 65535, 0 },
518 { "Tal16cint", TYPE_CINT, 2147483647, 0 },
519 { "Tal16cuint", TYPE_CUINT, 4294967295U, 0 },
520 { "Tal16clong", TYPE_CINT, 9223372036854775807LL, 0 },
521 { "Tal16culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
522 { "Tal16cllong", TYPE_CINT, 9223372036854775807LL, 0 },
523 { "Tal16cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
524 { "Tal16cfloat", TYPE_CFLOAT, 0, 0 },
525 { "Tal16cdouble", TYPE_CFLOAT, 0, 0 },
526 { "Tal16cldouble", TYPE_CFLOAT, 0, 0 }
527 #define NCATYPES2 (sizeof (complex_attrib_types) / sizeof (complex_attrib_types[0]))
528 };
529 struct types attrib_array_types[] = {
530 { "Talx1char", TYPE_UINT, 127, 'C' },
531 { "Talx1schar", TYPE_INT, 127, 'C' },
532 { "Talx1uchar", TYPE_UINT, 255, 'C' },
533 { "Talx1short", TYPE_INT, 32767, 'S' },
534 { "Talx1ushort", TYPE_UINT, 65535, 'S' },
535 { "Talx1int", TYPE_INT, 2147483647, 'I' },
536 { "Talx1uint", TYPE_UINT, 4294967295U, 'I' },
537 { "Talx1long", TYPE_INT, 9223372036854775807LL, 'L' },
538 { "Talx1ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
539 { "Talx1llong", TYPE_INT, 9223372036854775807LL, 'Q' },
540 { "Talx1ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
541 { "Talx1bool", TYPE_UINT, 1, 'B' },
542 { "Talx1ptr", TYPE_PTR, 0, 0 },
543 { "Talx1cptr", TYPE_PTR, 0, 0 },
544 { "Talx1iptr", TYPE_PTR, 0, 0 },
545 { "Talx1float", TYPE_FLOAT, 0, 0 },
546 { "Talx1double", TYPE_FLOAT, 0, 0 },
547 { "Talx1ldouble", TYPE_FLOAT, 0, 0 },
548 #ifndef SKIP_DECIMAL_FLOAT
549 { "Talx1Decimal32", TYPE_DEC_FLOAT, 0 ,0 },
550 { "Talx1Decimal64", TYPE_DEC_FLOAT, 0 ,0 },
551 { "Talx1Decimal128", TYPE_DEC_FLOAT, 0 ,0 },
552 #endif
553 { "Talx1E0", TYPE_UENUM, 0, ' ' },
554 { "Talx1E1", TYPE_UENUM, 1, ' ' },
555 { "Talx1E2", TYPE_SENUM, 3, ' ' },
556 { "Talx1E3", TYPE_SENUM, 127, ' ' },
557 { "Talx1E4", TYPE_UENUM, 255, ' ' },
558 { "Talx1E5", TYPE_SENUM, 32767, ' ' },
559 { "Talx1E6", TYPE_UENUM, 65535, ' ' },
560 { "Talx1E7", TYPE_SENUM, 2147483647, ' ' },
561 { "Talx1E8", TYPE_UENUM, 4294967295U, ' ' },
562 { "Talx1E9", TYPE_SENUM, 1099511627775LL, ' ' },
563 { "Talx2short", TYPE_INT, 32767, 'S' },
564 { "Talx2ushort", TYPE_UINT, 65535, 'S' },
565 { "Talx2int", TYPE_INT, 2147483647, 'I' },
566 { "Talx2uint", TYPE_UINT, 4294967295U, 'I' },
567 { "Talx2long", TYPE_INT, 9223372036854775807LL, 'L' },
568 { "Talx2ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
569 { "Talx2llong", TYPE_INT, 9223372036854775807LL, 'Q' },
570 { "Talx2ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
571 { "Talx2ptr", TYPE_PTR, 0, 0 },
572 { "Talx2cptr", TYPE_PTR, 0, 0 },
573 { "Talx2iptr", TYPE_PTR, 0, 0 },
574 { "Talx2float", TYPE_FLOAT, 0, 0 },
575 { "Talx2double", TYPE_FLOAT, 0, 0 },
576 { "Talx2ldouble", TYPE_FLOAT, 0, 0 },
577 #ifndef SKIP_DECIMAL_FLOAT
578 { "Talx2Decimal32", TYPE_DEC_FLOAT, 0 , 0 },
579 { "Talx2Decimal64", TYPE_DEC_FLOAT, 0 , 0 },
580 { "Talx2Decimal128", TYPE_DEC_FLOAT, 0 , 0 },
581 #endif
582 { "Talx2E0", TYPE_UENUM, 0, ' ' },
583 { "Talx2E1", TYPE_UENUM, 1, ' ' },
584 { "Talx2E2", TYPE_SENUM, 3, ' ' },
585 { "Talx2E3", TYPE_SENUM, 127, ' ' },
586 { "Talx2E4", TYPE_UENUM, 255, ' ' },
587 { "Talx2E5", TYPE_SENUM, 32767, ' ' },
588 { "Talx2E6", TYPE_UENUM, 65535, ' ' },
589 { "Talx2E7", TYPE_SENUM, 2147483647, ' ' },
590 { "Talx2E8", TYPE_UENUM, 4294967295U, ' ' },
591 { "Talx2E9", TYPE_SENUM, 1099511627775LL, ' ' },
592 { "Talx4int", TYPE_INT, 2147483647, 'I' },
593 { "Talx4uint", TYPE_UINT, 4294967295U, 'I' },
594 { "Talx4long", TYPE_INT, 9223372036854775807LL, 'L' },
595 { "Talx4ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
596 { "Talx4llong", TYPE_INT, 9223372036854775807LL, 'Q' },
597 { "Talx4ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
598 { "Talx4ptr", TYPE_PTR, 0, 0 },
599 { "Talx4cptr", TYPE_PTR, 0, 0 },
600 { "Talx4iptr", TYPE_PTR, 0, 0 },
601 { "Talx4float", TYPE_FLOAT, 0, 0 },
602 { "Talx4double", TYPE_FLOAT, 0, 0 },
603 { "Talx4ldouble", TYPE_FLOAT, 0, 0 },
604 #ifndef SKIP_DECIMAL_FLOAT
605 { "Talx4Decimal32", TYPE_DEC_FLOAT, 0 , 0 },
606 { "Talx4Decimal64", TYPE_DEC_FLOAT, 0 , 0 },
607 { "Talx4Decimal128", TYPE_DEC_FLOAT, 0 , 0 },
608 #endif
609 { "Talx4E0", TYPE_UENUM, 0, ' ' },
610 { "Talx4E1", TYPE_UENUM, 1, ' ' },
611 { "Talx4E2", TYPE_SENUM, 3, ' ' },
612 { "Talx4E3", TYPE_SENUM, 127, ' ' },
613 { "Talx4E4", TYPE_UENUM, 255, ' ' },
614 { "Talx4E5", TYPE_SENUM, 32767, ' ' },
615 { "Talx4E6", TYPE_UENUM, 65535, ' ' },
616 { "Talx4E7", TYPE_SENUM, 2147483647, ' ' },
617 { "Talx4E8", TYPE_UENUM, 4294967295U, ' ' },
618 { "Talx4E9", TYPE_SENUM, 1099511627775LL, ' ' },
619 { "Taly8long", TYPE_INT, 9223372036854775807LL, 'L' },
620 { "Taly8ulong", TYPE_UINT, 18446744073709551615ULL, 'L' },
621 { "Talx8llong", TYPE_INT, 9223372036854775807LL, 'Q' },
622 { "Talx8ullong", TYPE_UINT, 18446744073709551615ULL, 'Q' },
623 { "Taly8ptr", TYPE_PTR, 0, 0 },
624 { "Taly8cptr", TYPE_PTR, 0, 0 },
625 { "Taly8iptr", TYPE_PTR, 0, 0 },
626 { "Talx8double", TYPE_FLOAT, 0, 0 },
627 { "Talx8ldouble", TYPE_FLOAT, 0, 0 },
628 #ifndef SKIP_DECIMAL_FLOAT
629 { "Talx8Decimal64", TYPE_DEC_FLOAT, 0, 0 },
630 { "Talx8Decimal128", TYPE_DEC_FLOAT, 0, 0 }
631 #endif
632 #define NAATYPES2 (sizeof (attrib_array_types) / sizeof (attrib_array_types[0]))
633 };
634 struct types complex_attrib_array_types[] = {
635 { "Talx1cchar", TYPE_CUINT, 127, 0 },
636 { "Talx1cschar", TYPE_CINT, 127, 0 },
637 { "Talx1cuchar", TYPE_CUINT, 255, 0 },
638 { "Talx1cshort", TYPE_CINT, 32767, 0 },
639 { "Talx1cushort", TYPE_CUINT, 65535, 0 },
640 { "Talx1cint", TYPE_CINT, 2147483647, 0 },
641 { "Talx1cuint", TYPE_CUINT, 4294967295U, 0 },
642 { "Talx1clong", TYPE_CINT, 9223372036854775807LL, 0 },
643 { "Talx1culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
644 { "Talx1cllong", TYPE_CINT, 9223372036854775807LL, 0 },
645 { "Talx1cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
646 { "Talx1cfloat", TYPE_CFLOAT, 0, 0 },
647 { "Talx1cdouble", TYPE_CFLOAT, 0, 0 },
648 { "Talx1cldouble", TYPE_CFLOAT, 0, 0 },
649 { "Talx2cchar", TYPE_CUINT, 127, 0 },
650 { "Talx2cschar", TYPE_CINT, 127, 0 },
651 { "Talx2cuchar", TYPE_CUINT, 255, 0 },
652 { "Talx2cshort", TYPE_CINT, 32767, 0 },
653 { "Talx2cushort", TYPE_CUINT, 65535, 0 },
654 { "Talx2cint", TYPE_CINT, 2147483647, 0 },
655 { "Talx2cuint", TYPE_CUINT, 4294967295U, 0 },
656 { "Talx2clong", TYPE_CINT, 9223372036854775807LL, 0 },
657 { "Talx2culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
658 { "Talx2cllong", TYPE_CINT, 9223372036854775807LL, 0 },
659 { "Talx2cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
660 { "Talx2cfloat", TYPE_CFLOAT, 0, 0 },
661 { "Talx2cdouble", TYPE_CFLOAT, 0, 0 },
662 { "Talx2cldouble", TYPE_CFLOAT, 0, 0 },
663 { "Talx4cshort", TYPE_CINT, 32767, 0 },
664 { "Talx4cushort", TYPE_CUINT, 65535, 0 },
665 { "Talx4cint", TYPE_CINT, 2147483647, 0 },
666 { "Talx4cuint", TYPE_CUINT, 4294967295U, 0 },
667 { "Talx4clong", TYPE_CINT, 9223372036854775807LL, 0 },
668 { "Talx4culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
669 { "Talx4cllong", TYPE_CINT, 9223372036854775807LL, 0 },
670 { "Talx4cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
671 { "Talx4cfloat", TYPE_CFLOAT, 0, 0 },
672 { "Talx4cdouble", TYPE_CFLOAT, 0, 0 },
673 { "Talx4cldouble", TYPE_CFLOAT, 0, 0 },
674 { "Talx8cint", TYPE_CINT, 2147483647, 0 },
675 { "Talx8cuint", TYPE_CUINT, 4294967295U, 0 },
676 { "Talx8clong", TYPE_CINT, 9223372036854775807LL, 0 },
677 { "Talx8culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
678 { "Talx8cllong", TYPE_CINT, 9223372036854775807LL, 0 },
679 { "Talx8cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
680 { "Talx8cfloat", TYPE_CFLOAT, 0, 0 },
681 { "Talx8cdouble", TYPE_CFLOAT, 0, 0 },
682 { "Talx8cldouble", TYPE_CFLOAT, 0, 0 },
683 { "Taly16clong", TYPE_CINT, 9223372036854775807LL, 0 },
684 { "Taly16culong", TYPE_CUINT, 18446744073709551615ULL, 0 },
685 { "Talx16cllong", TYPE_CINT, 9223372036854775807LL, 0 },
686 { "Talx16cullong", TYPE_CUINT, 18446744073709551615ULL, 0 },
687 { "Talx16cdouble", TYPE_CFLOAT, 0, 0 },
688 { "Talx16cldouble", TYPE_CFLOAT, 0, 0 }
689 #define NCAATYPES2 (sizeof (complex_attrib_array_types) / sizeof (complex_attrib_array_types[0]))
690 };
691
692 struct types bitfld_types[NTYPES2];
693 int n_bitfld_types;
694 struct types aligned_bitfld_types[NATYPES2];
695 int n_aligned_bitfld_types;
696
697 const char *attributes[] = {
698 "atal",
699 "atpa",
700 "atal1",
701 "atal2",
702 "atal4",
703 "atal8",
704 "atal16",
705 #define NATTRIBS1 7
706 "atalpa",
707 "atpaal",
708 "atal1pa",
709 "atal2pa",
710 "atal4pa",
711 "atal8pa",
712 "atal16pa",
713 "atpaal1",
714 "atpaal2",
715 "atpaal4",
716 "atpaal8",
717 "atpaal16"
718 #define NATTRIBS2 (sizeof (attributes) / sizeof (attributes[0]))
719 };
720
721 enum ETYPE
722 {
723 ETYPE_TYPE,
724 ETYPE_ARRAY,
725 ETYPE_BITFLD,
726 ETYPE_STRUCT,
727 ETYPE_UNION,
728 ETYPE_STRUCT_ARRAY,
729 ETYPE_UNION_ARRAY
730 };
731
732 struct entry
733 {
734 #ifdef __GNUC__
735 enum ETYPE etype : 8;
736 #else
737 unsigned char etype;
738 #endif
739 unsigned short len;
740 unsigned char arr_len;
741 struct types *type;
742 const char *attrib;
743 /* Used to chain together entries in the hash table. */
744 struct entry *next;
745 };
746
747 /* A prime number giving the number of slots in the hash table. */
748 #define HASH_SIZE 32749
749 static struct entry *hash_table[HASH_SIZE];
750
751 static int idx, limidx, output_one, short_enums;
752 static const char *destdir;
753 static const char *srcdir;
754 static const char *srcdir_safe;
755 FILE *outfile;
756
757 void
switchfiles(int fields)758 switchfiles (int fields)
759 {
760 static int filecnt;
761 static char *destbuf, *destptr;
762 int i;
763
764 ++filecnt;
765 if (outfile)
766 fclose (outfile);
767 if (output_one)
768 {
769 outfile = stdout;
770 return;
771 }
772 if (destbuf == NULL)
773 {
774 size_t len = strlen (destdir);
775 destbuf = malloc (len + 20);
776 if (!destbuf)
777 abort ();
778 memcpy (destbuf, destdir, len);
779 if (!len || destbuf[len - 1] != '/')
780 destbuf[len++] = '/';
781 destptr = destbuf + len;
782 }
783 sprintf (destptr, "t%03d_main.c", filecnt);
784 outfile = fopen (destbuf, "w");
785 if (outfile == NULL)
786 {
787 fail:
788 fputs ("failed to create test files\n", stderr);
789 exit (1);
790 }
791 fprintf (outfile, "/* { dg-require-effective-target int32plus } */\n");
792 for (i = 0; i < NDG_OPTIONS; i++)
793 fprintf (outfile, dg_options[i], "", srcdir_safe);
794 fprintf (outfile, "/* { dg-prune-output \".*-Wno-abi.*\" } */\n");
795 fprintf (outfile, "/* { dg-prune-output \".*Offset of packed bit-field.*\" } */\n");
796 fprintf (outfile, "\
797 #include \"struct-layout-1.h\"\n\
798 \n\
799 #define TX(n, type, attrs, fields, ops) extern void test##n (void);\n\
800 #include \"t%03d_test.h\"\n\
801 #undef TX\n\
802 \n\
803 int main (void)\n\
804 {\n\
805 #define TX(n, type, attrs, fields, ops) test##n ();\n\
806 #include \"t%03d_test.h\"\n\
807 #undef TX\n\
808 exit (fails != 0);\n\
809 }\n", filecnt, filecnt);
810 fclose (outfile);
811 sprintf (destptr, "t%03d_x.c", filecnt);
812 outfile = fopen (destbuf, "w");
813 if (outfile == NULL)
814 goto fail;
815 for (i = 0; i < NDG_OPTIONS; i++)
816 fprintf (outfile, dg_options[i], "-w ", srcdir_safe);
817 fprintf (outfile, "\
818 #include \"struct-layout-1_x1.h\"\n\
819 #include \"t%03d_test.h\"\n\
820 #include \"struct-layout-1_x2.h\"\n\
821 #include \"t%03d_test.h\"\n", filecnt, filecnt);
822 fclose (outfile);
823 sprintf (destptr, "t%03d_y.c", filecnt);
824 outfile = fopen (destbuf, "w");
825 if (outfile == NULL)
826 goto fail;
827 for (i = 0; i < NDG_OPTIONS; i++)
828 fprintf (outfile, dg_options[i], "-w ", srcdir_safe);
829 fprintf (outfile, "\
830 #include \"struct-layout-1_y1.h\"\n\
831 #include \"t%03d_test.h\"\n\
832 #include \"struct-layout-1_y2.h\"\n\
833 #include \"t%03d_test.h\"\n", filecnt, filecnt);
834 fclose (outfile);
835 sprintf (destptr, "t%03d_test.h", filecnt);
836 outfile = fopen (destbuf, "w");
837 if (outfile == NULL)
838 goto fail;
839 if (fields <= 2)
840 limidx = idx + 300;
841 else if (fields <= 4)
842 limidx = idx + 200;
843 else if (fields <= 6)
844 limidx = idx + 100;
845 else
846 limidx = idx + 50;
847 }
848
849 unsigned long long int
getrandll(void)850 getrandll (void)
851 {
852 unsigned long long int ret;
853 ret = generate_random () & 0xffffff;
854 ret |= (generate_random () & 0xffffffLL) << 24;
855 ret |= ((unsigned long long int) generate_random ()) << 48;
856 return ret;
857 }
858
859 int
subfield(struct entry * e,char * letter)860 subfield (struct entry *e, char *letter)
861 {
862 int i, type;
863 char buf[20];
864 const char *p;
865 switch (e[0].etype)
866 {
867 case ETYPE_STRUCT:
868 case ETYPE_UNION:
869 case ETYPE_STRUCT_ARRAY:
870 case ETYPE_UNION_ARRAY:
871 type = e[0].attrib ? 1 + (generate_random () & 3) : 0;
872 if (e[0].etype == ETYPE_STRUCT || e[0].etype == ETYPE_STRUCT_ARRAY)
873 p = "struct";
874 else
875 p = "union";
876 if (e[0].etype == ETYPE_STRUCT_ARRAY || e[0].etype == ETYPE_UNION_ARRAY)
877 {
878 if (e[0].arr_len == 255)
879 snprintf (buf, 20, "%c[]", *letter);
880 else
881 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
882 /* If this is an array type, do not put aligned attributes on
883 elements. Aligning elements to a value greater than their
884 size will result in a compiler error. */
885 if (type == 1
886 && ((strncmp (e[0].attrib, "atal", 4) == 0)
887 || strncmp (e[0].attrib, "atpaal", 6) == 0))
888 type = 2;
889 }
890 else
891 {
892 buf[0] = *letter;
893 buf[1] = '\0';
894 }
895 ++*letter;
896 switch (type)
897 {
898 case 0:
899 case 3:
900 case 4:
901 fprintf (outfile, "%s{", p);
902 break;
903 case 1:
904 fprintf (outfile, "%s %s{", e[0].attrib, p);
905 break;
906 case 2:
907 fprintf (outfile, "%s %s{", p, e[0].attrib);
908 break;
909 }
910
911 for (i = 1; i <= e[0].len; )
912 i += subfield (e + i, letter);
913
914 switch (type)
915 {
916 case 0:
917 case 1:
918 case 2:
919 fprintf (outfile, "}%s;", buf);
920 break;
921 case 3:
922 fprintf (outfile, "}%s %s;", e[0].attrib, buf);
923 break;
924 case 4:
925 fprintf (outfile, "}%s %s;", buf, e[0].attrib);
926 break;
927 }
928 return 1 + e[0].len;
929 case ETYPE_TYPE:
930 case ETYPE_ARRAY:
931 if (e[0].etype == ETYPE_ARRAY)
932 {
933 if (e[0].arr_len == 255)
934 snprintf (buf, 20, "%c[]", *letter);
935 else
936 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len);
937 }
938 else
939 {
940 buf[0] = *letter;
941 buf[1] = '\0';
942 }
943 ++*letter;
944 if (e[0].attrib)
945 {
946 /* If this is an array type, do not put aligned attributes on
947 elements. Aligning elements to a value greater than their
948 size will result in a compiler error. */
949 if (e[0].etype == ETYPE_ARRAY
950 && ((strncmp (e[0].attrib, "atal", 4) == 0)
951 || strncmp (e[0].attrib, "atpaal", 6) == 0))
952 type = 2;
953 else
954 type = generate_random () % 3;
955 switch (type)
956 {
957 case 0:
958 fprintf (outfile, "%s %s %s;", e[0].attrib, e[0].type->name,
959 buf);
960 break;
961 case 1:
962 fprintf (outfile, "%s %s %s;", e[0].type->name, e[0].attrib,
963 buf);
964 break;
965 case 2:
966 fprintf (outfile, "%s %s %s;", e[0].type->name, buf,
967 e[0].attrib);
968 break;
969 }
970 }
971 else
972 fprintf (outfile, "%s %s;", e[0].type->name, buf);
973 return 1;
974 case ETYPE_BITFLD:
975 if (e[0].len == 0)
976 {
977 if (e[0].attrib)
978 switch (generate_random () % 3)
979 {
980 case 0:
981 fprintf (outfile, "%s %s:0;", e[0].attrib, e[0].type->name);
982 break;
983 case 1:
984 fprintf (outfile, "%s %s:0;", e[0].type->name, e[0].attrib);
985 break;
986 case 2:
987 fprintf (outfile, "%s:0 %s;", e[0].type->name, e[0].attrib);
988 break;
989 }
990 else
991 fprintf (outfile, "%s:0;", e[0].type->name);
992 ++*letter;
993 return 1;
994 }
995 switch (e[0].type->bitfld)
996 {
997 case 'C':
998 case 'S':
999 case 'I':
1000 case 'L':
1001 case 'Q':
1002 snprintf (buf, 20, "B%cN(%d)", e[0].type->bitfld, e[0].len);
1003 break;
1004 case 'B':
1005 case ' ':
1006 snprintf (buf, 20, "%d", e[0].len);
1007 break;
1008 default:
1009 abort ();
1010 }
1011 if (e[0].attrib)
1012 switch (generate_random () % 3)
1013 {
1014 case 0:
1015 fprintf (outfile, "%s %s %c:%s;", e[0].attrib, e[0].type->name,
1016 *letter, buf);
1017 break;
1018 case 1:
1019 fprintf (outfile, "%s %s %c:%s;", e[0].type->name, e[0].attrib,
1020 *letter, buf);
1021 break;
1022 case 2:
1023 fprintf (outfile, "%s %c:%s %s;", e[0].type->name, *letter,
1024 buf, e[0].attrib);
1025 break;
1026 }
1027 else
1028 fprintf (outfile, "%s %c:%s;", e[0].type->name, *letter, buf);
1029 ++*letter;
1030 return 1;
1031 default:
1032 abort ();
1033 }
1034 }
1035
1036 char namebuf[1024];
1037
1038 void
output_FNB(char mode,struct entry * e)1039 output_FNB (char mode, struct entry *e)
1040 {
1041 unsigned long long int l1, l2, m;
1042 int signs = 0;
1043 #ifndef SKIP_DECIMAL_FLOAT
1044 int suffix = 0;
1045 char DEC_SUFFIX[3][3]={"DF","DD","DL"};
1046 #endif
1047
1048 const char *p, *q;
1049
1050 if (e->type->type == TYPE_OTHER)
1051 {
1052 if (mode == 'B')
1053 abort ();
1054 fprintf (outfile, "N(%d,%s)", idx, namebuf);
1055 return;
1056 }
1057 fprintf (outfile, "%c(%d,%s,", mode, idx, namebuf);
1058 l1 = getrandll ();
1059 l2 = getrandll ();
1060 switch (e->type->type)
1061 {
1062 case TYPE_INT:
1063 signs = generate_random () & 3;
1064 m = e->type->maxval;
1065 if (mode == 'B')
1066 m &= e->len > 1 ? (1ULL << (e->len - 1)) - 1 : 1;
1067 l1 &= m;
1068 l2 &= m;
1069 fprintf (outfile, "%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s",
1070 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
1071 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
1072 break;
1073 case TYPE_UINT:
1074 m = e->type->maxval;
1075 if (mode == 'B')
1076 m &= (1ULL << e->len) - 1;
1077 l1 &= m;
1078 l2 &= m;
1079 fprintf (outfile, "%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s",
1080 l1, l1 > 4294967295U ? "LL" : "",
1081 l2, l2 > 4294967295U ? "LL" : "");
1082 break;
1083 case TYPE_FLOAT:
1084 l1 &= 0xffffff;
1085 l2 &= 0xffffff;
1086 signs = generate_random () & 3;
1087 fprintf (outfile, "%s%f,%s%f", (signs & 1) ? "-" : "",
1088 ((double) l1) / 64, (signs & 2) ? "-" : "", ((double) l2) / 64);
1089 break;
1090 #ifndef SKIP_DECIMAL_FLOAT
1091 case TYPE_DEC_FLOAT:
1092 l1 &= 0xffffff;
1093 l2 &= 0xffffff;
1094 signs = generate_random () & 3;
1095
1096 /* Get the suffix of Decimal Floting Points per
1097 e->type->name. Distinguish these three DFP types by
1098 e->type->name. */
1099 if (strstr(e->type->name, "Decimal32")) suffix=0;
1100 else if (strstr(e->type->name, "Decimal64")) suffix=1;
1101 else if (strstr(e->type->name, "Decimal128")) suffix=2;
1102 else
1103 abort ();
1104
1105 /* Formatted input/output specifiers for DFP types have not been
1106 implemented in GLIBC. %f here used in fprintf is just to
1107 dump the numbers to outfile. */
1108 fprintf (outfile, "%s%f%s,%s%f%s",
1109 (signs & 1) ? "-" : "", ((double) l1) / 64, DEC_SUFFIX[suffix],
1110 (signs & 2) ? "-" : "", ((double) l2) / 64, DEC_SUFFIX[suffix]);
1111 break;
1112 #endif
1113 case TYPE_CINT:
1114 signs = generate_random () & 3;
1115 l1 &= e->type->maxval;
1116 l2 &= e->type->maxval;
1117 fprintf (outfile,
1118 "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s),",
1119 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
1120 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
1121 signs = generate_random () & 3;
1122 l1 = getrandll ();
1123 l2 = getrandll ();
1124 l1 &= e->type->maxval;
1125 l2 &= e->type->maxval;
1126 fprintf (outfile,
1127 "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s)",
1128 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "",
1129 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : "");
1130 break;
1131 case TYPE_CUINT:
1132 l1 &= e->type->maxval;
1133 l2 &= e->type->maxval;
1134 fprintf (outfile,
1135 "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s),",
1136 l1, l1 > 4294967295U ? "LL" : "",
1137 l2, l2 > 4294967295U ? "LL" : "");
1138 l1 = getrandll ();
1139 l2 = getrandll ();
1140 l1 &= e->type->maxval;
1141 l2 &= e->type->maxval;
1142 fprintf (outfile,
1143 "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s)",
1144 l1, l1 > 4294967295U ? "LL" : "",
1145 l2, l2 > 4294967295U ? "LL" : "");
1146 break;
1147 case TYPE_CFLOAT:
1148 l1 &= 0xffffff;
1149 l2 &= 0xffffff;
1150 signs = generate_random () & 3;
1151 fprintf (outfile, "CDBL(%s%f,%s%f),",
1152 (signs & 1) ? "-" : "", ((double) l1) / 64,
1153 (signs & 2) ? "-" : "", ((double) l2) / 64);
1154 l1 = getrandll ();
1155 l2 = getrandll ();
1156 l1 &= 0xffffff;
1157 l2 &= 0xffffff;
1158 signs = generate_random () & 3;
1159 fprintf (outfile, "CDBL(%s%f,%s%f)",
1160 (signs & 1) ? "-" : "", ((double) l1) / 64,
1161 (signs & 2) ? "-" : "", ((double) l2) / 64);
1162 break;
1163 case TYPE_UENUM:
1164 if (e->type->maxval == 0)
1165 fputs ("e0_0,e0_0", outfile);
1166 else if (e->type->maxval == 1)
1167 fprintf (outfile, "e1_%" COMPAT_PRLL "d,e1_%" COMPAT_PRLL "d",
1168 l1 & 1, l2 & 1);
1169 else
1170 {
1171 p = strchr (e->type->name, '\0');
1172 while (--p >= e->type->name && *p >= '0' && *p <= '9');
1173 p++;
1174 l1 %= 7;
1175 l2 %= 7;
1176 if (l1 > 3)
1177 l1 += e->type->maxval - 6;
1178 if (l2 > 3)
1179 l2 += e->type->maxval - 6;
1180 fprintf (outfile, "e%s_%" COMPAT_PRLL "d,e%s_%" COMPAT_PRLL "d",
1181 p, l1, p, l2);
1182 }
1183 break;
1184 case TYPE_SENUM:
1185 p = strchr (e->type->name, '\0');
1186 while (--p >= e->type->name && *p >= '0' && *p <= '9');
1187 p++;
1188 l1 %= 7;
1189 l2 %= 7;
1190 fprintf (outfile, "e%s_%s%" COMPAT_PRLL "d,e%s_%s%" COMPAT_PRLL "d",
1191 p, l1 < 3 ? "m" : "",
1192 l1 == 3 ? 0LL : e->type->maxval - (l1 & 3),
1193 p, l2 < 3 ? "m" : "",
1194 l2 == 3 ? 0LL : e->type->maxval - (l2 & 3));
1195 break;
1196 case TYPE_PTR:
1197 l1 %= 256;
1198 l2 %= 256;
1199 fprintf (outfile,
1200 "(%s)&intarray[%" COMPAT_PRLL "d], (%s)&intarray[%" COMPAT_PRLL "d]",
1201 e->type->name, l1, e->type->name, l2);
1202 break;
1203 case TYPE_FNPTR:
1204 l1 %= 10;
1205 l2 %= 10;
1206 fprintf (outfile, "fn%" COMPAT_PRLL "d,fn%" COMPAT_PRLL "d", l1, l2);
1207 break;
1208 default:
1209 abort ();
1210 }
1211 fputs (")", outfile);
1212 }
1213
1214 int
subvalues(struct entry * e,char * p,char * letter)1215 subvalues (struct entry *e, char *p, char *letter)
1216 {
1217 int i, j;
1218 char *q;
1219 if (p >= namebuf + sizeof (namebuf) - 32)
1220 abort ();
1221 p[0] = *letter;
1222 p[1] = '\0';
1223 q = p + 1;
1224 switch (e[0].etype)
1225 {
1226 case ETYPE_STRUCT_ARRAY:
1227 case ETYPE_UNION_ARRAY:
1228 if (e[0].arr_len == 0 || e[0].arr_len == 255)
1229 {
1230 *letter += 1 + e[0].len;
1231 return 1 + e[0].len;
1232 }
1233 i = generate_random () % e[0].arr_len;
1234 snprintf (p, sizeof (namebuf) - (p - namebuf) - 1,
1235 "%c[%d]", *letter, i);
1236 q = strchr (p, '\0');
1237 /* FALLTHROUGH */
1238 case ETYPE_STRUCT:
1239 case ETYPE_UNION:
1240 *q++ = '.';
1241 ++*letter;
1242 for (i = 1; i <= e[0].len; )
1243 {
1244 i += subvalues (e + i, q, letter);
1245 if (e[0].etype == ETYPE_UNION || e[0].etype == ETYPE_UNION_ARRAY)
1246 {
1247 *letter += e[0].len - i + 1;
1248 break;
1249 }
1250 }
1251 return 1 + e[0].len;
1252 case ETYPE_TYPE:
1253 ++*letter;
1254 output_FNB ('F', e);
1255 return 1;
1256 case ETYPE_ARRAY:
1257 if (e[0].arr_len == 0 || e[0].arr_len == 255)
1258 {
1259 ++*letter;
1260 return 1;
1261 }
1262 i = generate_random () % e[0].arr_len;
1263 snprintf (p, sizeof (namebuf) - (p - namebuf),
1264 "%c[%d]", *letter, i);
1265 output_FNB ('F', e);
1266 if ((generate_random () & 7) == 0)
1267 {
1268 j = generate_random () % e[0].arr_len;
1269 if (i != j)
1270 {
1271 snprintf (p, sizeof (namebuf) - (p - namebuf),
1272 "%c[%d]", *letter, j);
1273 output_FNB ('F', e);
1274 }
1275 }
1276 ++*letter;
1277 return 1;
1278 case ETYPE_BITFLD:
1279 ++*letter;
1280 if (e[0].len != 0)
1281 output_FNB ('B', e);
1282 return 1;
1283 default:
1284 return 0;
1285 }
1286 }
1287
1288 /* DERIVED FROM:
1289 --------------------------------------------------------------------
1290 lookup2.c, by Bob Jenkins, December 1996, Public Domain.
1291 hash(), hash2(), hash3, and mix() are externally useful functions.
1292 Routines to test the hash are included if SELF_TEST is defined.
1293 You can use this free for any purpose. It has no warranty.
1294 --------------------------------------------------------------------
1295 */
1296
1297 /*
1298 --------------------------------------------------------------------
1299 mix -- mix 3 32-bit values reversibly.
1300 For every delta with one or two bit set, and the deltas of all three
1301 high bits or all three low bits, whether the original value of a,b,c
1302 is almost all zero or is uniformly distributed,
1303 * If mix() is run forward or backward, at least 32 bits in a,b,c
1304 have at least 1/4 probability of changing.
1305 * If mix() is run forward, every bit of c will change between 1/3 and
1306 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
1307 mix() was built out of 36 single-cycle latency instructions in a
1308 structure that could supported 2x parallelism, like so:
1309 a -= b;
1310 a -= c; x = (c>>13);
1311 b -= c; a ^= x;
1312 b -= a; x = (a<<8);
1313 c -= a; b ^= x;
1314 c -= b; x = (b>>13);
1315 ...
1316 Unfortunately, superscalar Pentiums and Sparcs can't take advantage
1317 of that parallelism. They've also turned some of those single-cycle
1318 latency instructions into multi-cycle latency instructions. Still,
1319 this is the fastest good hash I could find. There were about 2^^68
1320 to choose from. I only looked at a billion or so.
1321 --------------------------------------------------------------------
1322 */
1323 /* same, but slower, works on systems that might have 8 byte hashval_t's */
1324 #define mix(a,b,c) \
1325 { \
1326 a -= b; a -= c; a ^= (c>>13); \
1327 b -= c; b -= a; b ^= (a<< 8); \
1328 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
1329 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
1330 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
1331 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
1332 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
1333 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
1334 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
1335 }
1336
1337 /*
1338 --------------------------------------------------------------------
1339 hash() -- hash a variable-length key into a 32-bit value
1340 k : the key (the unaligned variable-length array of bytes)
1341 len : the length of the key, counting by bytes
1342 level : can be any 4-byte value
1343 Returns a 32-bit value. Every bit of the key affects every bit of
1344 the return value. Every 1-bit and 2-bit delta achieves avalanche.
1345 About 36+6len instructions.
1346
1347 The best hash table sizes are powers of 2. There is no need to do
1348 mod a prime (mod is sooo slow!). If you need less than 32 bits,
1349 use a bitmask. For example, if you need only 10 bits, do
1350 h = (h & hashmask(10));
1351 In which case, the hash table should have hashsize(10) elements.
1352
1353 If you are hashing n strings (ub1 **)k, do it like this:
1354 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
1355
1356 By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
1357 code any way you wish, private, educational, or commercial. It's free.
1358
1359 See http://burtleburtle.net/bob/hash/evahash.html
1360 Use for hash table lookup, or anything where one collision in 2^32 is
1361 acceptable. Do NOT use for cryptographic purposes.
1362 --------------------------------------------------------------------
1363 */
1364
1365 static hashval_t
iterative_hash(const void * k_in,register size_t length,register hashval_t initval)1366 iterative_hash (const void *k_in /* the key */,
1367 register size_t length /* the length of the key */,
1368 register hashval_t initval /* the previous hash, or
1369 an arbitrary value */)
1370 {
1371 register const unsigned char *k = (const unsigned char *)k_in;
1372 register hashval_t a,b,c,len;
1373
1374 /* Set up the internal state */
1375 len = length;
1376 a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
1377 c = initval; /* the previous hash value */
1378
1379 /*---------------------------------------- handle most of the key */
1380 while (len >= 12)
1381 {
1382 a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24));
1383 b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24));
1384 c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24));
1385 mix(a,b,c);
1386 k += 12; len -= 12;
1387 }
1388
1389 /*------------------------------------- handle the last 11 bytes */
1390 c += length;
1391 switch(len) /* all the case statements fall through */
1392 {
1393 case 11: c+=((hashval_t)k[10]<<24);
1394 case 10: c+=((hashval_t)k[9]<<16);
1395 case 9 : c+=((hashval_t)k[8]<<8);
1396 /* the first byte of c is reserved for the length */
1397 case 8 : b+=((hashval_t)k[7]<<24);
1398 case 7 : b+=((hashval_t)k[6]<<16);
1399 case 6 : b+=((hashval_t)k[5]<<8);
1400 case 5 : b+=k[4];
1401 case 4 : a+=((hashval_t)k[3]<<24);
1402 case 3 : a+=((hashval_t)k[2]<<16);
1403 case 2 : a+=((hashval_t)k[1]<<8);
1404 case 1 : a+=k[0];
1405 /* case 0: nothing left to add */
1406 }
1407 mix(a,b,c);
1408 /*-------------------------------------------- report the result */
1409 return c;
1410 }
1411
1412 hashval_t
e_hash(const void * a)1413 e_hash (const void *a)
1414 {
1415 const struct entry *e = a;
1416 hashval_t ret = 0;
1417 int i;
1418
1419 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
1420 abort ();
1421 for (i = 0; i <= e[0].len; ++i)
1422 {
1423 int attriblen;
1424 ret = iterative_hash (&e[i], offsetof (struct entry, attrib), ret);
1425 attriblen = e[i].attrib ? strlen (e[i].attrib) : -1;
1426 ret = iterative_hash (&attriblen, sizeof (int), ret);
1427 if (e[i].attrib)
1428 ret = iterative_hash (e[i].attrib, attriblen, ret);
1429 }
1430 return ret;
1431 }
1432
1433 int
e_eq(const void * a,const void * b)1434 e_eq (const void *a, const void *b)
1435 {
1436 const struct entry *ea = a, *eb = b;
1437 int i;
1438 if (ea[0].etype != ETYPE_STRUCT && ea[0].etype != ETYPE_UNION)
1439 abort ();
1440 if (ea[0].len != eb[0].len)
1441 return 0;
1442 for (i = 0; i <= ea[0].len; ++i)
1443 {
1444 if (ea[i].etype != eb[i].etype
1445 || ea[i].len != eb[i].len
1446 || ea[i].arr_len != eb[i].arr_len
1447 || ea[i].type != eb[i].type)
1448 return 0;
1449 if ((ea[i].attrib == NULL) ^ (eb[i].attrib == NULL))
1450 return 0;
1451 if (ea[i].attrib && strcmp (ea[i].attrib, eb[i].attrib) != 0)
1452 return 0;
1453 }
1454 return 1;
1455 }
1456
1457 static int
e_exists(const struct entry * e)1458 e_exists (const struct entry *e)
1459 {
1460 struct entry *h;
1461 hashval_t hval;
1462
1463 hval = e_hash (e);
1464 for (h = hash_table[hval % HASH_SIZE]; h; h = h->next)
1465 if (e_eq (e, h))
1466 return 1;
1467 return 0;
1468 }
1469
1470 static void
e_insert(struct entry * e)1471 e_insert (struct entry *e)
1472 {
1473 hashval_t hval;
1474
1475 hval = e_hash (e);
1476 e->next = hash_table[hval % HASH_SIZE];
1477 hash_table[hval % HASH_SIZE] = e;
1478 }
1479
1480 void
output(struct entry * e)1481 output (struct entry *e)
1482 {
1483 int i;
1484 char c;
1485 struct entry *n;
1486 const char *skip_cint = "";
1487
1488 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION)
1489 abort ();
1490
1491 if (e_exists (e))
1492 return;
1493
1494 n = (struct entry *) malloc ((e[0].len + 1) * sizeof (struct entry));
1495 memcpy (n, e, (e[0].len + 1) * sizeof (struct entry));
1496 e_insert (n);
1497
1498 if (idx == limidx)
1499 switchfiles (e[0].len);
1500
1501 for (i = 1; i <= e[0].len; ++i)
1502 if ((e[i].etype == ETYPE_TYPE || e[i].etype == ETYPE_ARRAY)
1503 && (e[i].type->type == TYPE_CINT || e[i].type->type == TYPE_CUINT))
1504 break;
1505 if (i <= e[0].len)
1506 skip_cint = "CI";
1507 if (e[0].attrib)
1508 fprintf (outfile, (generate_random () & 1)
1509 ? "TX%s(%d,%s %s,," : "TX%s(%d,%s,%s,", skip_cint,
1510 idx, e[0].etype == ETYPE_STRUCT ? "struct" : "union",
1511 e[0].attrib);
1512 else if (e[0].etype == ETYPE_STRUCT)
1513 fprintf (outfile, "T%s(%d,", skip_cint, idx);
1514 else
1515 fprintf (outfile, "U%s(%d,", skip_cint, idx);
1516 c = 'a';
1517 for (i = 1; i <= e[0].len; )
1518 i += subfield (e + i, &c);
1519 fputs (",", outfile);
1520 c = 'a';
1521 for (i = 1; i <= e[0].len; )
1522 {
1523 i += subvalues (e + i, namebuf, &c);
1524 if (e[0].etype == ETYPE_UNION)
1525 break;
1526 }
1527 fputs (")\n", outfile);
1528 if (output_one && idx == limidx)
1529 exit (0);
1530 ++idx;
1531 }
1532
1533 enum FEATURE
1534 {
1535 FEATURE_VECTOR = 1,
1536 FEATURE_COMPLEX = 2,
1537 FEATURE_ALIGNEDPACKED = 4,
1538 FEATURE_ZEROARRAY = 8,
1539 FEATURE_ZEROBITFLD = 16,
1540 ALL_FEATURES = FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY
1541 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD
1542 };
1543
1544 void
singles(enum FEATURE features)1545 singles (enum FEATURE features)
1546 {
1547 struct entry e[2];
1548 int i;
1549 memset (e, 0, sizeof (e));
1550 e[0].etype = ETYPE_STRUCT;
1551 output (e);
1552 e[0].etype = ETYPE_UNION;
1553 output (e);
1554 for (i = 0;
1555 i < ((features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1);
1556 ++i)
1557 {
1558 e[0].attrib = attributes[i];
1559 e[0].etype = ETYPE_STRUCT;
1560 output (e);
1561 e[0].etype = ETYPE_UNION;
1562 output (e);
1563 }
1564 e[0].len = 1;
1565 e[0].attrib = NULL;
1566 for (i = 0; i < NTYPES2; ++i)
1567 {
1568 e[0].etype = ETYPE_STRUCT;
1569 e[1].etype = ETYPE_TYPE;
1570 e[1].type = &base_types[i];
1571 output (e);
1572 e[0].etype = ETYPE_UNION;
1573 output (e);
1574 }
1575 if (features & FEATURE_COMPLEX)
1576 for (i = 0; i < NCTYPES2; ++i)
1577 {
1578 e[0].etype = ETYPE_STRUCT;
1579 e[1].etype = ETYPE_TYPE;
1580 e[1].type = &complex_types[i];
1581 output (e);
1582 e[0].etype = ETYPE_UNION;
1583 output (e);
1584 }
1585 if (features & FEATURE_VECTOR)
1586 for (i = 0; i < NVTYPES2; ++i)
1587 {
1588 e[0].etype = ETYPE_STRUCT;
1589 e[1].etype = ETYPE_TYPE;
1590 e[1].type = &vector_types[i];
1591 output (e);
1592 e[0].etype = ETYPE_UNION;
1593 output (e);
1594 }
1595 }
1596
1597 void
choose_type(enum FEATURE features,struct entry * e,int r,int in_array)1598 choose_type (enum FEATURE features, struct entry *e, int r, int in_array)
1599 {
1600 int i;
1601
1602 i = NTYPES2 - NTYPES1;
1603 if (features & FEATURE_COMPLEX)
1604 i += NCTYPES2;
1605 if (features & FEATURE_VECTOR)
1606 i += NVTYPES2;
1607 if ((r & 3) == 0)
1608 {
1609 if (in_array)
1610 {
1611 i += NAATYPES2;
1612 if (features & FEATURE_COMPLEX)
1613 i += NCAATYPES2;
1614 }
1615 else
1616 {
1617 i += NATYPES2;
1618 if (features & FEATURE_COMPLEX)
1619 i += NCATYPES2;
1620 }
1621 }
1622 r >>= 2;
1623 r %= i;
1624 if (r < NTYPES2 - NTYPES1)
1625 e->type = &base_types[r + NTYPES1];
1626 r -= NTYPES2 - NTYPES1;
1627 if (e->type == NULL && (features & FEATURE_COMPLEX))
1628 {
1629 if (r < NCTYPES2)
1630 e->type = &complex_types[r];
1631 r -= NCTYPES2;
1632 }
1633 if (e->type == NULL && (features & FEATURE_VECTOR))
1634 {
1635 if (r < NVTYPES2)
1636 e->type = &vector_types[r];
1637 r -= NVTYPES2;
1638 }
1639 if (e->type == NULL && !in_array)
1640 {
1641 if (r < NATYPES2)
1642 e->type = &attrib_types[r];
1643 r -= NATYPES2;
1644 }
1645 if (e->type == NULL && !in_array && (features & FEATURE_COMPLEX))
1646 {
1647 if (r < NCATYPES2)
1648 e->type = &complex_attrib_types[r];
1649 r -= NCATYPES2;
1650 }
1651 if (e->type == NULL && in_array)
1652 {
1653 if (r < NAATYPES2)
1654 e->type = &attrib_array_types[r];
1655 r -= NAATYPES2;
1656 }
1657 if (e->type == NULL && in_array && (features & FEATURE_COMPLEX))
1658 {
1659 if (r < NCAATYPES2)
1660 e->type = &complex_attrib_array_types[r];
1661 r -= NCAATYPES2;
1662 }
1663 if (e->type == NULL)
1664 abort ();
1665 }
1666
1667 /* This is from gcc.c-torture/execute/builtin-bitops-1.c. */
1668 static int
my_ffsll(unsigned long long x)1669 my_ffsll (unsigned long long x)
1670 {
1671 int i;
1672 if (x == 0)
1673 return 0;
1674 /* We've tested LLONG_MAX for 64 bits so this should be safe. */
1675 for (i = 0; i < 64; i++)
1676 if (x & (1ULL << i))
1677 break;
1678 return i + 1;
1679 }
1680
1681 void
generate_fields(enum FEATURE features,struct entry * e,struct entry * parent,int len)1682 generate_fields (enum FEATURE features, struct entry *e, struct entry *parent,
1683 int len)
1684 {
1685 int r, i, j, ret = 1, n, incr, sametype;
1686
1687 for (n = 0; n < len; n += incr)
1688 {
1689 r = generate_random ();
1690 /* 50% ETYPE_TYPE base_types NTYPES1
1691 12.5% ETYPE_TYPE other
1692 12.5% ETYPE_ARRAY
1693 12.5% ETYPE_BITFLD
1694 12.5% ETYPE_STRUCT|ETYPE_UNION|ETYPE_STRUCT_ARRAY|ETYPE_UNION_ARRAY */
1695 i = (r & 7);
1696 r >>= 3;
1697 incr = 1;
1698 switch (i)
1699 {
1700 case 0:
1701 case 1:
1702 case 2:
1703 case 3:
1704 e[n].etype = ETYPE_TYPE;
1705 e[n].type = &base_types[r % NTYPES1];
1706 break;
1707 case 4:
1708 e[n].etype = ETYPE_TYPE;
1709 choose_type (features, &e[n], r, 0);
1710 break;
1711 case 5:
1712 e[n].etype = ETYPE_ARRAY;
1713 i = r & 1;
1714 r >>= 1;
1715 if (i)
1716 e[n].type = &base_types[r % NTYPES1];
1717 else
1718 choose_type (features, &e[n], r, 1);
1719 r = generate_random ();
1720 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
1721 {
1722 e[n].arr_len = 0;
1723 if (n == len - 1 && (r & 4)
1724 && (parent->etype == ETYPE_STRUCT
1725 || parent->etype == ETYPE_STRUCT_ARRAY))
1726 {
1727 int k;
1728 for (k = 0; k < n; ++k)
1729 if (e[k].etype != ETYPE_BITFLD || e[k].len)
1730 {
1731 e[n].arr_len = 255;
1732 break;
1733 }
1734 }
1735 }
1736 else if ((r & 3) != 3)
1737 e[n].arr_len = (r >> 2) & 7;
1738 else
1739 e[n].arr_len = (r >> 2) & 31;
1740 break;
1741 case 6:
1742 sametype = 1;
1743 switch (r & 7)
1744 {
1745 case 0:
1746 case 1:
1747 case 2:
1748 break;
1749 case 3:
1750 case 4:
1751 case 5:
1752 incr = 1 + (r >> 3) % (len - n);
1753 break;
1754 case 6:
1755 case 7:
1756 sametype = 0;
1757 incr = 1 + (r >> 3) % (len - n);
1758 break;
1759 }
1760 for (j = n; j < n + incr; ++j)
1761 {
1762 int mi, ma;
1763
1764 e[j].etype = ETYPE_BITFLD;
1765 if (j == n || !sametype)
1766 {
1767 int k;
1768 r = generate_random ();
1769 k = r & 3;
1770 r >>= 2;
1771 if (!k)
1772 e[j].type
1773 = &aligned_bitfld_types[r % n_aligned_bitfld_types];
1774 else
1775 e[j].type
1776 = &bitfld_types[r % n_bitfld_types];
1777 }
1778 else
1779 e[j].type = e[n].type;
1780 r = generate_random ();
1781 mi = 0;
1782 ma = 0;
1783 switch (e[j].type->bitfld)
1784 {
1785 case 'C': ma = 8; break;
1786 case 'S': ma = 16; break;
1787 case 'I': ma = 32; break;
1788 case 'L':
1789 case 'Q': ma = 64; break;
1790 case 'B': ma = 1; break;
1791 case ' ':
1792 if (e[j].type->type == TYPE_UENUM)
1793 mi = my_ffsll (e[j].type->maxval + 1) - 1;
1794 else if (e[j].type->type == TYPE_SENUM)
1795 mi = my_ffsll (e[j].type->maxval + 1);
1796 else
1797 abort ();
1798 if (!mi)
1799 mi = 1;
1800 if (mi > 32)
1801 ma = 64;
1802 else if (mi > 16 || !short_enums)
1803 ma = 32;
1804 else if (mi > 8)
1805 ma = 16;
1806 else
1807 ma = 8;
1808 break;
1809 default:
1810 abort ();
1811 }
1812 e[j].len = ma + 1;
1813 if (sametype && (r & 3) == 0 && ma > 1)
1814 {
1815 int sum = 0, k;
1816 for (k = n; k < j; ++k)
1817 sum += e[k].len;
1818 sum %= ma;
1819 e[j].len = sum ? ma - sum : ma;
1820 }
1821 r >>= 2;
1822 if (! (features & FEATURE_ZEROBITFLD) && mi == 0)
1823 mi = 1;
1824 if (e[j].len < mi || e[j].len > ma)
1825 e[j].len = mi + (r % (ma + 1 - mi));
1826 r >>= 6;
1827 if ((features & FEATURE_ZEROBITFLD) && (r & 3) == 0
1828 && mi == 0)
1829 e[j].len = 0;
1830 }
1831 break;
1832 case 7:
1833 switch (r & 7)
1834 {
1835 case 0:
1836 case 1:
1837 case 2:
1838 e[n].etype = ETYPE_STRUCT;
1839 break;
1840 case 3:
1841 case 4:
1842 e[n].etype = ETYPE_UNION;
1843 break;
1844 case 5:
1845 case 6:
1846 e[n].etype = ETYPE_STRUCT_ARRAY;
1847 break;
1848 case 7:
1849 e[n].etype = ETYPE_UNION_ARRAY;
1850 break;
1851 }
1852 r >>= 3;
1853 e[n].len = r % (len - n);
1854 incr = 1 + e[n].len;
1855 generate_fields (features, &e[n + 1], &e[n], e[n].len);
1856 if (e[n].etype == ETYPE_STRUCT_ARRAY
1857 || e[n].etype == ETYPE_UNION_ARRAY)
1858 {
1859 r = generate_random ();
1860 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0)
1861 {
1862 e[n].arr_len = 0;
1863 if (n + incr == len && (r & 4)
1864 && (parent->etype == ETYPE_STRUCT
1865 || parent->etype == ETYPE_STRUCT_ARRAY))
1866 {
1867 int k;
1868 for (k = 0; k < n; ++k)
1869 if (e[k].etype != ETYPE_BITFLD || e[k].len)
1870 {
1871 e[n].arr_len = 255;
1872 break;
1873 }
1874 }
1875 }
1876 else if ((r & 3) != 3)
1877 e[n].arr_len = (r >> 2) & 7;
1878 else
1879 e[n].arr_len = (r >> 2) & 31;
1880 }
1881 break;
1882 }
1883 r = generate_random ();
1884 if ((r & 7) == 0)
1885 {
1886 r >>= 3;
1887 i = (features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1;
1888 e[n].attrib = attributes[r % i];
1889 if (! (features & FEATURE_ALIGNEDPACKED)
1890 && strcmp (e[n].attrib, "atpa") == 0
1891 && ((e[n].type >= &attrib_types[0]
1892 && e[n].type < &attrib_types[NATYPES2])
1893 || (e[n].type >= &complex_attrib_types[0]
1894 && e[n].type < &complex_attrib_types[NCATYPES2])
1895 || (e[n].type >= &attrib_array_types[0]
1896 && e[n].type < &attrib_array_types[NAATYPES2])
1897 || (e[n].type >= &complex_attrib_array_types[0]
1898 && e[n].type < &complex_attrib_array_types[NCAATYPES2])
1899 || (e[n].type >= &aligned_bitfld_types[0]
1900 && e[n].type < &aligned_bitfld_types[n_aligned_bitfld_types])))
1901 e[n].attrib = NULL;
1902 }
1903 }
1904 }
1905
1906 void
generate_random_tests(enum FEATURE features,int len)1907 generate_random_tests (enum FEATURE features, int len)
1908 {
1909 struct entry e[len + 1];
1910 int i, r;
1911 if (len > 'z' - 'a' + 1)
1912 abort ();
1913 memset (e, 0, sizeof (e));
1914 r = generate_random ();
1915 if ((r & 7) == 0)
1916 e[0].etype = ETYPE_UNION;
1917 else
1918 e[0].etype = ETYPE_STRUCT;
1919 r >>= 3;
1920 e[0].len = len;
1921 if ((r & 31) == 0)
1922 {
1923 r >>= 5;
1924 if (features & FEATURE_ALIGNEDPACKED)
1925 r %= NATTRIBS2;
1926 else
1927 r %= NATTRIBS1;
1928 e[0].attrib = attributes[r];
1929 }
1930 generate_fields (features, &e[1], &e[0], len);
1931 output (e);
1932 }
1933
1934 struct { const char *name; enum FEATURE f; }
1935 features[] = {
1936 { "normal", 0 },
1937 { "complex", FEATURE_COMPLEX },
1938 { "vector", FEATURE_VECTOR },
1939 { "[0] :0", FEATURE_ZEROARRAY | FEATURE_ZEROBITFLD },
1940 { "complex vector [0]",
1941 FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY },
1942 { "aligned packed complex vector [0] :0",
1943 FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY
1944 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD },
1945 };
1946
1947 int
main(int argc,char ** argv)1948 main (int argc, char **argv)
1949 {
1950 int i, j, count, c, n = 3000;
1951 char *optarg;
1952
1953 if (sizeof (int) != 4 || sizeof (long long) != 8)
1954 return 1;
1955
1956 i = 1;
1957 while (i < argc)
1958 {
1959 c = '\0';
1960 if (argv[i][0] == '-' && argv[i][2] == '\0')
1961 c = argv[i][1];
1962 optarg = argv[i + 1];
1963 if (!optarg)
1964 goto usage;
1965 switch (c)
1966 {
1967 case 'n':
1968 n = atoi (optarg);
1969 break;
1970 case 'd':
1971 destdir = optarg;
1972 break;
1973 case 's':
1974 srcdir = optarg;
1975 break;
1976 case 'i':
1977 output_one = 1;
1978 limidx = atoi (optarg);
1979 break;
1980 case 'e':
1981 short_enums = 1;
1982 i--;
1983 break;
1984 default:
1985 fprintf (stderr, "unrecognized option %s\n", argv[i]);
1986 goto usage;
1987 }
1988 i += 2;
1989 }
1990
1991 if (output_one)
1992 {
1993 outfile = fopen ("/dev/null", "w");
1994 if (outfile == NULL)
1995 {
1996 fputs ("could not open /dev/null", stderr);
1997 return 1;
1998 }
1999 n = limidx + 1;
2000 }
2001
2002 if (destdir == NULL && !output_one)
2003 {
2004 usage:
2005 fprintf (stderr, "Usage:\n\
2006 %s [-e] [-s srcdir -d destdir] [-n count] [-i idx]\n\
2007 Either -s srcdir -d destdir or -i idx must be used\n", argv[0]);
2008 return 1;
2009 }
2010
2011 if (srcdir == NULL && !output_one)
2012 goto usage;
2013
2014 if (srcdir != NULL)
2015 {
2016 const char *s = srcdir;
2017 char *ss, *t;
2018 t = ss = malloc (strlen (srcdir) + 1);
2019 if (!ss)
2020 abort ();
2021 do {
2022 if (*s == '\\')
2023 *t++ = '/';
2024 else
2025 *t++ = *s;
2026 } while (*s++);
2027 srcdir_safe = ss;
2028 }
2029
2030 for (i = 0; i < NTYPES2; ++i)
2031 if (base_types[i].bitfld)
2032 bitfld_types[n_bitfld_types++] = base_types[i];
2033 for (i = 0; i < NATYPES2; ++i)
2034 if (attrib_types[i].bitfld)
2035 aligned_bitfld_types[n_aligned_bitfld_types++] = attrib_types[i];
2036 for (i = 0; i < sizeof (features) / sizeof (features[0]); ++i)
2037 {
2038 int startidx = idx;
2039 if (! output_one)
2040 limidx = idx;
2041 if (!i)
2042 count = 200;
2043 else
2044 count = 20;
2045 for (j = 1; j <= 9; ++j)
2046 while (idx < startidx + j * count)
2047 generate_random_tests (features[i].f, j);
2048 while (idx < startidx + count * 10)
2049 generate_random_tests (features[i].f, 10 + (generate_random () % 16));
2050 }
2051 for (i = 0; n > 3000 && i < sizeof (features) / sizeof (features[0]); ++i)
2052 {
2053 int startidx;
2054 startidx = idx;
2055 if (! output_one)
2056 limidx = idx;
2057 singles (features[i].f);
2058 if (!i)
2059 {
2060 count = 1000;
2061 while (idx < startidx + 1000)
2062 generate_random_tests (features[i].f, 1);
2063 }
2064 else
2065 {
2066 startidx = idx;
2067 count = 100;
2068 while (idx < startidx + 100)
2069 generate_random_tests (features[i].f, 1);
2070 }
2071 startidx = idx;
2072 for (j = 2; j <= 9; ++j)
2073 while (idx < startidx + (j - 1) * count)
2074 generate_random_tests (features[i].f, j);
2075 while (idx < startidx + count * 9)
2076 generate_random_tests (features[i].f, 10 + (generate_random () % 16));
2077 }
2078 if (! output_one)
2079 limidx = idx;
2080 while (idx < n)
2081 generate_random_tests (ALL_FEATURES, 1 + (generate_random () % 25));
2082 fclose (outfile);
2083 return 0;
2084 }
2085