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

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