OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [compat/] [struct-layout-1_generate.c] - Blame information for rev 783

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.