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