gcc/testsuite/gcc.dg/compat/struct-layout-1_generate.c

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