?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with main truk.
[official-gcc.git] / gcc / testsuite / g++.dg / compat / struct-layout-1_generate.c
blob2cf08946e36ae5c7cb5e17b7b19128e2cc0dd0c7
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 "../../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 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 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org