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>.
6 This file is part of GCC.
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
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
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/>. */
23 /* Compile with gcc -o struct-layout-1_generate{,.c} generate_random{,_r}.c */
25 /* N.B. -- This program cannot use libiberty as that will not work
26 when testing an installed compiler. */
32 /* We use our own pseudo-random number generator, so that it gives the same
33 values on all hosts. */
34 #include "generate-random.h"
36 #if LLONG_MAX != 9223372036854775807LL && __LONG_LONG_MAX__ != 9223372036854775807LL
37 # error Need 64-bit long long
40 #if defined __MSVCRT__
41 #define COMPAT_PRLL "I64"
43 #define COMPAT_PRLL "ll"
46 const char *dg_options
[] = {
47 "/* { dg-options \"%s-I%s\" } */\n",
48 "/* { dg-options \"%s-I%s -Wno-abi\" } */\n",
49 "/* { dg-options \"%s-I%s -mno-mmx -Wno-abi\" { target i?86-*-* x86_64-*-* } } */\n",
50 "/* { dg-options \"%s-I%s -fno-common\" { target hppa*-*-hpux* powerpc*-*-darwin* } } */\n",
51 "/* { dg-options \"%s-I%s -mno-mmx -fno-common -Wno-abi\" { target i?86-*-darwin* x86_64-*-darwin* } } */\n",
52 "/* { dg-options \"%s-I%s -mno-base-addresses\" { target mmix-*-* } } */\n",
53 "/* { dg-options \"%s-I%s -mlongcalls -mtext-section-literals\" { target xtensa*-*-* } } */\n"
54 #define NDG_OPTIONS (sizeof (dg_options) / sizeof (dg_options[0]))
57 typedef unsigned int hashval_t
;
79 unsigned long long int maxval
;
83 struct types base_types
[] = {
84 /* As we don't know whether char will be signed or not, just limit ourselves
85 to unsigned values less than maximum signed char value. */
86 { "char", TYPE_UINT
, 127, 'C' },
87 { "signed char", TYPE_INT
, 127, 'C' },
88 { "unsigned char", TYPE_UINT
, 255, 'C' },
89 { "short int", TYPE_INT
, 32767, 'S' },
90 { "unsigned short int", TYPE_UINT
, 65535, 'S' },
91 { "int", TYPE_INT
, 2147483647, 'I' },
92 { "unsigned int", TYPE_UINT
, 4294967295U, 'I' },
93 { "long int", TYPE_INT
, 9223372036854775807LL, 'L' },
94 { "unsigned long int", TYPE_UINT
, 18446744073709551615ULL, 'L' },
95 { "long long int", TYPE_INT
, 9223372036854775807LL, 'Q' },
96 { "unsigned long long int", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
97 { "bool", TYPE_UINT
, 1, 'B' },
98 { "void *", TYPE_PTR
, 0, 0 },
99 { "char *", TYPE_PTR
, 0, 0 },
100 { "int *", TYPE_PTR
, 0, 0 },
101 { "float", TYPE_FLOAT
, 0, 0 },
102 { "double", TYPE_FLOAT
, 0, 0 },
103 { "long double", TYPE_FLOAT
, 0, 0 },
104 #ifndef SKIP_DECIMAL_FLOAT
105 { "_Decimal32", TYPE_DEC_FLOAT
, 0, 0 },
106 { "_Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
107 { "_Decimal128", TYPE_DEC_FLOAT
, 0, 0 },
112 { "Tchar", TYPE_UINT
, 127, 'C' },
113 { "Tschar", TYPE_INT
, 127, 'C' },
114 { "Tuchar", TYPE_UINT
, 255, 'C' },
115 { "Tshort", TYPE_INT
, 32767, 'S' },
116 { "Tushort", TYPE_UINT
, 65535, 'S' },
117 { "Tint", TYPE_INT
, 2147483647, 'I' },
118 { "Tuint", TYPE_UINT
, 4294967295U, 'I' },
119 { "Tlong", TYPE_INT
, 9223372036854775807LL, 'L' },
120 { "Tulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
121 { "Tllong", TYPE_INT
, 9223372036854775807LL, 'Q' },
122 { "Tullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
123 { "Tbool", TYPE_UINT
, 1, 'B' },
124 { "size_t", TYPE_UINT
, 18446744073709551615ULL, 0 },
125 { "Tptr", TYPE_PTR
, 0, 0 },
126 { "Tcptr", TYPE_PTR
, 0, 0 },
127 { "Tiptr", TYPE_PTR
, 0, 0 },
128 { "Tfnptr", TYPE_FNPTR
, 0, 0 },
129 { "Tfloat", TYPE_FLOAT
, 0, 0 },
130 { "Tdouble", TYPE_FLOAT
, 0, 0 },
131 { "Tldouble", TYPE_FLOAT
, 0, 0 },
132 #ifndef SKIP_DECIMAL_FLOAT
133 { "TDecimal32", TYPE_DEC_FLOAT
, 0, 0 },
134 { "TDecimal64", TYPE_DEC_FLOAT
, 0, 0 },
135 { "TDecimal128", TYPE_DEC_FLOAT
, 0, 0 },
137 { "enum E0", TYPE_UENUM
, 0, ' ' },
138 { "enum E1", TYPE_UENUM
, 1, ' ' },
139 { "enum E2", TYPE_SENUM
, 3, ' ' },
140 { "enum E3", TYPE_SENUM
, 127, ' ' },
141 { "enum E4", TYPE_UENUM
, 255, ' ' },
142 { "enum E5", TYPE_SENUM
, 32767, ' ' },
143 { "enum E6", TYPE_UENUM
, 65535, ' ' },
144 { "enum E7", TYPE_SENUM
, 2147483647, ' ' },
145 { "enum E8", TYPE_UENUM
, 4294967295U, ' ' },
146 { "enum E9", TYPE_SENUM
, 1099511627775LL, ' ' },
147 { "TE0", TYPE_UENUM
, 0, ' ' },
148 { "TE1", TYPE_UENUM
, 1, ' ' },
149 { "TE2", TYPE_SENUM
, 3, ' ' },
150 { "TE3", TYPE_SENUM
, 127, ' ' },
151 { "TE4", TYPE_UENUM
, 255, ' ' },
152 { "TE5", TYPE_SENUM
, 32767, ' ' },
153 { "TE6", TYPE_UENUM
, 65535, ' ' },
154 { "TE7", TYPE_SENUM
, 2147483647, ' ' },
155 { "TE8", TYPE_UENUM
, 4294967295U, ' ' },
156 { "TE9", TYPE_SENUM
, 1099511627775LL, ' ' },
157 /* vector-defs.h typedefs */
158 { "qi", TYPE_INT
, 127, 0 },
159 { "hi", TYPE_INT
, 32767, 0 },
160 { "si", TYPE_INT
, 2147483647, 0 },
161 { "di", TYPE_INT
, 9223372036854775807LL, 0 },
162 { "sf", TYPE_FLOAT
, 0, 0 },
163 { "df", TYPE_FLOAT
, 0, 0 }
164 #define NTYPES2 (sizeof (base_types) / sizeof (base_types[0]))
166 struct types complex_types
[] = {
167 { "_Complex char", TYPE_CUINT
, 127, 0 },
168 { "_Complex signed char", TYPE_CINT
, 127, 0 },
169 { "_Complex unsigned char", TYPE_CUINT
, 255, 0 },
170 { "_Complex short int", TYPE_CINT
, 32767, 0 },
171 { "_Complex unsigned short int", TYPE_CUINT
, 65535, 0 },
172 { "_Complex int", TYPE_CINT
, 2147483647, 0 },
173 { "_Complex unsigned int", TYPE_CUINT
, 4294967295U, 0 },
174 { "_Complex long int", TYPE_CINT
, 9223372036854775807LL, 0 },
175 { "_Complex unsigned long int", TYPE_CUINT
, 18446744073709551615ULL, 0 },
176 { "_Complex long long int", TYPE_CINT
, 9223372036854775807LL, 0 },
177 { "_Complex unsigned long long int", TYPE_CUINT
, 18446744073709551615ULL, 0 },
178 { "_Complex float", TYPE_CFLOAT
, 0, 0 },
179 { "_Complex double", TYPE_CFLOAT
, 0, 0 },
180 { "_Complex long double", TYPE_CFLOAT
, 0, 0 },
181 { "Tcchar", TYPE_CUINT
, 127, 0 },
182 { "Tcschar", TYPE_CINT
, 127, 0 },
183 { "Tcuchar", TYPE_CUINT
, 255, 0 },
184 { "Tcshort", TYPE_CINT
, 32767, 0 },
185 { "Tcushort", TYPE_CUINT
, 65535, 0 },
186 { "Tcint", TYPE_CINT
, 2147483647, 0 },
187 { "Tcuint", TYPE_CUINT
, 4294967295U, 0 },
188 { "Tclong", TYPE_CINT
, 9223372036854775807LL, 0 },
189 { "Tculong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
190 { "Tcllong", TYPE_CINT
, 9223372036854775807LL, 0 },
191 { "Tcullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
192 { "Tcfloat", TYPE_CFLOAT
, 0, 0 },
193 { "Tcdouble", TYPE_CFLOAT
, 0, 0 },
194 { "Tcldouble", TYPE_CFLOAT
, 0, 0 }
195 #define NCTYPES2 (sizeof (complex_types) / sizeof (complex_types[0]))
197 struct types vector_types
[] = {
198 /* vector-defs.h typedefs */
199 { "v8qi", TYPE_OTHER
, 0, 0 },
200 { "v16qi", TYPE_OTHER
, 0, 0 },
201 { "v32qi", TYPE_OTHER
, 0, 0 },
202 { "v2hi", TYPE_OTHER
, 0, 0 },
203 { "v4hi", TYPE_OTHER
, 0, 0 },
204 { "v8hi", TYPE_OTHER
, 0, 0 },
205 { "v16hi", TYPE_OTHER
, 0, 0 },
206 { "v2si", TYPE_OTHER
, 0, 0 },
207 { "v4si", TYPE_OTHER
, 0, 0 },
208 { "v8si", TYPE_OTHER
, 0, 0 },
209 { "v1di", TYPE_OTHER
, 0, 0 },
210 { "v2di", TYPE_OTHER
, 0, 0 },
211 { "v4di", TYPE_OTHER
, 0, 0 },
212 { "v2sf", TYPE_OTHER
, 0, 0 },
213 { "v4sf", TYPE_OTHER
, 0, 0 },
214 { "v8sf", TYPE_OTHER
, 0, 0 },
215 { "v16sf", TYPE_OTHER
, 0, 0 },
216 { "v2df", TYPE_OTHER
, 0, 0 },
217 { "v4df", TYPE_OTHER
, 0, 0 },
218 { "u8qi", TYPE_OTHER
, 0, 0 },
219 { "u16qi", TYPE_OTHER
, 0, 0 },
220 { "u32qi", TYPE_OTHER
, 0, 0 },
221 { "u2hi", TYPE_OTHER
, 0, 0 },
222 { "u4hi", TYPE_OTHER
, 0, 0 },
223 { "u8hi", TYPE_OTHER
, 0, 0 },
224 { "u16hi", TYPE_OTHER
, 0, 0 },
225 { "u2si", TYPE_OTHER
, 0, 0 },
226 { "u4si", TYPE_OTHER
, 0, 0 },
227 { "u8si", TYPE_OTHER
, 0, 0 },
228 { "u1di", TYPE_OTHER
, 0, 0 },
229 { "u2di", TYPE_OTHER
, 0, 0 },
230 { "u4di", TYPE_OTHER
, 0, 0 },
231 { "u2sf", TYPE_OTHER
, 0, 0 },
232 { "u4sf", TYPE_OTHER
, 0, 0 },
233 { "u8sf", TYPE_OTHER
, 0, 0 },
234 { "u16sf", TYPE_OTHER
, 0, 0 },
235 { "u2df", TYPE_OTHER
, 0, 0 },
236 { "u4df", TYPE_OTHER
, 0, 0 },
237 { "__m64", TYPE_OTHER
, 0, 0 },
238 { "__m128", TYPE_OTHER
, 0, 0 }
239 #define NVTYPES2 (sizeof (vector_types) / sizeof (vector_types[0]))
241 struct types attrib_types
[] = {
242 { "Talchar", TYPE_UINT
, 127, 'C' },
243 { "Talschar", TYPE_INT
, 127, 'C' },
244 { "Taluchar", TYPE_UINT
, 255, 'C' },
245 { "Talshort", TYPE_INT
, 32767, 'S' },
246 { "Talushort", TYPE_UINT
, 65535, 'S' },
247 { "Talint", TYPE_INT
, 2147483647, 'I' },
248 { "Taluint", TYPE_UINT
, 4294967295U, 'I' },
249 { "Tallong", TYPE_INT
, 9223372036854775807LL, 'L' },
250 { "Talulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
251 { "Talllong", TYPE_INT
, 9223372036854775807LL, 'Q' },
252 { "Talullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
253 { "Talbool", TYPE_UINT
, 1, 'B' },
254 { "Talptr", TYPE_PTR
, 0, 0 },
255 { "Talcptr", TYPE_PTR
, 0, 0 },
256 { "Taliptr", TYPE_PTR
, 0, 0 },
257 { "Talfloat", TYPE_FLOAT
, 0, 0 },
258 { "Taldouble", TYPE_FLOAT
, 0, 0 },
259 { "Talldouble", TYPE_FLOAT
, 0, 0 },
260 #ifndef SKIP_DECIMAL_FLOAT
261 { "TalDecimal32", TYPE_DEC_FLOAT
, 0, 0 },
262 { "TalDecimal64", TYPE_DEC_FLOAT
, 0, 0 },
263 { "TalDecimal128", TYPE_DEC_FLOAT
, 0, 0 },
265 { "TalE0", TYPE_UENUM
, 0, ' ' },
266 { "TalE1", TYPE_UENUM
, 1, ' ' },
267 { "TalE2", TYPE_SENUM
, 3, ' ' },
268 { "TalE3", TYPE_SENUM
, 127, ' ' },
269 { "TalE4", TYPE_UENUM
, 255, ' ' },
270 { "TalE5", TYPE_SENUM
, 32767, ' ' },
271 { "TalE6", TYPE_UENUM
, 65535, ' ' },
272 { "TalE7", TYPE_SENUM
, 2147483647, ' ' },
273 { "TalE8", TYPE_UENUM
, 4294967295U, ' ' },
274 { "TalE9", TYPE_SENUM
, 1099511627775LL, ' ' },
275 { "Tal1char", TYPE_UINT
, 127, 'C' },
276 { "Tal1schar", TYPE_INT
, 127, 'C' },
277 { "Tal1uchar", TYPE_UINT
, 255, 'C' },
278 { "Tal1short", TYPE_INT
, 32767, 'S' },
279 { "Tal1ushort", TYPE_UINT
, 65535, 'S' },
280 { "Tal1int", TYPE_INT
, 2147483647, 'I' },
281 { "Tal1uint", TYPE_UINT
, 4294967295U, 'I' },
282 { "Tal1long", TYPE_INT
, 9223372036854775807LL, 'L' },
283 { "Tal1ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
284 { "Tal1llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
285 { "Tal1ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
286 { "Tal1bool", TYPE_UINT
, 1, 'B' },
287 { "Tal1ptr", TYPE_PTR
, 0, 0 },
288 { "Tal1cptr", TYPE_PTR
, 0, 0 },
289 { "Tal1iptr", TYPE_PTR
, 0, 0 },
290 { "Tal1float", TYPE_FLOAT
, 0, 0 },
291 { "Tal1double", TYPE_FLOAT
, 0, 0 },
292 { "Tal1ldouble", TYPE_FLOAT
, 0, 0 },
293 #ifndef SKIP_DECIMAL_FLOAT
294 { "Tal1Decimal32", TYPE_DEC_FLOAT
, 0, 0},
295 { "Tal1Decimal64", TYPE_DEC_FLOAT
, 0, 0},
296 { "Tal1Decimal128", TYPE_DEC_FLOAT
, 0, 0},
298 { "Tal1E0", TYPE_UENUM
, 0, ' ' },
299 { "Tal1E1", TYPE_UENUM
, 1, ' ' },
300 { "Tal1E2", TYPE_SENUM
, 3, ' ' },
301 { "Tal1E3", TYPE_SENUM
, 127, ' ' },
302 { "Tal1E4", TYPE_UENUM
, 255, ' ' },
303 { "Tal1E5", TYPE_SENUM
, 32767, ' ' },
304 { "Tal1E6", TYPE_UENUM
, 65535, ' ' },
305 { "Tal1E7", TYPE_SENUM
, 2147483647, ' ' },
306 { "Tal1E8", TYPE_UENUM
, 4294967295U, ' ' },
307 { "Tal1E9", TYPE_SENUM
, 1099511627775LL, ' ' },
308 { "Tal2char", TYPE_UINT
, 127, 'C' },
309 { "Tal2schar", TYPE_INT
, 127, 'C' },
310 { "Tal2uchar", TYPE_UINT
, 255, 'C' },
311 { "Tal2short", TYPE_INT
, 32767, 'S' },
312 { "Tal2ushort", TYPE_UINT
, 65535, 'S' },
313 { "Tal2int", TYPE_INT
, 2147483647, 'I' },
314 { "Tal2uint", TYPE_UINT
, 4294967295U, 'I' },
315 { "Tal2long", TYPE_INT
, 9223372036854775807LL, 'L' },
316 { "Tal2ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
317 { "Tal2llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
318 { "Tal2ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
319 { "Tal2bool", TYPE_UINT
, 1, 'B' },
320 { "Tal2ptr", TYPE_PTR
, 0, 0 },
321 { "Tal2cptr", TYPE_PTR
, 0, 0 },
322 { "Tal2iptr", TYPE_PTR
, 0, 0 },
323 { "Tal2float", TYPE_FLOAT
, 0, 0 },
324 { "Tal2double", TYPE_FLOAT
, 0, 0 },
325 { "Tal2ldouble", TYPE_FLOAT
, 0, 0 },
326 #ifndef SKIP_DECIMAL_FLOAT
327 { "Tal2Decimal32", TYPE_DEC_FLOAT
, 0, 0 },
328 { "Tal2Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
329 { "Tal2Decimal128", TYPE_DEC_FLOAT
, 0, 0 },
331 { "Tal2E0", TYPE_UENUM
, 0, ' ' },
332 { "Tal2E1", TYPE_UENUM
, 1, ' ' },
333 { "Tal2E2", TYPE_SENUM
, 3, ' ' },
334 { "Tal2E3", TYPE_SENUM
, 127, ' ' },
335 { "Tal2E4", TYPE_UENUM
, 255, ' ' },
336 { "Tal2E5", TYPE_SENUM
, 32767, ' ' },
337 { "Tal2E6", TYPE_UENUM
, 65535, ' ' },
338 { "Tal2E7", TYPE_SENUM
, 2147483647, ' ' },
339 { "Tal2E8", TYPE_UENUM
, 4294967295U, ' ' },
340 { "Tal2E9", TYPE_SENUM
, 1099511627775LL, ' ' },
341 { "Tal4char", TYPE_UINT
, 127, 'C' },
342 { "Tal4schar", TYPE_INT
, 127, 'C' },
343 { "Tal4uchar", TYPE_UINT
, 255, 'C' },
344 { "Tal4short", TYPE_INT
, 32767, 'S' },
345 { "Tal4ushort", TYPE_UINT
, 65535, 'S' },
346 { "Tal4int", TYPE_INT
, 2147483647, 'I' },
347 { "Tal4uint", TYPE_UINT
, 4294967295U, 'I' },
348 { "Tal4long", TYPE_INT
, 9223372036854775807LL, 'L' },
349 { "Tal4ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
350 { "Tal4llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
351 { "Tal4ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
352 { "Tal4bool", TYPE_UINT
, 1, 'B' },
353 { "Tal4ptr", TYPE_PTR
, 0, 0 },
354 { "Tal4cptr", TYPE_PTR
, 0, 0 },
355 { "Tal4iptr", TYPE_PTR
, 0, 0 },
356 { "Tal4float", TYPE_FLOAT
, 0, 0 },
357 { "Tal4double", TYPE_FLOAT
, 0, 0 },
358 { "Tal4ldouble", TYPE_FLOAT
, 0, 0 },
359 #ifndef SKIP_DECIMAL_FLOAT
360 { "Tal4Decimal32", TYPE_DEC_FLOAT
, 0, 0 },
361 { "Tal4Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
362 { "Tal4Decimal128", TYPE_DEC_FLOAT
, 0, 0 },
364 { "Tal4E0", TYPE_UENUM
, 0, ' ' },
365 { "Tal4E1", TYPE_UENUM
, 1, ' ' },
366 { "Tal4E2", TYPE_SENUM
, 3, ' ' },
367 { "Tal4E3", TYPE_SENUM
, 127, ' ' },
368 { "Tal4E4", TYPE_UENUM
, 255, ' ' },
369 { "Tal4E5", TYPE_SENUM
, 32767, ' ' },
370 { "Tal4E6", TYPE_UENUM
, 65535, ' ' },
371 { "Tal4E7", TYPE_SENUM
, 2147483647, ' ' },
372 { "Tal4E8", TYPE_UENUM
, 4294967295U, ' ' },
373 { "Tal4E9", TYPE_SENUM
, 1099511627775LL, ' ' },
374 { "Tal8char", TYPE_UINT
, 127, 'C' },
375 { "Tal8schar", TYPE_INT
, 127, 'C' },
376 { "Tal8uchar", TYPE_UINT
, 255, 'C' },
377 { "Tal8short", TYPE_INT
, 32767, 'S' },
378 { "Tal8ushort", TYPE_UINT
, 65535, 'S' },
379 { "Tal8int", TYPE_INT
, 2147483647, 'I' },
380 { "Tal8uint", TYPE_UINT
, 4294967295U, 'I' },
381 { "Tal8long", TYPE_INT
, 9223372036854775807LL, 'L' },
382 { "Tal8ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
383 { "Tal8llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
384 { "Tal8ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
385 { "Tal8bool", TYPE_UINT
, 1, 'B' },
386 { "Tal8ptr", TYPE_PTR
, 0, 0 },
387 { "Tal8cptr", TYPE_PTR
, 0, 0 },
388 { "Tal8iptr", TYPE_PTR
, 0, 0 },
389 { "Tal8float", TYPE_FLOAT
, 0, 0 },
390 { "Tal8double", TYPE_FLOAT
, 0, 0 },
391 { "Tal8ldouble", TYPE_FLOAT
, 0, 0 },
392 #ifndef SKIP_DECIMAL_FLOAT
393 { "Tal8Decimal32", TYPE_DEC_FLOAT
, 0, 0 },
394 { "Tal8Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
395 { "Tal8Decimal128", TYPE_DEC_FLOAT
, 0, 0 },
397 { "Tal8E0", TYPE_UENUM
, 0, ' ' },
398 { "Tal8E1", TYPE_UENUM
, 1, ' ' },
399 { "Tal8E2", TYPE_SENUM
, 3, ' ' },
400 { "Tal8E3", TYPE_SENUM
, 127, ' ' },
401 { "Tal8E4", TYPE_UENUM
, 255, ' ' },
402 { "Tal8E5", TYPE_SENUM
, 32767, ' ' },
403 { "Tal8E6", TYPE_UENUM
, 65535, ' ' },
404 { "Tal8E7", TYPE_SENUM
, 2147483647, ' ' },
405 { "Tal8E8", TYPE_UENUM
, 4294967295U, ' ' },
406 { "Tal8E9", TYPE_SENUM
, 1099511627775LL, ' ' },
407 { "Tal16char", TYPE_UINT
, 127, 'C' },
408 { "Tal16schar", TYPE_INT
, 127, 'C' },
409 { "Tal16uchar", TYPE_UINT
, 255, 'C' },
410 { "Tal16short", TYPE_INT
, 32767, 'S' },
411 { "Tal16ushort", TYPE_UINT
, 65535, 'S' },
412 { "Tal16int", TYPE_INT
, 2147483647, 'I' },
413 { "Tal16uint", TYPE_UINT
, 4294967295U, 'I' },
414 { "Tal16long", TYPE_INT
, 9223372036854775807LL, 'L' },
415 { "Tal16ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
416 { "Tal16llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
417 { "Tal16ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
418 { "Tal16bool", TYPE_UINT
, 1, 'B' },
419 { "Tal16ptr", TYPE_PTR
, 0, 0 },
420 { "Tal16cptr", TYPE_PTR
, 0, 0 },
421 { "Tal16iptr", TYPE_PTR
, 0, 0 },
422 { "Tal16float", TYPE_FLOAT
, 0, 0 },
423 { "Tal16double", TYPE_FLOAT
, 0, 0 },
424 { "Tal16ldouble", TYPE_FLOAT
, 0, 0 },
425 #ifndef SKIP_DECIMAL_FLOAT
426 { "Tal16Decimal32", TYPE_DEC_FLOAT
, 0, 0 },
427 { "Tal16Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
428 { "Tal16Decimal128", TYPE_DEC_FLOAT
, 0, 0 },
430 { "Tal16E0", TYPE_UENUM
, 0, ' ' },
431 { "Tal16E1", TYPE_UENUM
, 1, ' ' },
432 { "Tal16E2", TYPE_SENUM
, 3, ' ' },
433 { "Tal16E3", TYPE_SENUM
, 127, ' ' },
434 { "Tal16E4", TYPE_UENUM
, 255, ' ' },
435 { "Tal16E5", TYPE_SENUM
, 32767, ' ' },
436 { "Tal16E6", TYPE_UENUM
, 65535, ' ' },
437 { "Tal16E7", TYPE_SENUM
, 2147483647, ' ' },
438 { "Tal16E8", TYPE_UENUM
, 4294967295U, ' ' },
439 { "Tal16E9", TYPE_SENUM
, 1099511627775LL, ' ' }
440 #define NATYPES2 (sizeof (attrib_types) / sizeof (attrib_types[0]))
442 struct types complex_attrib_types
[] = {
443 { "Talcchar", TYPE_CUINT
, 127, 0 },
444 { "Talcschar", TYPE_CINT
, 127, 0 },
445 { "Talcuchar", TYPE_CUINT
, 255, 0 },
446 { "Talcshort", TYPE_CINT
, 32767, 0 },
447 { "Talcushort", TYPE_CUINT
, 65535, 0 },
448 { "Talcint", TYPE_CINT
, 2147483647, 0 },
449 { "Talcuint", TYPE_CUINT
, 4294967295U, 0 },
450 { "Talclong", TYPE_CINT
, 9223372036854775807LL, 0 },
451 { "Talculong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
452 { "Talcllong", TYPE_CINT
, 9223372036854775807LL, 0 },
453 { "Talcullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
454 { "Talcfloat", TYPE_CFLOAT
, 0, 0 },
455 { "Talcdouble", TYPE_CFLOAT
, 0, 0 },
456 { "Talcldouble", TYPE_CFLOAT
, 0, 0 },
457 { "Tal1cchar", TYPE_CUINT
, 127, 0 },
458 { "Tal1cschar", TYPE_CINT
, 127, 0 },
459 { "Tal1cuchar", TYPE_CUINT
, 255, 0 },
460 { "Tal1cshort", TYPE_CINT
, 32767, 0 },
461 { "Tal1cushort", TYPE_CUINT
, 65535, 0 },
462 { "Tal1cint", TYPE_CINT
, 2147483647, 0 },
463 { "Tal1cuint", TYPE_CUINT
, 4294967295U, 0 },
464 { "Tal1clong", TYPE_CINT
, 9223372036854775807LL, 0 },
465 { "Tal1culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
466 { "Tal1cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
467 { "Tal1cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
468 { "Tal1cfloat", TYPE_CFLOAT
, 0, 0 },
469 { "Tal1cdouble", TYPE_CFLOAT
, 0, 0 },
470 { "Tal1cldouble", TYPE_CFLOAT
, 0, 0 },
471 { "Tal2cchar", TYPE_CUINT
, 127, 0 },
472 { "Tal2cschar", TYPE_CINT
, 127, 0 },
473 { "Tal2cuchar", TYPE_CUINT
, 255, 0 },
474 { "Tal2cshort", TYPE_CINT
, 32767, 0 },
475 { "Tal2cushort", TYPE_CUINT
, 65535, 0 },
476 { "Tal2cint", TYPE_CINT
, 2147483647, 0 },
477 { "Tal2cuint", TYPE_CUINT
, 4294967295U, 0 },
478 { "Tal2clong", TYPE_CINT
, 9223372036854775807LL, 0 },
479 { "Tal2culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
480 { "Tal2cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
481 { "Tal2cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
482 { "Tal2cfloat", TYPE_CFLOAT
, 0, 0 },
483 { "Tal2cdouble", TYPE_CFLOAT
, 0, 0 },
484 { "Tal2cldouble", TYPE_CFLOAT
, 0, 0 },
485 { "Tal4cchar", TYPE_CUINT
, 127, 0 },
486 { "Tal4cschar", TYPE_CINT
, 127, 0 },
487 { "Tal4cuchar", TYPE_CUINT
, 255, 0 },
488 { "Tal4cshort", TYPE_CINT
, 32767, 0 },
489 { "Tal4cushort", TYPE_CUINT
, 65535, 0 },
490 { "Tal4cint", TYPE_CINT
, 2147483647, 0 },
491 { "Tal4cuint", TYPE_CUINT
, 4294967295U, 0 },
492 { "Tal4clong", TYPE_CINT
, 9223372036854775807LL, 0 },
493 { "Tal4culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
494 { "Tal4cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
495 { "Tal4cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
496 { "Tal4cfloat", TYPE_CFLOAT
, 0, 0 },
497 { "Tal4cdouble", TYPE_CFLOAT
, 0, 0 },
498 { "Tal4cldouble", TYPE_CFLOAT
, 0, 0 },
499 { "Tal8cchar", TYPE_CUINT
, 127, 0 },
500 { "Tal8cschar", TYPE_CINT
, 127, 0 },
501 { "Tal8cuchar", TYPE_CUINT
, 255, 0 },
502 { "Tal8cshort", TYPE_CINT
, 32767, 0 },
503 { "Tal8cushort", TYPE_CUINT
, 65535, 0 },
504 { "Tal8cint", TYPE_CINT
, 2147483647, 0 },
505 { "Tal8cuint", TYPE_CUINT
, 4294967295U, 0 },
506 { "Tal8clong", TYPE_CINT
, 9223372036854775807LL, 0 },
507 { "Tal8culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
508 { "Tal8cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
509 { "Tal8cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
510 { "Tal8cfloat", TYPE_CFLOAT
, 0, 0 },
511 { "Tal8cdouble", TYPE_CFLOAT
, 0, 0 },
512 { "Tal8cldouble", TYPE_CFLOAT
, 0, 0 },
513 { "Tal16cchar", TYPE_CUINT
, 127, 0 },
514 { "Tal16cschar", TYPE_CINT
, 127, 0 },
515 { "Tal16cuchar", TYPE_CUINT
, 255, 0 },
516 { "Tal16cshort", TYPE_CINT
, 32767, 0 },
517 { "Tal16cushort", TYPE_CUINT
, 65535, 0 },
518 { "Tal16cint", TYPE_CINT
, 2147483647, 0 },
519 { "Tal16cuint", TYPE_CUINT
, 4294967295U, 0 },
520 { "Tal16clong", TYPE_CINT
, 9223372036854775807LL, 0 },
521 { "Tal16culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
522 { "Tal16cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
523 { "Tal16cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
524 { "Tal16cfloat", TYPE_CFLOAT
, 0, 0 },
525 { "Tal16cdouble", TYPE_CFLOAT
, 0, 0 },
526 { "Tal16cldouble", TYPE_CFLOAT
, 0, 0 }
527 #define NCATYPES2 (sizeof (complex_attrib_types) / sizeof (complex_attrib_types[0]))
529 struct types attrib_array_types
[] = {
530 { "Talx1char", TYPE_UINT
, 127, 'C' },
531 { "Talx1schar", TYPE_INT
, 127, 'C' },
532 { "Talx1uchar", TYPE_UINT
, 255, 'C' },
533 { "Talx1short", TYPE_INT
, 32767, 'S' },
534 { "Talx1ushort", TYPE_UINT
, 65535, 'S' },
535 { "Talx1int", TYPE_INT
, 2147483647, 'I' },
536 { "Talx1uint", TYPE_UINT
, 4294967295U, 'I' },
537 { "Talx1long", TYPE_INT
, 9223372036854775807LL, 'L' },
538 { "Talx1ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
539 { "Talx1llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
540 { "Talx1ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
541 { "Talx1bool", TYPE_UINT
, 1, 'B' },
542 { "Talx1ptr", TYPE_PTR
, 0, 0 },
543 { "Talx1cptr", TYPE_PTR
, 0, 0 },
544 { "Talx1iptr", TYPE_PTR
, 0, 0 },
545 { "Talx1float", TYPE_FLOAT
, 0, 0 },
546 { "Talx1double", TYPE_FLOAT
, 0, 0 },
547 { "Talx1ldouble", TYPE_FLOAT
, 0, 0 },
548 #ifndef SKIP_DECIMAL_FLOAT
549 { "Talx1Decimal32", TYPE_DEC_FLOAT
, 0 ,0 },
550 { "Talx1Decimal64", TYPE_DEC_FLOAT
, 0 ,0 },
551 { "Talx1Decimal128", TYPE_DEC_FLOAT
, 0 ,0 },
553 { "Talx1E0", TYPE_UENUM
, 0, ' ' },
554 { "Talx1E1", TYPE_UENUM
, 1, ' ' },
555 { "Talx1E2", TYPE_SENUM
, 3, ' ' },
556 { "Talx1E3", TYPE_SENUM
, 127, ' ' },
557 { "Talx1E4", TYPE_UENUM
, 255, ' ' },
558 { "Talx1E5", TYPE_SENUM
, 32767, ' ' },
559 { "Talx1E6", TYPE_UENUM
, 65535, ' ' },
560 { "Talx1E7", TYPE_SENUM
, 2147483647, ' ' },
561 { "Talx1E8", TYPE_UENUM
, 4294967295U, ' ' },
562 { "Talx1E9", TYPE_SENUM
, 1099511627775LL, ' ' },
563 { "Talx2short", TYPE_INT
, 32767, 'S' },
564 { "Talx2ushort", TYPE_UINT
, 65535, 'S' },
565 { "Talx2int", TYPE_INT
, 2147483647, 'I' },
566 { "Talx2uint", TYPE_UINT
, 4294967295U, 'I' },
567 { "Talx2long", TYPE_INT
, 9223372036854775807LL, 'L' },
568 { "Talx2ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
569 { "Talx2llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
570 { "Talx2ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
571 { "Talx2ptr", TYPE_PTR
, 0, 0 },
572 { "Talx2cptr", TYPE_PTR
, 0, 0 },
573 { "Talx2iptr", TYPE_PTR
, 0, 0 },
574 { "Talx2float", TYPE_FLOAT
, 0, 0 },
575 { "Talx2double", TYPE_FLOAT
, 0, 0 },
576 { "Talx2ldouble", TYPE_FLOAT
, 0, 0 },
577 #ifndef SKIP_DECIMAL_FLOAT
578 { "Talx2Decimal32", TYPE_DEC_FLOAT
, 0 , 0 },
579 { "Talx2Decimal64", TYPE_DEC_FLOAT
, 0 , 0 },
580 { "Talx2Decimal128", TYPE_DEC_FLOAT
, 0 , 0 },
582 { "Talx2E0", TYPE_UENUM
, 0, ' ' },
583 { "Talx2E1", TYPE_UENUM
, 1, ' ' },
584 { "Talx2E2", TYPE_SENUM
, 3, ' ' },
585 { "Talx2E3", TYPE_SENUM
, 127, ' ' },
586 { "Talx2E4", TYPE_UENUM
, 255, ' ' },
587 { "Talx2E5", TYPE_SENUM
, 32767, ' ' },
588 { "Talx2E6", TYPE_UENUM
, 65535, ' ' },
589 { "Talx2E7", TYPE_SENUM
, 2147483647, ' ' },
590 { "Talx2E8", TYPE_UENUM
, 4294967295U, ' ' },
591 { "Talx2E9", TYPE_SENUM
, 1099511627775LL, ' ' },
592 { "Talx4int", TYPE_INT
, 2147483647, 'I' },
593 { "Talx4uint", TYPE_UINT
, 4294967295U, 'I' },
594 { "Talx4long", TYPE_INT
, 9223372036854775807LL, 'L' },
595 { "Talx4ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
596 { "Talx4llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
597 { "Talx4ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
598 { "Talx4ptr", TYPE_PTR
, 0, 0 },
599 { "Talx4cptr", TYPE_PTR
, 0, 0 },
600 { "Talx4iptr", TYPE_PTR
, 0, 0 },
601 { "Talx4float", TYPE_FLOAT
, 0, 0 },
602 { "Talx4double", TYPE_FLOAT
, 0, 0 },
603 { "Talx4ldouble", TYPE_FLOAT
, 0, 0 },
604 #ifndef SKIP_DECIMAL_FLOAT
605 { "Talx4Decimal32", TYPE_DEC_FLOAT
, 0 , 0 },
606 { "Talx4Decimal64", TYPE_DEC_FLOAT
, 0 , 0 },
607 { "Talx4Decimal128", TYPE_DEC_FLOAT
, 0 , 0 },
609 { "Talx4E0", TYPE_UENUM
, 0, ' ' },
610 { "Talx4E1", TYPE_UENUM
, 1, ' ' },
611 { "Talx4E2", TYPE_SENUM
, 3, ' ' },
612 { "Talx4E3", TYPE_SENUM
, 127, ' ' },
613 { "Talx4E4", TYPE_UENUM
, 255, ' ' },
614 { "Talx4E5", TYPE_SENUM
, 32767, ' ' },
615 { "Talx4E6", TYPE_UENUM
, 65535, ' ' },
616 { "Talx4E7", TYPE_SENUM
, 2147483647, ' ' },
617 { "Talx4E8", TYPE_UENUM
, 4294967295U, ' ' },
618 { "Talx4E9", TYPE_SENUM
, 1099511627775LL, ' ' },
619 { "Taly8long", TYPE_INT
, 9223372036854775807LL, 'L' },
620 { "Taly8ulong", TYPE_UINT
, 18446744073709551615ULL, 'L' },
621 { "Talx8llong", TYPE_INT
, 9223372036854775807LL, 'Q' },
622 { "Talx8ullong", TYPE_UINT
, 18446744073709551615ULL, 'Q' },
623 { "Taly8ptr", TYPE_PTR
, 0, 0 },
624 { "Taly8cptr", TYPE_PTR
, 0, 0 },
625 { "Taly8iptr", TYPE_PTR
, 0, 0 },
626 { "Talx8double", TYPE_FLOAT
, 0, 0 },
627 { "Talx8ldouble", TYPE_FLOAT
, 0, 0 },
628 #ifndef SKIP_DECIMAL_FLOAT
629 { "Talx8Decimal64", TYPE_DEC_FLOAT
, 0, 0 },
630 { "Talx8Decimal128", TYPE_DEC_FLOAT
, 0, 0 }
632 #define NAATYPES2 (sizeof (attrib_array_types) / sizeof (attrib_array_types[0]))
634 struct types complex_attrib_array_types
[] = {
635 { "Talx1cchar", TYPE_CUINT
, 127, 0 },
636 { "Talx1cschar", TYPE_CINT
, 127, 0 },
637 { "Talx1cuchar", TYPE_CUINT
, 255, 0 },
638 { "Talx1cshort", TYPE_CINT
, 32767, 0 },
639 { "Talx1cushort", TYPE_CUINT
, 65535, 0 },
640 { "Talx1cint", TYPE_CINT
, 2147483647, 0 },
641 { "Talx1cuint", TYPE_CUINT
, 4294967295U, 0 },
642 { "Talx1clong", TYPE_CINT
, 9223372036854775807LL, 0 },
643 { "Talx1culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
644 { "Talx1cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
645 { "Talx1cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
646 { "Talx1cfloat", TYPE_CFLOAT
, 0, 0 },
647 { "Talx1cdouble", TYPE_CFLOAT
, 0, 0 },
648 { "Talx1cldouble", TYPE_CFLOAT
, 0, 0 },
649 { "Talx2cchar", TYPE_CUINT
, 127, 0 },
650 { "Talx2cschar", TYPE_CINT
, 127, 0 },
651 { "Talx2cuchar", TYPE_CUINT
, 255, 0 },
652 { "Talx2cshort", TYPE_CINT
, 32767, 0 },
653 { "Talx2cushort", TYPE_CUINT
, 65535, 0 },
654 { "Talx2cint", TYPE_CINT
, 2147483647, 0 },
655 { "Talx2cuint", TYPE_CUINT
, 4294967295U, 0 },
656 { "Talx2clong", TYPE_CINT
, 9223372036854775807LL, 0 },
657 { "Talx2culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
658 { "Talx2cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
659 { "Talx2cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
660 { "Talx2cfloat", TYPE_CFLOAT
, 0, 0 },
661 { "Talx2cdouble", TYPE_CFLOAT
, 0, 0 },
662 { "Talx2cldouble", TYPE_CFLOAT
, 0, 0 },
663 { "Talx4cshort", TYPE_CINT
, 32767, 0 },
664 { "Talx4cushort", TYPE_CUINT
, 65535, 0 },
665 { "Talx4cint", TYPE_CINT
, 2147483647, 0 },
666 { "Talx4cuint", TYPE_CUINT
, 4294967295U, 0 },
667 { "Talx4clong", TYPE_CINT
, 9223372036854775807LL, 0 },
668 { "Talx4culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
669 { "Talx4cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
670 { "Talx4cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
671 { "Talx4cfloat", TYPE_CFLOAT
, 0, 0 },
672 { "Talx4cdouble", TYPE_CFLOAT
, 0, 0 },
673 { "Talx4cldouble", TYPE_CFLOAT
, 0, 0 },
674 { "Talx8cint", TYPE_CINT
, 2147483647, 0 },
675 { "Talx8cuint", TYPE_CUINT
, 4294967295U, 0 },
676 { "Talx8clong", TYPE_CINT
, 9223372036854775807LL, 0 },
677 { "Talx8culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
678 { "Talx8cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
679 { "Talx8cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
680 { "Talx8cfloat", TYPE_CFLOAT
, 0, 0 },
681 { "Talx8cdouble", TYPE_CFLOAT
, 0, 0 },
682 { "Talx8cldouble", TYPE_CFLOAT
, 0, 0 },
683 { "Taly16clong", TYPE_CINT
, 9223372036854775807LL, 0 },
684 { "Taly16culong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
685 { "Talx16cllong", TYPE_CINT
, 9223372036854775807LL, 0 },
686 { "Talx16cullong", TYPE_CUINT
, 18446744073709551615ULL, 0 },
687 { "Talx16cdouble", TYPE_CFLOAT
, 0, 0 },
688 { "Talx16cldouble", TYPE_CFLOAT
, 0, 0 }
689 #define NCAATYPES2 (sizeof (complex_attrib_array_types) / sizeof (complex_attrib_array_types[0]))
692 struct types bitfld_types
[NTYPES2
];
694 struct types aligned_bitfld_types
[NATYPES2
];
695 int n_aligned_bitfld_types
;
697 const char *attributes
[] = {
718 #define NATTRIBS2 (sizeof (attributes) / sizeof (attributes[0]))
735 enum ETYPE etype
: 8;
740 unsigned char arr_len
;
743 /* Used to chain together entries in the hash table. */
747 /* A prime number giving the number of slots in the hash table. */
748 #define HASH_SIZE 32749
749 static struct entry
*hash_table
[HASH_SIZE
];
751 static int idx
, limidx
, output_one
, short_enums
;
752 static const char *destdir
;
753 static const char *srcdir
;
754 static const char *srcdir_safe
;
758 switchfiles (int fields
)
761 static char *destbuf
, *destptr
;
774 size_t len
= strlen (destdir
);
775 destbuf
= malloc (len
+ 20);
778 memcpy (destbuf
, destdir
, len
);
779 if (!len
|| destbuf
[len
- 1] != '/')
780 destbuf
[len
++] = '/';
781 destptr
= destbuf
+ len
;
783 sprintf (destptr
, "t%03d_main.c", filecnt
);
784 outfile
= fopen (destbuf
, "w");
788 fputs ("failed to create test files\n", stderr
);
791 fprintf (outfile
, "/* { dg-require-effective-target int32plus } */\n");
792 for (i
= 0; i
< NDG_OPTIONS
; i
++)
793 fprintf (outfile
, dg_options
[i
], "", srcdir_safe
);
794 fprintf (outfile
, "/* { dg-prune-output \".*-Wno-abi.*\" } */\n");
795 fprintf (outfile
, "/* { dg-prune-output \".*Offset of packed bit-field.*\" } */\n");
797 #include \"struct-layout-1.h\"\n\
799 #define TX(n, type, attrs, fields, ops) extern void test##n (void);\n\
800 #include \"t%03d_test.h\"\n\
805 #define TX(n, type, attrs, fields, ops) test##n ();\n\
806 #include \"t%03d_test.h\"\n\
808 exit (fails != 0);\n\
809 }\n", filecnt
, filecnt
);
811 sprintf (destptr
, "t%03d_x.c", filecnt
);
812 outfile
= fopen (destbuf
, "w");
815 for (i
= 0; i
< NDG_OPTIONS
; i
++)
816 fprintf (outfile
, dg_options
[i
], "-w ", srcdir_safe
);
818 #include \"struct-layout-1_x1.h\"\n\
819 #include \"t%03d_test.h\"\n\
820 #include \"struct-layout-1_x2.h\"\n\
821 #include \"t%03d_test.h\"\n", filecnt
, filecnt
);
823 sprintf (destptr
, "t%03d_y.c", filecnt
);
824 outfile
= fopen (destbuf
, "w");
827 for (i
= 0; i
< NDG_OPTIONS
; i
++)
828 fprintf (outfile
, dg_options
[i
], "-w ", srcdir_safe
);
830 #include \"struct-layout-1_y1.h\"\n\
831 #include \"t%03d_test.h\"\n\
832 #include \"struct-layout-1_y2.h\"\n\
833 #include \"t%03d_test.h\"\n", filecnt
, filecnt
);
835 sprintf (destptr
, "t%03d_test.h", filecnt
);
836 outfile
= fopen (destbuf
, "w");
841 else if (fields
<= 4)
843 else if (fields
<= 6)
849 unsigned long long int
852 unsigned long long int ret
;
853 ret
= generate_random () & 0xffffff;
854 ret
|= (generate_random () & 0xffffffLL
) << 24;
855 ret
|= ((unsigned long long int) generate_random ()) << 48;
860 subfield (struct entry
*e
, char *letter
)
869 case ETYPE_STRUCT_ARRAY
:
870 case ETYPE_UNION_ARRAY
:
871 type
= e
[0].attrib
? 1 + (generate_random () & 3) : 0;
872 if (e
[0].etype
== ETYPE_STRUCT
|| e
[0].etype
== ETYPE_STRUCT_ARRAY
)
876 if (e
[0].etype
== ETYPE_STRUCT_ARRAY
|| e
[0].etype
== ETYPE_UNION_ARRAY
)
878 if (e
[0].arr_len
== 255)
879 snprintf (buf
, 20, "%c[]", *letter
);
881 snprintf (buf
, 20, "%c[%d]", *letter
, e
[0].arr_len
);
882 /* If this is an array type, do not put aligned attributes on
883 elements. Aligning elements to a value greater than their
884 size will result in a compiler error. */
886 && ((strncmp (e
[0].attrib
, "atal", 4) == 0)
887 || strncmp (e
[0].attrib
, "atpaal", 6) == 0))
901 fprintf (outfile
, "%s{", p
);
904 fprintf (outfile
, "%s %s{", e
[0].attrib
, p
);
907 fprintf (outfile
, "%s %s{", p
, e
[0].attrib
);
911 for (i
= 1; i
<= e
[0].len
; )
912 i
+= subfield (e
+ i
, letter
);
919 fprintf (outfile
, "}%s;", buf
);
922 fprintf (outfile
, "}%s %s;", e
[0].attrib
, buf
);
925 fprintf (outfile
, "}%s %s;", buf
, e
[0].attrib
);
931 if (e
[0].etype
== ETYPE_ARRAY
)
933 if (e
[0].arr_len
== 255)
934 snprintf (buf
, 20, "%c[]", *letter
);
936 snprintf (buf
, 20, "%c[%d]", *letter
, e
[0].arr_len
);
946 /* If this is an array type, do not put aligned attributes on
947 elements. Aligning elements to a value greater than their
948 size will result in a compiler error. */
949 if (e
[0].etype
== ETYPE_ARRAY
950 && ((strncmp (e
[0].attrib
, "atal", 4) == 0)
951 || strncmp (e
[0].attrib
, "atpaal", 6) == 0))
954 type
= generate_random () % 3;
958 fprintf (outfile
, "%s %s %s;", e
[0].attrib
, e
[0].type
->name
,
962 fprintf (outfile
, "%s %s %s;", e
[0].type
->name
, e
[0].attrib
,
966 fprintf (outfile
, "%s %s %s;", e
[0].type
->name
, buf
,
972 fprintf (outfile
, "%s %s;", e
[0].type
->name
, buf
);
978 switch (generate_random () % 3)
981 fprintf (outfile
, "%s %s:0;", e
[0].attrib
, e
[0].type
->name
);
984 fprintf (outfile
, "%s %s:0;", e
[0].type
->name
, e
[0].attrib
);
987 fprintf (outfile
, "%s:0 %s;", e
[0].type
->name
, e
[0].attrib
);
991 fprintf (outfile
, "%s:0;", e
[0].type
->name
);
995 switch (e
[0].type
->bitfld
)
1002 snprintf (buf
, 20, "B%cN(%d)", e
[0].type
->bitfld
, e
[0].len
);
1006 snprintf (buf
, 20, "%d", e
[0].len
);
1012 switch (generate_random () % 3)
1015 fprintf (outfile
, "%s %s %c:%s;", e
[0].attrib
, e
[0].type
->name
,
1019 fprintf (outfile
, "%s %s %c:%s;", e
[0].type
->name
, e
[0].attrib
,
1023 fprintf (outfile
, "%s %c:%s %s;", e
[0].type
->name
, *letter
,
1028 fprintf (outfile
, "%s %c:%s;", e
[0].type
->name
, *letter
, buf
);
1039 output_FNB (char mode
, struct entry
*e
)
1041 unsigned long long int l1
, l2
, m
;
1043 #ifndef SKIP_DECIMAL_FLOAT
1045 char DEC_SUFFIX
[3][3]={"DF","DD","DL"};
1050 if (e
->type
->type
== TYPE_OTHER
)
1054 fprintf (outfile
, "N(%d,%s)", idx
, namebuf
);
1057 fprintf (outfile
, "%c(%d,%s,", mode
, idx
, namebuf
);
1060 switch (e
->type
->type
)
1063 signs
= generate_random () & 3;
1064 m
= e
->type
->maxval
;
1066 m
&= e
->len
> 1 ? (1ULL << (e
->len
- 1)) - 1 : 1;
1069 fprintf (outfile
, "%s%" COMPAT_PRLL
"u%s,%s%" COMPAT_PRLL
"u%s",
1070 (signs
& 1) ? "-" : "", l1
, l1
> 2147483647 ? "LL" : "",
1071 (signs
& 2) ? "-" : "", l2
, l2
> 2147483647 ? "LL" : "");
1074 m
= e
->type
->maxval
;
1076 m
&= (1ULL << e
->len
) - 1;
1079 fprintf (outfile
, "%" COMPAT_PRLL
"uU%s,%" COMPAT_PRLL
"uU%s",
1080 l1
, l1
> 4294967295U ? "LL" : "",
1081 l2
, l2
> 4294967295U ? "LL" : "");
1086 signs
= generate_random () & 3;
1087 fprintf (outfile
, "%s%f,%s%f", (signs
& 1) ? "-" : "",
1088 ((double) l1
) / 64, (signs
& 2) ? "-" : "", ((double) l2
) / 64);
1090 #ifndef SKIP_DECIMAL_FLOAT
1091 case TYPE_DEC_FLOAT
:
1094 signs
= generate_random () & 3;
1096 /* Get the suffix of Decimal Floting Points per
1097 e->type->name. Distinguish these three DFP types by
1099 if (strstr(e
->type
->name
, "Decimal32")) suffix
=0;
1100 else if (strstr(e
->type
->name
, "Decimal64")) suffix
=1;
1101 else if (strstr(e
->type
->name
, "Decimal128")) suffix
=2;
1105 /* Formatted input/output specifiers for DFP types have not been
1106 implemented in GLIBC. %f here used in fprintf is just to
1107 dump the numbers to outfile. */
1108 fprintf (outfile
, "%s%f%s,%s%f%s",
1109 (signs
& 1) ? "-" : "", ((double) l1
) / 64, DEC_SUFFIX
[suffix
],
1110 (signs
& 2) ? "-" : "", ((double) l2
) / 64, DEC_SUFFIX
[suffix
]);
1114 signs
= generate_random () & 3;
1115 l1
&= e
->type
->maxval
;
1116 l2
&= e
->type
->maxval
;
1118 "CINT(%s%" COMPAT_PRLL
"u%s,%s%" COMPAT_PRLL
"u%s),",
1119 (signs
& 1) ? "-" : "", l1
, l1
> 2147483647 ? "LL" : "",
1120 (signs
& 2) ? "-" : "", l2
, l2
> 2147483647 ? "LL" : "");
1121 signs
= generate_random () & 3;
1124 l1
&= e
->type
->maxval
;
1125 l2
&= e
->type
->maxval
;
1127 "CINT(%s%" COMPAT_PRLL
"u%s,%s%" COMPAT_PRLL
"u%s)",
1128 (signs
& 1) ? "-" : "", l1
, l1
> 2147483647 ? "LL" : "",
1129 (signs
& 2) ? "-" : "", l2
, l2
> 2147483647 ? "LL" : "");
1132 l1
&= e
->type
->maxval
;
1133 l2
&= e
->type
->maxval
;
1135 "CINT(%" COMPAT_PRLL
"uU%s,%" COMPAT_PRLL
"uU%s),",
1136 l1
, l1
> 4294967295U ? "LL" : "",
1137 l2
, l2
> 4294967295U ? "LL" : "");
1140 l1
&= e
->type
->maxval
;
1141 l2
&= e
->type
->maxval
;
1143 "CINT(%" COMPAT_PRLL
"uU%s,%" COMPAT_PRLL
"uU%s)",
1144 l1
, l1
> 4294967295U ? "LL" : "",
1145 l2
, l2
> 4294967295U ? "LL" : "");
1150 signs
= generate_random () & 3;
1151 fprintf (outfile
, "CDBL(%s%f,%s%f),",
1152 (signs
& 1) ? "-" : "", ((double) l1
) / 64,
1153 (signs
& 2) ? "-" : "", ((double) l2
) / 64);
1158 signs
= generate_random () & 3;
1159 fprintf (outfile
, "CDBL(%s%f,%s%f)",
1160 (signs
& 1) ? "-" : "", ((double) l1
) / 64,
1161 (signs
& 2) ? "-" : "", ((double) l2
) / 64);
1164 if (e
->type
->maxval
== 0)
1165 fputs ("e0_0,e0_0", outfile
);
1166 else if (e
->type
->maxval
== 1)
1167 fprintf (outfile
, "e1_%" COMPAT_PRLL
"d,e1_%" COMPAT_PRLL
"d",
1171 p
= strchr (e
->type
->name
, '\0');
1172 while (--p
>= e
->type
->name
&& *p
>= '0' && *p
<= '9');
1177 l1
+= e
->type
->maxval
- 6;
1179 l2
+= e
->type
->maxval
- 6;
1180 fprintf (outfile
, "e%s_%" COMPAT_PRLL
"d,e%s_%" COMPAT_PRLL
"d",
1185 p
= strchr (e
->type
->name
, '\0');
1186 while (--p
>= e
->type
->name
&& *p
>= '0' && *p
<= '9');
1190 fprintf (outfile
, "e%s_%s%" COMPAT_PRLL
"d,e%s_%s%" COMPAT_PRLL
"d",
1191 p
, l1
< 3 ? "m" : "",
1192 l1
== 3 ? 0LL : e
->type
->maxval
- (l1
& 3),
1193 p
, l2
< 3 ? "m" : "",
1194 l2
== 3 ? 0LL : e
->type
->maxval
- (l2
& 3));
1200 "(%s)&intarray[%" COMPAT_PRLL
"d], (%s)&intarray[%" COMPAT_PRLL
"d]",
1201 e
->type
->name
, l1
, e
->type
->name
, l2
);
1206 fprintf (outfile
, "fn%" COMPAT_PRLL
"d,fn%" COMPAT_PRLL
"d", l1
, l2
);
1211 fputs (")", outfile
);
1215 subvalues (struct entry
*e
, char *p
, char *letter
)
1219 if (p
>= namebuf
+ sizeof (namebuf
) - 32)
1226 case ETYPE_STRUCT_ARRAY
:
1227 case ETYPE_UNION_ARRAY
:
1228 if (e
[0].arr_len
== 0 || e
[0].arr_len
== 255)
1230 *letter
+= 1 + e
[0].len
;
1231 return 1 + e
[0].len
;
1233 i
= generate_random () % e
[0].arr_len
;
1234 snprintf (p
, sizeof (namebuf
) - (p
- namebuf
) - 1,
1235 "%c[%d]", *letter
, i
);
1236 q
= strchr (p
, '\0');
1242 for (i
= 1; i
<= e
[0].len
; )
1244 i
+= subvalues (e
+ i
, q
, letter
);
1245 if (e
[0].etype
== ETYPE_UNION
|| e
[0].etype
== ETYPE_UNION_ARRAY
)
1247 *letter
+= e
[0].len
- i
+ 1;
1251 return 1 + e
[0].len
;
1254 output_FNB ('F', e
);
1257 if (e
[0].arr_len
== 0 || e
[0].arr_len
== 255)
1262 i
= generate_random () % e
[0].arr_len
;
1263 snprintf (p
, sizeof (namebuf
) - (p
- namebuf
),
1264 "%c[%d]", *letter
, i
);
1265 output_FNB ('F', e
);
1266 if ((generate_random () & 7) == 0)
1268 j
= generate_random () % e
[0].arr_len
;
1271 snprintf (p
, sizeof (namebuf
) - (p
- namebuf
),
1272 "%c[%d]", *letter
, j
);
1273 output_FNB ('F', e
);
1281 output_FNB ('B', e
);
1287 --------------------------------------------------------------------
1288 lookup2.c, by Bob Jenkins, December 1996, Public Domain.
1289 hash(), hash2(), hash3, and mix() are externally useful functions.
1290 Routines to test the hash are included if SELF_TEST is defined.
1291 You can use this free for any purpose. It has no warranty.
1292 --------------------------------------------------------------------
1296 --------------------------------------------------------------------
1297 mix -- mix 3 32-bit values reversibly.
1298 For every delta with one or two bit set, and the deltas of all three
1299 high bits or all three low bits, whether the original value of a,b,c
1300 is almost all zero or is uniformly distributed,
1301 * If mix() is run forward or backward, at least 32 bits in a,b,c
1302 have at least 1/4 probability of changing.
1303 * If mix() is run forward, every bit of c will change between 1/3 and
1304 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
1305 mix() was built out of 36 single-cycle latency instructions in a
1306 structure that could supported 2x parallelism, like so:
1308 a -= c; x = (c>>13);
1312 c -= b; x = (b>>13);
1314 Unfortunately, superscalar Pentiums and Sparcs can't take advantage
1315 of that parallelism. They've also turned some of those single-cycle
1316 latency instructions into multi-cycle latency instructions. Still,
1317 this is the fastest good hash I could find. There were about 2^^68
1318 to choose from. I only looked at a billion or so.
1319 --------------------------------------------------------------------
1321 /* same, but slower, works on systems that might have 8 byte hashval_t's */
1322 #define mix(a,b,c) \
1324 a -= b; a -= c; a ^= (c>>13); \
1325 b -= c; b -= a; b ^= (a<< 8); \
1326 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
1327 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
1328 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
1329 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
1330 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
1331 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
1332 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
1336 --------------------------------------------------------------------
1337 hash() -- hash a variable-length key into a 32-bit value
1338 k : the key (the unaligned variable-length array of bytes)
1339 len : the length of the key, counting by bytes
1340 level : can be any 4-byte value
1341 Returns a 32-bit value. Every bit of the key affects every bit of
1342 the return value. Every 1-bit and 2-bit delta achieves avalanche.
1343 About 36+6len instructions.
1345 The best hash table sizes are powers of 2. There is no need to do
1346 mod a prime (mod is sooo slow!). If you need less than 32 bits,
1347 use a bitmask. For example, if you need only 10 bits, do
1348 h = (h & hashmask(10));
1349 In which case, the hash table should have hashsize(10) elements.
1351 If you are hashing n strings (ub1 **)k, do it like this:
1352 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
1354 By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
1355 code any way you wish, private, educational, or commercial. It's free.
1357 See http://burtleburtle.net/bob/hash/evahash.html
1358 Use for hash table lookup, or anything where one collision in 2^32 is
1359 acceptable. Do NOT use for cryptographic purposes.
1360 --------------------------------------------------------------------
1364 iterative_hash (const void *k_in
/* the key */,
1365 register size_t length
/* the length of the key */,
1366 register hashval_t initval
/* the previous hash, or
1367 an arbitrary value */)
1369 register const unsigned char *k
= (const unsigned char *)k_in
;
1370 register hashval_t a
,b
,c
,len
;
1372 /* Set up the internal state */
1374 a
= b
= 0x9e3779b9; /* the golden ratio; an arbitrary value */
1375 c
= initval
; /* the previous hash value */
1377 /*---------------------------------------- handle most of the key */
1380 a
+= (k
[0] +((hashval_t
)k
[1]<<8) +((hashval_t
)k
[2]<<16) +((hashval_t
)k
[3]<<24));
1381 b
+= (k
[4] +((hashval_t
)k
[5]<<8) +((hashval_t
)k
[6]<<16) +((hashval_t
)k
[7]<<24));
1382 c
+= (k
[8] +((hashval_t
)k
[9]<<8) +((hashval_t
)k
[10]<<16)+((hashval_t
)k
[11]<<24));
1387 /*------------------------------------- handle the last 11 bytes */
1389 switch(len
) /* all the case statements fall through */
1391 case 11: c
+=((hashval_t
)k
[10]<<24);
1392 case 10: c
+=((hashval_t
)k
[9]<<16);
1393 case 9 : c
+=((hashval_t
)k
[8]<<8);
1394 /* the first byte of c is reserved for the length */
1395 case 8 : b
+=((hashval_t
)k
[7]<<24);
1396 case 7 : b
+=((hashval_t
)k
[6]<<16);
1397 case 6 : b
+=((hashval_t
)k
[5]<<8);
1399 case 4 : a
+=((hashval_t
)k
[3]<<24);
1400 case 3 : a
+=((hashval_t
)k
[2]<<16);
1401 case 2 : a
+=((hashval_t
)k
[1]<<8);
1403 /* case 0: nothing left to add */
1406 /*-------------------------------------------- report the result */
1411 e_hash (const void *a
)
1413 const struct entry
*e
= a
;
1417 if (e
[0].etype
!= ETYPE_STRUCT
&& e
[0].etype
!= ETYPE_UNION
)
1419 for (i
= 0; i
<= e
[0].len
; ++i
)
1422 ret
= iterative_hash (&e
[i
], offsetof (struct entry
, attrib
), ret
);
1423 attriblen
= e
[i
].attrib
? strlen (e
[i
].attrib
) : -1;
1424 ret
= iterative_hash (&attriblen
, sizeof (int), ret
);
1426 ret
= iterative_hash (e
[i
].attrib
, attriblen
, ret
);
1432 e_eq (const void *a
, const void *b
)
1434 const struct entry
*ea
= a
, *eb
= b
;
1436 if (ea
[0].etype
!= ETYPE_STRUCT
&& ea
[0].etype
!= ETYPE_UNION
)
1438 if (ea
[0].len
!= eb
[0].len
)
1440 for (i
= 0; i
<= ea
[0].len
; ++i
)
1442 if (ea
[i
].etype
!= eb
[i
].etype
1443 || ea
[i
].len
!= eb
[i
].len
1444 || ea
[i
].arr_len
!= eb
[i
].arr_len
1445 || ea
[i
].type
!= eb
[i
].type
)
1447 if ((ea
[i
].attrib
== NULL
) ^ (eb
[i
].attrib
== NULL
))
1449 if (ea
[i
].attrib
&& strcmp (ea
[i
].attrib
, eb
[i
].attrib
) != 0)
1456 e_exists (const struct entry
*e
)
1462 for (h
= hash_table
[hval
% HASH_SIZE
]; h
; h
= h
->next
)
1469 e_insert (struct entry
*e
)
1474 e
->next
= hash_table
[hval
% HASH_SIZE
];
1475 hash_table
[hval
% HASH_SIZE
] = e
;
1479 output (struct entry
*e
)
1484 const char *skip_cint
= "";
1486 if (e
[0].etype
!= ETYPE_STRUCT
&& e
[0].etype
!= ETYPE_UNION
)
1492 n
= (struct entry
*) malloc ((e
[0].len
+ 1) * sizeof (struct entry
));
1493 memcpy (n
, e
, (e
[0].len
+ 1) * sizeof (struct entry
));
1497 switchfiles (e
[0].len
);
1499 for (i
= 1; i
<= e
[0].len
; ++i
)
1500 if ((e
[i
].etype
== ETYPE_TYPE
|| e
[i
].etype
== ETYPE_ARRAY
)
1501 && (e
[i
].type
->type
== TYPE_CINT
|| e
[i
].type
->type
== TYPE_CUINT
))
1506 fprintf (outfile
, (generate_random () & 1)
1507 ? "TX%s(%d,%s %s,," : "TX%s(%d,%s,%s,", skip_cint
,
1508 idx
, e
[0].etype
== ETYPE_STRUCT
? "struct" : "union",
1510 else if (e
[0].etype
== ETYPE_STRUCT
)
1511 fprintf (outfile
, "T%s(%d,", skip_cint
, idx
);
1513 fprintf (outfile
, "U%s(%d,", skip_cint
, idx
);
1515 for (i
= 1; i
<= e
[0].len
; )
1516 i
+= subfield (e
+ i
, &c
);
1517 fputs (",", outfile
);
1519 for (i
= 1; i
<= e
[0].len
; )
1521 i
+= subvalues (e
+ i
, namebuf
, &c
);
1522 if (e
[0].etype
== ETYPE_UNION
)
1525 fputs (")\n", outfile
);
1526 if (output_one
&& idx
== limidx
)
1534 FEATURE_COMPLEX
= 2,
1535 FEATURE_ALIGNEDPACKED
= 4,
1536 FEATURE_ZEROARRAY
= 8,
1537 FEATURE_ZEROBITFLD
= 16,
1538 ALL_FEATURES
= FEATURE_COMPLEX
| FEATURE_VECTOR
| FEATURE_ZEROARRAY
1539 | FEATURE_ALIGNEDPACKED
| FEATURE_ZEROBITFLD
1543 singles (enum FEATURE features
)
1547 memset (e
, 0, sizeof (e
));
1548 e
[0].etype
= ETYPE_STRUCT
;
1550 e
[0].etype
= ETYPE_UNION
;
1553 i
< ((features
& FEATURE_ALIGNEDPACKED
) ? NATTRIBS2
: NATTRIBS1
);
1556 e
[0].attrib
= attributes
[i
];
1557 e
[0].etype
= ETYPE_STRUCT
;
1559 e
[0].etype
= ETYPE_UNION
;
1564 for (i
= 0; i
< NTYPES2
; ++i
)
1566 e
[0].etype
= ETYPE_STRUCT
;
1567 e
[1].etype
= ETYPE_TYPE
;
1568 e
[1].type
= &base_types
[i
];
1570 e
[0].etype
= ETYPE_UNION
;
1573 if (features
& FEATURE_COMPLEX
)
1574 for (i
= 0; i
< NCTYPES2
; ++i
)
1576 e
[0].etype
= ETYPE_STRUCT
;
1577 e
[1].etype
= ETYPE_TYPE
;
1578 e
[1].type
= &complex_types
[i
];
1580 e
[0].etype
= ETYPE_UNION
;
1583 if (features
& FEATURE_VECTOR
)
1584 for (i
= 0; i
< NVTYPES2
; ++i
)
1586 e
[0].etype
= ETYPE_STRUCT
;
1587 e
[1].etype
= ETYPE_TYPE
;
1588 e
[1].type
= &vector_types
[i
];
1590 e
[0].etype
= ETYPE_UNION
;
1596 choose_type (enum FEATURE features
, struct entry
*e
, int r
, int in_array
)
1600 i
= NTYPES2
- NTYPES1
;
1601 if (features
& FEATURE_COMPLEX
)
1603 if (features
& FEATURE_VECTOR
)
1610 if (features
& FEATURE_COMPLEX
)
1616 if (features
& FEATURE_COMPLEX
)
1622 if (r
< NTYPES2
- NTYPES1
)
1623 e
->type
= &base_types
[r
+ NTYPES1
];
1624 r
-= NTYPES2
- NTYPES1
;
1625 if (e
->type
== NULL
&& (features
& FEATURE_COMPLEX
))
1628 e
->type
= &complex_types
[r
];
1631 if (e
->type
== NULL
&& (features
& FEATURE_VECTOR
))
1634 e
->type
= &vector_types
[r
];
1637 if (e
->type
== NULL
&& !in_array
)
1640 e
->type
= &attrib_types
[r
];
1643 if (e
->type
== NULL
&& !in_array
&& (features
& FEATURE_COMPLEX
))
1646 e
->type
= &complex_attrib_types
[r
];
1649 if (e
->type
== NULL
&& in_array
)
1652 e
->type
= &attrib_array_types
[r
];
1655 if (e
->type
== NULL
&& in_array
&& (features
& FEATURE_COMPLEX
))
1658 e
->type
= &complex_attrib_array_types
[r
];
1661 if (e
->type
== NULL
)
1665 /* This is from gcc.c-torture/execute/builtin-bitops-1.c. */
1667 my_ffsll (unsigned long long x
)
1672 /* We've tested LLONG_MAX for 64 bits so this should be safe. */
1673 for (i
= 0; i
< 64; i
++)
1674 if (x
& (1ULL << i
))
1680 generate_fields (enum FEATURE features
, struct entry
*e
, struct entry
*parent
,
1683 int r
, i
, j
, ret
= 1, n
, incr
, sametype
;
1685 for (n
= 0; n
< len
; n
+= incr
)
1687 r
= generate_random ();
1688 /* 50% ETYPE_TYPE base_types NTYPES1
1689 12.5% ETYPE_TYPE other
1692 12.5% ETYPE_STRUCT|ETYPE_UNION|ETYPE_STRUCT_ARRAY|ETYPE_UNION_ARRAY */
1702 e
[n
].etype
= ETYPE_TYPE
;
1703 e
[n
].type
= &base_types
[r
% NTYPES1
];
1706 e
[n
].etype
= ETYPE_TYPE
;
1707 choose_type (features
, &e
[n
], r
, 0);
1710 e
[n
].etype
= ETYPE_ARRAY
;
1714 e
[n
].type
= &base_types
[r
% NTYPES1
];
1716 choose_type (features
, &e
[n
], r
, 1);
1717 r
= generate_random ();
1718 if ((features
& FEATURE_ZEROARRAY
) && (r
& 3) == 0)
1721 if (n
== len
- 1 && (r
& 4)
1722 && (parent
->etype
== ETYPE_STRUCT
1723 || parent
->etype
== ETYPE_STRUCT_ARRAY
))
1726 for (k
= 0; k
< n
; ++k
)
1727 if (e
[k
].etype
!= ETYPE_BITFLD
|| e
[k
].len
)
1734 else if ((r
& 3) != 3)
1735 e
[n
].arr_len
= (r
>> 2) & 7;
1737 e
[n
].arr_len
= (r
>> 2) & 31;
1750 incr
= 1 + (r
>> 3) % (len
- n
);
1755 incr
= 1 + (r
>> 3) % (len
- n
);
1758 for (j
= n
; j
< n
+ incr
; ++j
)
1762 e
[j
].etype
= ETYPE_BITFLD
;
1763 if (j
== n
|| !sametype
)
1766 r
= generate_random ();
1771 = &aligned_bitfld_types
[r
% n_aligned_bitfld_types
];
1774 = &bitfld_types
[r
% n_bitfld_types
];
1777 e
[j
].type
= e
[n
].type
;
1778 r
= generate_random ();
1781 switch (e
[j
].type
->bitfld
)
1783 case 'C': ma
= 8; break;
1784 case 'S': ma
= 16; break;
1785 case 'I': ma
= 32; break;
1787 case 'Q': ma
= 64; break;
1788 case 'B': ma
= 1; break;
1790 if (e
[j
].type
->type
== TYPE_UENUM
)
1791 mi
= my_ffsll (e
[j
].type
->maxval
+ 1) - 1;
1792 else if (e
[j
].type
->type
== TYPE_SENUM
)
1793 mi
= my_ffsll (e
[j
].type
->maxval
+ 1);
1800 else if (mi
> 16 || !short_enums
)
1811 if (sametype
&& (r
& 3) == 0 && ma
> 1)
1814 for (k
= n
; k
< j
; ++k
)
1817 e
[j
].len
= sum
? ma
- sum
: ma
;
1820 if (! (features
& FEATURE_ZEROBITFLD
) && mi
== 0)
1822 if (e
[j
].len
< mi
|| e
[j
].len
> ma
)
1823 e
[j
].len
= mi
+ (r
% (ma
+ 1 - mi
));
1825 if ((features
& FEATURE_ZEROBITFLD
) && (r
& 3) == 0
1836 e
[n
].etype
= ETYPE_STRUCT
;
1840 e
[n
].etype
= ETYPE_UNION
;
1844 e
[n
].etype
= ETYPE_STRUCT_ARRAY
;
1847 e
[n
].etype
= ETYPE_UNION_ARRAY
;
1851 e
[n
].len
= r
% (len
- n
);
1852 incr
= 1 + e
[n
].len
;
1853 generate_fields (features
, &e
[n
+ 1], &e
[n
], e
[n
].len
);
1854 if (e
[n
].etype
== ETYPE_STRUCT_ARRAY
1855 || e
[n
].etype
== ETYPE_UNION_ARRAY
)
1857 r
= generate_random ();
1858 if ((features
& FEATURE_ZEROARRAY
) && (r
& 3) == 0)
1861 if (n
+ incr
== len
&& (r
& 4)
1862 && (parent
->etype
== ETYPE_STRUCT
1863 || parent
->etype
== ETYPE_STRUCT_ARRAY
))
1866 for (k
= 0; k
< n
; ++k
)
1867 if (e
[k
].etype
!= ETYPE_BITFLD
|| e
[k
].len
)
1874 else if ((r
& 3) != 3)
1875 e
[n
].arr_len
= (r
>> 2) & 7;
1877 e
[n
].arr_len
= (r
>> 2) & 31;
1881 r
= generate_random ();
1885 i
= (features
& FEATURE_ALIGNEDPACKED
) ? NATTRIBS2
: NATTRIBS1
;
1886 e
[n
].attrib
= attributes
[r
% i
];
1887 if (! (features
& FEATURE_ALIGNEDPACKED
)
1888 && strcmp (e
[n
].attrib
, "atpa") == 0
1889 && ((e
[n
].type
>= &attrib_types
[0]
1890 && e
[n
].type
< &attrib_types
[NATYPES2
])
1891 || (e
[n
].type
>= &complex_attrib_types
[0]
1892 && e
[n
].type
< &complex_attrib_types
[NCATYPES2
])
1893 || (e
[n
].type
>= &attrib_array_types
[0]
1894 && e
[n
].type
< &attrib_array_types
[NAATYPES2
])
1895 || (e
[n
].type
>= &complex_attrib_array_types
[0]
1896 && e
[n
].type
< &complex_attrib_array_types
[NCAATYPES2
])
1897 || (e
[n
].type
>= &aligned_bitfld_types
[0]
1898 && e
[n
].type
< &aligned_bitfld_types
[n_aligned_bitfld_types
])))
1905 generate_random_tests (enum FEATURE features
, int len
)
1907 struct entry e
[len
+ 1];
1909 if (len
> 'z' - 'a' + 1)
1911 memset (e
, 0, sizeof (e
));
1912 r
= generate_random ();
1914 e
[0].etype
= ETYPE_UNION
;
1916 e
[0].etype
= ETYPE_STRUCT
;
1922 if (features
& FEATURE_ALIGNEDPACKED
)
1926 e
[0].attrib
= attributes
[r
];
1928 generate_fields (features
, &e
[1], &e
[0], len
);
1932 struct { const char *name
; enum FEATURE f
; }
1935 { "complex", FEATURE_COMPLEX
},
1936 { "vector", FEATURE_VECTOR
},
1937 { "[0] :0", FEATURE_ZEROARRAY
| FEATURE_ZEROBITFLD
},
1938 { "complex vector [0]",
1939 FEATURE_COMPLEX
| FEATURE_VECTOR
| FEATURE_ZEROARRAY
},
1940 { "aligned packed complex vector [0] :0",
1941 FEATURE_COMPLEX
| FEATURE_VECTOR
| FEATURE_ZEROARRAY
1942 | FEATURE_ALIGNEDPACKED
| FEATURE_ZEROBITFLD
},
1946 main (int argc
, char **argv
)
1948 int i
, j
, count
, c
, n
= 3000;
1951 if (sizeof (int) != 4 || sizeof (long long) != 8)
1958 if (argv
[i
][0] == '-' && argv
[i
][2] == '\0')
1960 optarg
= argv
[i
+ 1];
1976 limidx
= atoi (optarg
);
1983 fprintf (stderr
, "unrecognized option %s\n", argv
[i
]);
1991 outfile
= fopen ("/dev/null", "w");
1992 if (outfile
== NULL
)
1994 fputs ("could not open /dev/null", stderr
);
2000 if (destdir
== NULL
&& !output_one
)
2003 fprintf (stderr
, "Usage:\n\
2004 %s [-e] [-s srcdir -d destdir] [-n count] [-i idx]\n\
2005 Either -s srcdir -d destdir or -i idx must be used\n", argv
[0]);
2009 if (srcdir
== NULL
&& !output_one
)
2014 const char *s
= srcdir
;
2016 t
= ss
= malloc (strlen (srcdir
) + 1);
2028 for (i
= 0; i
< NTYPES2
; ++i
)
2029 if (base_types
[i
].bitfld
)
2030 bitfld_types
[n_bitfld_types
++] = base_types
[i
];
2031 for (i
= 0; i
< NATYPES2
; ++i
)
2032 if (attrib_types
[i
].bitfld
)
2033 aligned_bitfld_types
[n_aligned_bitfld_types
++] = attrib_types
[i
];
2034 for (i
= 0; i
< sizeof (features
) / sizeof (features
[0]); ++i
)
2043 for (j
= 1; j
<= 9; ++j
)
2044 while (idx
< startidx
+ j
* count
)
2045 generate_random_tests (features
[i
].f
, j
);
2046 while (idx
< startidx
+ count
* 10)
2047 generate_random_tests (features
[i
].f
, 10 + (generate_random () % 16));
2049 for (i
= 0; n
> 3000 && i
< sizeof (features
) / sizeof (features
[0]); ++i
)
2055 singles (features
[i
].f
);
2059 while (idx
< startidx
+ 1000)
2060 generate_random_tests (features
[i
].f
, 1);
2066 while (idx
< startidx
+ 100)
2067 generate_random_tests (features
[i
].f
, 1);
2070 for (j
= 2; j
<= 9; ++j
)
2071 while (idx
< startidx
+ (j
- 1) * count
)
2072 generate_random_tests (features
[i
].f
, j
);
2073 while (idx
< startidx
+ count
* 9)
2074 generate_random_tests (features
[i
].f
, 10 + (generate_random () % 16));
2079 generate_random_tests (ALL_FEATURES
, 1 + (generate_random () % 25));