1/* Structure layout test generator. 2 Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. 3 Contributed by Jakub Jelinek <jakub@redhat.com>. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along 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 45const char *dg_options[] = { 46"/* { dg-options \"%s-I%s\" } */\n", 47"/* { dg-options \"%s-I%s -Wno-abi\" } */\n", 48"/* { dg-options \"%s-I%s -mno-mmx -Wno-abi\" { target i?86-*-* x86_64-*-* } } */\n", 49"/* { dg-options \"%s-I%s -fno-common\" { target hppa*-*-hpux* powerpc*-*-darwin* } } */\n", 50"/* { dg-options \"%s-I%s -mno-mmx -fno-common -Wno-abi\" { target i?86-*-darwin* x86_64-*-darwin* } } */\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 56typedef unsigned int hashval_t; 57 58enum 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 74struct types 75{ 76 const char *name; 77 enum TYPE type; 78 unsigned long long int maxval; 79 char bitfld; 80}; 81 82struct 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}; 165struct 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}; 196struct 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}; 240struct 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}; 441struct 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}; 528struct 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}; 633struct 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 691struct types bitfld_types[NTYPES2]; 692int n_bitfld_types; 693struct types aligned_bitfld_types[NATYPES2]; 694int n_aligned_bitfld_types; 695 696const 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 720enum 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 731struct 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 748static struct entry *hash_table[HASH_SIZE]; 749 750static int idx, limidx, output_one, short_enums; 751static const char *destdir; 752static const char *srcdir; 753static const char *srcdir_safe; 754FILE *outfile; 755 756void 757switchfiles (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, "/* { dg-prune-output \".*-Wno-abi.*\" } */\n"); 794 fprintf (outfile, "/* { dg-prune-output \".*Offset of packed bit-field.*\" } */\n"); 795 fprintf (outfile, "\ 796#include \"struct-layout-1.h\"\n\ 797\n\ 798#define TX(n, type, attrs, fields, ops) extern void test##n (void);\n\ 799#include \"t%03d_test.h\"\n\ 800#undef TX\n\ 801\n\ 802int main (void)\n\ 803{\n\ 804#define TX(n, type, attrs, fields, ops) test##n ();\n\ 805#include \"t%03d_test.h\"\n\ 806#undef TX\n\ 807 if (fails)\n\ 808 {\n\ 809 fflush (stdout);\n\ 810 abort ();\n\ 811 }\n\ 812 exit (0);\n\ 813}\n", filecnt, filecnt); 814 fclose (outfile); 815 sprintf (destptr, "t%03d_x.c", filecnt); 816 outfile = fopen (destbuf, "w"); 817 if (outfile == NULL) 818 goto fail; 819 for (i = 0; i < NDG_OPTIONS; i++) 820 fprintf (outfile, dg_options[i], "-w ", srcdir_safe); 821 fprintf (outfile, "\ 822#include \"struct-layout-1_x1.h\"\n\ 823#include \"t%03d_test.h\"\n\ 824#include \"struct-layout-1_x2.h\"\n\ 825#include \"t%03d_test.h\"\n", filecnt, filecnt); 826 fclose (outfile); 827 sprintf (destptr, "t%03d_y.c", filecnt); 828 outfile = fopen (destbuf, "w"); 829 if (outfile == NULL) 830 goto fail; 831 for (i = 0; i < NDG_OPTIONS; i++) 832 fprintf (outfile, dg_options[i], "-w ", srcdir_safe); 833 fprintf (outfile, "\ 834#include \"struct-layout-1_y1.h\"\n\ 835#include \"t%03d_test.h\"\n\ 836#include \"struct-layout-1_y2.h\"\n\ 837#include \"t%03d_test.h\"\n", filecnt, filecnt); 838 fclose (outfile); 839 sprintf (destptr, "t%03d_test.h", filecnt); 840 outfile = fopen (destbuf, "w"); 841 if (outfile == NULL) 842 goto fail; 843 if (fields <= 2) 844 limidx = idx + 300; 845 else if (fields <= 4) 846 limidx = idx + 200; 847 else if (fields <= 6) 848 limidx = idx + 100; 849 else 850 limidx = idx + 50; 851} 852 853unsigned long long int 854getrandll (void) 855{ 856 unsigned long long int ret; 857 ret = generate_random () & 0xffffff; 858 ret |= (generate_random () & 0xffffffLL) << 24; 859 ret |= ((unsigned long long int) generate_random ()) << 48; 860 return ret; 861} 862 863int 864subfield (struct entry *e, char *letter) 865{ 866 int i, type; 867 char buf[20]; 868 const char *p; 869 switch (e[0].etype) 870 { 871 case ETYPE_STRUCT: 872 case ETYPE_UNION: 873 case ETYPE_STRUCT_ARRAY: 874 case ETYPE_UNION_ARRAY: 875 type = e[0].attrib ? 1 + (generate_random () & 3) : 0; 876 if (e[0].etype == ETYPE_STRUCT || e[0].etype == ETYPE_STRUCT_ARRAY) 877 p = "struct"; 878 else 879 p = "union"; 880 if (e[0].etype == ETYPE_STRUCT_ARRAY || e[0].etype == ETYPE_UNION_ARRAY) 881 { 882 if (e[0].arr_len == 255) 883 snprintf (buf, 20, "%c[]", *letter); 884 else 885 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len); 886 /* If this is an array type, do not put aligned attributes on 887 elements. Aligning elements to a value greater than their 888 size will result in a compiler error. */ 889 if (type == 1 890 && ((strncmp (e[0].attrib, "atal", 4) == 0) 891 || strncmp (e[0].attrib, "atpaal", 6) == 0)) 892 type = 2; 893 } 894 else 895 { 896 buf[0] = *letter; 897 buf[1] = '\0'; 898 } 899 ++*letter; 900 switch (type) 901 { 902 case 0: 903 case 3: 904 case 4: 905 fprintf (outfile, "%s{", p); 906 break; 907 case 1: 908 fprintf (outfile, "%s %s{", e[0].attrib, p); 909 break; 910 case 2: 911 fprintf (outfile, "%s %s{", p, e[0].attrib); 912 break; 913 } 914 915 for (i = 1; i <= e[0].len; ) 916 i += subfield (e + i, letter); 917 918 switch (type) 919 { 920 case 0: 921 case 1: 922 case 2: 923 fprintf (outfile, "}%s;", buf); 924 break; 925 case 3: 926 fprintf (outfile, "}%s %s;", e[0].attrib, buf); 927 break; 928 case 4: 929 fprintf (outfile, "}%s %s;", buf, e[0].attrib); 930 break; 931 } 932 return 1 + e[0].len; 933 case ETYPE_TYPE: 934 case ETYPE_ARRAY: 935 if (e[0].etype == ETYPE_ARRAY) 936 { 937 if (e[0].arr_len == 255) 938 snprintf (buf, 20, "%c[]", *letter); 939 else 940 snprintf (buf, 20, "%c[%d]", *letter, e[0].arr_len); 941 } 942 else 943 { 944 buf[0] = *letter; 945 buf[1] = '\0'; 946 } 947 ++*letter; 948 if (e[0].attrib) 949 { 950 /* If this is an array type, do not put aligned attributes on 951 elements. Aligning elements to a value greater than their 952 size will result in a compiler error. */ 953 if (e[0].etype == ETYPE_ARRAY 954 && ((strncmp (e[0].attrib, "atal", 4) == 0) 955 || strncmp (e[0].attrib, "atpaal", 6) == 0)) 956 type = 2; 957 else 958 type = generate_random () % 3; 959 switch (type) 960 { 961 case 0: 962 fprintf (outfile, "%s %s %s;", e[0].attrib, e[0].type->name, 963 buf); 964 break; 965 case 1: 966 fprintf (outfile, "%s %s %s;", e[0].type->name, e[0].attrib, 967 buf); 968 break; 969 case 2: 970 fprintf (outfile, "%s %s %s;", e[0].type->name, buf, 971 e[0].attrib); 972 break; 973 } 974 } 975 else 976 fprintf (outfile, "%s %s;", e[0].type->name, buf); 977 return 1; 978 case ETYPE_BITFLD: 979 if (e[0].len == 0) 980 { 981 if (e[0].attrib) 982 switch (generate_random () % 3) 983 { 984 case 0: 985 fprintf (outfile, "%s %s:0;", e[0].attrib, e[0].type->name); 986 break; 987 case 1: 988 fprintf (outfile, "%s %s:0;", e[0].type->name, e[0].attrib); 989 break; 990 case 2: 991 fprintf (outfile, "%s:0 %s;", e[0].type->name, e[0].attrib); 992 break; 993 } 994 else 995 fprintf (outfile, "%s:0;", e[0].type->name); 996 ++*letter; 997 return 1; 998 } 999 switch (e[0].type->bitfld) 1000 { 1001 case 'C': 1002 case 'S': 1003 case 'I': 1004 case 'L': 1005 case 'Q': 1006 snprintf (buf, 20, "B%cN(%d)", e[0].type->bitfld, e[0].len); 1007 break; 1008 case 'B': 1009 case ' ': 1010 snprintf (buf, 20, "%d", e[0].len); 1011 break; 1012 default: 1013 abort (); 1014 } 1015 if (e[0].attrib) 1016 switch (generate_random () % 3) 1017 { 1018 case 0: 1019 fprintf (outfile, "%s %s %c:%s;", e[0].attrib, e[0].type->name, 1020 *letter, buf); 1021 break; 1022 case 1: 1023 fprintf (outfile, "%s %s %c:%s;", e[0].type->name, e[0].attrib, 1024 *letter, buf); 1025 break; 1026 case 2: 1027 fprintf (outfile, "%s %c:%s %s;", e[0].type->name, *letter, 1028 buf, e[0].attrib); 1029 break; 1030 } 1031 else 1032 fprintf (outfile, "%s %c:%s;", e[0].type->name, *letter, buf); 1033 ++*letter; 1034 return 1; 1035 default: 1036 abort (); 1037 } 1038} 1039 1040char namebuf[1024]; 1041 1042void 1043output_FNB (char mode, struct entry *e) 1044{ 1045 unsigned long long int l1, l2, m; 1046 int signs = 0; 1047#ifndef SKIP_DECIMAL_FLOAT 1048 int suffix = 0; 1049 char DEC_SUFFIX[3][3]={"DF","DD","DL"}; 1050#endif 1051 1052 const char *p, *q; 1053 1054 if (e->type->type == TYPE_OTHER) 1055 { 1056 if (mode == 'B') 1057 abort (); 1058 fprintf (outfile, "N(%d,%s)", idx, namebuf); 1059 return; 1060 } 1061 fprintf (outfile, "%c(%d,%s,", mode, idx, namebuf); 1062 l1 = getrandll (); 1063 l2 = getrandll (); 1064 switch (e->type->type) 1065 { 1066 case TYPE_INT: 1067 signs = generate_random () & 3; 1068 m = e->type->maxval; 1069 if (mode == 'B') 1070 m &= e->len > 1 ? (1ULL << (e->len - 1)) - 1 : 1; 1071 l1 &= m; 1072 l2 &= m; 1073 fprintf (outfile, "%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s", 1074 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "", 1075 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : ""); 1076 break; 1077 case TYPE_UINT: 1078 m = e->type->maxval; 1079 if (mode == 'B') 1080 m &= (1ULL << e->len) - 1; 1081 l1 &= m; 1082 l2 &= m; 1083 fprintf (outfile, "%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s", 1084 l1, l1 > 4294967295U ? "LL" : "", 1085 l2, l2 > 4294967295U ? "LL" : ""); 1086 break; 1087 case TYPE_FLOAT: 1088 l1 &= 0xffffff; 1089 l2 &= 0xffffff; 1090 signs = generate_random () & 3; 1091 fprintf (outfile, "%s%f,%s%f", (signs & 1) ? "-" : "", 1092 ((double) l1) / 64, (signs & 2) ? "-" : "", ((double) l2) / 64); 1093 break; 1094#ifndef SKIP_DECIMAL_FLOAT 1095 case TYPE_DEC_FLOAT: 1096 l1 &= 0xffffff; 1097 l2 &= 0xffffff; 1098 signs = generate_random () & 3; 1099 1100 /* Get the suffix of Decimal Floting Points per 1101 e->type->name. Distinguish these three DFP types by 1102 e->type->name. */ 1103 if (strstr(e->type->name, "Decimal32")) suffix=0; 1104 else if (strstr(e->type->name, "Decimal64")) suffix=1; 1105 else if (strstr(e->type->name, "Decimal128")) suffix=2; 1106 else 1107 abort (); 1108 1109 /* Formatted input/output specifiers for DFP types have not been 1110 implemented in GLIBC. %f here used in fprintf is just to 1111 dump the numbers to outfile. */ 1112 fprintf (outfile, "%s%f%s,%s%f%s", 1113 (signs & 1) ? "-" : "", ((double) l1) / 64, DEC_SUFFIX[suffix], 1114 (signs & 2) ? "-" : "", ((double) l2) / 64, DEC_SUFFIX[suffix]); 1115 break; 1116#endif 1117 case TYPE_CINT: 1118 signs = generate_random () & 3; 1119 l1 &= e->type->maxval; 1120 l2 &= e->type->maxval; 1121 fprintf (outfile, 1122 "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s),", 1123 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "", 1124 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : ""); 1125 signs = generate_random () & 3; 1126 l1 = getrandll (); 1127 l2 = getrandll (); 1128 l1 &= e->type->maxval; 1129 l2 &= e->type->maxval; 1130 fprintf (outfile, 1131 "CINT(%s%" COMPAT_PRLL "u%s,%s%" COMPAT_PRLL "u%s)", 1132 (signs & 1) ? "-" : "", l1, l1 > 2147483647 ? "LL" : "", 1133 (signs & 2) ? "-" : "", l2, l2 > 2147483647 ? "LL" : ""); 1134 break; 1135 case TYPE_CUINT: 1136 l1 &= e->type->maxval; 1137 l2 &= e->type->maxval; 1138 fprintf (outfile, 1139 "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s),", 1140 l1, l1 > 4294967295U ? "LL" : "", 1141 l2, l2 > 4294967295U ? "LL" : ""); 1142 l1 = getrandll (); 1143 l2 = getrandll (); 1144 l1 &= e->type->maxval; 1145 l2 &= e->type->maxval; 1146 fprintf (outfile, 1147 "CINT(%" COMPAT_PRLL "uU%s,%" COMPAT_PRLL "uU%s)", 1148 l1, l1 > 4294967295U ? "LL" : "", 1149 l2, l2 > 4294967295U ? "LL" : ""); 1150 break; 1151 case TYPE_CFLOAT: 1152 l1 &= 0xffffff; 1153 l2 &= 0xffffff; 1154 signs = generate_random () & 3; 1155 fprintf (outfile, "CDBL(%s%f,%s%f),", 1156 (signs & 1) ? "-" : "", ((double) l1) / 64, 1157 (signs & 2) ? "-" : "", ((double) l2) / 64); 1158 l1 = getrandll (); 1159 l2 = getrandll (); 1160 l1 &= 0xffffff; 1161 l2 &= 0xffffff; 1162 signs = generate_random () & 3; 1163 fprintf (outfile, "CDBL(%s%f,%s%f)", 1164 (signs & 1) ? "-" : "", ((double) l1) / 64, 1165 (signs & 2) ? "-" : "", ((double) l2) / 64); 1166 break; 1167 case TYPE_UENUM: 1168 if (e->type->maxval == 0) 1169 fputs ("e0_0,e0_0", outfile); 1170 else if (e->type->maxval == 1) 1171 fprintf (outfile, "e1_%" COMPAT_PRLL "d,e1_%" COMPAT_PRLL "d", 1172 l1 & 1, l2 & 1); 1173 else 1174 { 1175 p = strchr (e->type->name, '\0'); 1176 while (--p >= e->type->name && *p >= '0' && *p <= '9'); 1177 p++; 1178 l1 %= 7; 1179 l2 %= 7; 1180 if (l1 > 3) 1181 l1 += e->type->maxval - 6; 1182 if (l2 > 3) 1183 l2 += e->type->maxval - 6; 1184 fprintf (outfile, "e%s_%" COMPAT_PRLL "d,e%s_%" COMPAT_PRLL "d", 1185 p, l1, p, l2); 1186 } 1187 break; 1188 case TYPE_SENUM: 1189 p = strchr (e->type->name, '\0'); 1190 while (--p >= e->type->name && *p >= '0' && *p <= '9'); 1191 p++; 1192 l1 %= 7; 1193 l2 %= 7; 1194 fprintf (outfile, "e%s_%s%" COMPAT_PRLL "d,e%s_%s%" COMPAT_PRLL "d", 1195 p, l1 < 3 ? "m" : "", 1196 l1 == 3 ? 0LL : e->type->maxval - (l1 & 3), 1197 p, l2 < 3 ? "m" : "", 1198 l2 == 3 ? 0LL : e->type->maxval - (l2 & 3)); 1199 break; 1200 case TYPE_PTR: 1201 l1 %= 256; 1202 l2 %= 256; 1203 fprintf (outfile, 1204 "(%s)&intarray[%" COMPAT_PRLL "d], (%s)&intarray[%" COMPAT_PRLL "d]", 1205 e->type->name, l1, e->type->name, l2); 1206 break; 1207 case TYPE_FNPTR: 1208 l1 %= 10; 1209 l2 %= 10; 1210 fprintf (outfile, "fn%" COMPAT_PRLL "d,fn%" COMPAT_PRLL "d", l1, l2); 1211 break; 1212 default: 1213 abort (); 1214 } 1215 fputs (")", outfile); 1216} 1217 1218int 1219subvalues (struct entry *e, char *p, char *letter) 1220{ 1221 int i, j; 1222 char *q; 1223 if (p >= namebuf + sizeof (namebuf) - 32) 1224 abort (); 1225 p[0] = *letter; 1226 p[1] = '\0'; 1227 q = p + 1; 1228 switch (e[0].etype) 1229 { 1230 case ETYPE_STRUCT_ARRAY: 1231 case ETYPE_UNION_ARRAY: 1232 if (e[0].arr_len == 0 || e[0].arr_len == 255) 1233 { 1234 *letter += 1 + e[0].len; 1235 return 1 + e[0].len; 1236 } 1237 i = generate_random () % e[0].arr_len; 1238 snprintf (p, sizeof (namebuf) - (p - namebuf) - 1, 1239 "%c[%d]", *letter, i); 1240 q = strchr (p, '\0'); 1241 /* FALLTHROUGH */ 1242 case ETYPE_STRUCT: 1243 case ETYPE_UNION: 1244 *q++ = '.'; 1245 ++*letter; 1246 for (i = 1; i <= e[0].len; ) 1247 { 1248 i += subvalues (e + i, q, letter); 1249 if (e[0].etype == ETYPE_UNION || e[0].etype == ETYPE_UNION_ARRAY) 1250 { 1251 *letter += e[0].len - i + 1; 1252 break; 1253 } 1254 } 1255 return 1 + e[0].len; 1256 case ETYPE_TYPE: 1257 ++*letter; 1258 output_FNB ('F', e); 1259 return 1; 1260 case ETYPE_ARRAY: 1261 if (e[0].arr_len == 0 || e[0].arr_len == 255) 1262 { 1263 ++*letter; 1264 return 1; 1265 } 1266 i = generate_random () % e[0].arr_len; 1267 snprintf (p, sizeof (namebuf) - (p - namebuf), 1268 "%c[%d]", *letter, i); 1269 output_FNB ('F', e); 1270 if ((generate_random () & 7) == 0) 1271 { 1272 j = generate_random () % e[0].arr_len; 1273 if (i != j) 1274 { 1275 snprintf (p, sizeof (namebuf) - (p - namebuf), 1276 "%c[%d]", *letter, j); 1277 output_FNB ('F', e); 1278 } 1279 } 1280 ++*letter; 1281 return 1; 1282 case ETYPE_BITFLD: 1283 ++*letter; 1284 if (e[0].len != 0) 1285 output_FNB ('B', e); 1286 return 1; 1287 } 1288} 1289 1290/* DERIVED FROM: 1291-------------------------------------------------------------------- 1292lookup2.c, by Bob Jenkins, December 1996, Public Domain. 1293hash(), hash2(), hash3, and mix() are externally useful functions. 1294Routines to test the hash are included if SELF_TEST is defined. 1295You can use this free for any purpose. It has no warranty. 1296-------------------------------------------------------------------- 1297*/ 1298 1299/* 1300-------------------------------------------------------------------- 1301mix -- mix 3 32-bit values reversibly. 1302For every delta with one or two bit set, and the deltas of all three 1303 high bits or all three low bits, whether the original value of a,b,c 1304 is almost all zero or is uniformly distributed, 1305* If mix() is run forward or backward, at least 32 bits in a,b,c 1306 have at least 1/4 probability of changing. 1307* If mix() is run forward, every bit of c will change between 1/3 and 1308 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.) 1309mix() was built out of 36 single-cycle latency instructions in a 1310 structure that could supported 2x parallelism, like so: 1311 a -= b; 1312 a -= c; x = (c>>13); 1313 b -= c; a ^= x; 1314 b -= a; x = (a<<8); 1315 c -= a; b ^= x; 1316 c -= b; x = (b>>13); 1317 ... 1318 Unfortunately, superscalar Pentiums and Sparcs can't take advantage 1319 of that parallelism. They've also turned some of those single-cycle 1320 latency instructions into multi-cycle latency instructions. Still, 1321 this is the fastest good hash I could find. There were about 2^^68 1322 to choose from. I only looked at a billion or so. 1323-------------------------------------------------------------------- 1324*/ 1325/* same, but slower, works on systems that might have 8 byte hashval_t's */ 1326#define mix(a,b,c) \ 1327{ \ 1328 a -= b; a -= c; a ^= (c>>13); \ 1329 b -= c; b -= a; b ^= (a<< 8); \ 1330 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \ 1331 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \ 1332 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \ 1333 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \ 1334 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \ 1335 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \ 1336 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \ 1337} 1338 1339/* 1340-------------------------------------------------------------------- 1341hash() -- hash a variable-length key into a 32-bit value 1342 k : the key (the unaligned variable-length array of bytes) 1343 len : the length of the key, counting by bytes 1344 level : can be any 4-byte value 1345Returns a 32-bit value. Every bit of the key affects every bit of 1346the return value. Every 1-bit and 2-bit delta achieves avalanche. 1347About 36+6len instructions. 1348 1349The best hash table sizes are powers of 2. There is no need to do 1350mod a prime (mod is sooo slow!). If you need less than 32 bits, 1351use a bitmask. For example, if you need only 10 bits, do 1352 h = (h & hashmask(10)); 1353In which case, the hash table should have hashsize(10) elements. 1354 1355If you are hashing n strings (ub1 **)k, do it like this: 1356 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h); 1357 1358By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this 1359code any way you wish, private, educational, or commercial. It's free. 1360 1361See http://burtleburtle.net/bob/hash/evahash.html 1362Use for hash table lookup, or anything where one collision in 2^32 is 1363acceptable. Do NOT use for cryptographic purposes. 1364-------------------------------------------------------------------- 1365*/ 1366 1367static hashval_t 1368iterative_hash (const void *k_in /* the key */, 1369 register size_t length /* the length of the key */, 1370 register hashval_t initval /* the previous hash, or 1371 an arbitrary value */) 1372{ 1373 register const unsigned char *k = (const unsigned char *)k_in; 1374 register hashval_t a,b,c,len; 1375 1376 /* Set up the internal state */ 1377 len = length; 1378 a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */ 1379 c = initval; /* the previous hash value */ 1380 1381 /*---------------------------------------- handle most of the key */ 1382 while (len >= 12) 1383 { 1384 a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24)); 1385 b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24)); 1386 c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24)); 1387 mix(a,b,c); 1388 k += 12; len -= 12; 1389 } 1390 1391 /*------------------------------------- handle the last 11 bytes */ 1392 c += length; 1393 switch(len) /* all the case statements fall through */ 1394 { 1395 case 11: c+=((hashval_t)k[10]<<24); 1396 case 10: c+=((hashval_t)k[9]<<16); 1397 case 9 : c+=((hashval_t)k[8]<<8); 1398 /* the first byte of c is reserved for the length */ 1399 case 8 : b+=((hashval_t)k[7]<<24); 1400 case 7 : b+=((hashval_t)k[6]<<16); 1401 case 6 : b+=((hashval_t)k[5]<<8); 1402 case 5 : b+=k[4]; 1403 case 4 : a+=((hashval_t)k[3]<<24); 1404 case 3 : a+=((hashval_t)k[2]<<16); 1405 case 2 : a+=((hashval_t)k[1]<<8); 1406 case 1 : a+=k[0]; 1407 /* case 0: nothing left to add */ 1408 } 1409 mix(a,b,c); 1410 /*-------------------------------------------- report the result */ 1411 return c; 1412} 1413 1414hashval_t 1415e_hash (const void *a) 1416{ 1417 const struct entry *e = a; 1418 hashval_t ret = 0; 1419 int i; 1420 1421 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION) 1422 abort (); 1423 for (i = 0; i <= e[0].len; ++i) 1424 { 1425 int attriblen; 1426 ret = iterative_hash (&e[i], offsetof (struct entry, attrib), ret); 1427 attriblen = e[i].attrib ? strlen (e[i].attrib) : -1; 1428 ret = iterative_hash (&attriblen, sizeof (int), ret); 1429 if (e[i].attrib) 1430 ret = iterative_hash (e[i].attrib, attriblen, ret); 1431 } 1432 return ret; 1433} 1434 1435int 1436e_eq (const void *a, const void *b) 1437{ 1438 const struct entry *ea = a, *eb = b; 1439 int i; 1440 if (ea[0].etype != ETYPE_STRUCT && ea[0].etype != ETYPE_UNION) 1441 abort (); 1442 if (ea[0].len != eb[0].len) 1443 return 0; 1444 for (i = 0; i <= ea[0].len; ++i) 1445 { 1446 if (ea[i].etype != eb[i].etype 1447 || ea[i].len != eb[i].len 1448 || ea[i].arr_len != eb[i].arr_len 1449 || ea[i].type != eb[i].type) 1450 return 0; 1451 if ((ea[i].attrib == NULL) ^ (eb[i].attrib == NULL)) 1452 return 0; 1453 if (ea[i].attrib && strcmp (ea[i].attrib, eb[i].attrib) != 0) 1454 return 0; 1455 } 1456 return 1; 1457} 1458 1459static int 1460e_exists (const struct entry *e) 1461{ 1462 struct entry *h; 1463 hashval_t hval; 1464 1465 hval = e_hash (e); 1466 for (h = hash_table[hval % HASH_SIZE]; h; h = h->next) 1467 if (e_eq (e, h)) 1468 return 1; 1469 return 0; 1470} 1471 1472static void 1473e_insert (struct entry *e) 1474{ 1475 hashval_t hval; 1476 1477 hval = e_hash (e); 1478 e->next = hash_table[hval % HASH_SIZE]; 1479 hash_table[hval % HASH_SIZE] = e; 1480} 1481 1482void 1483output (struct entry *e) 1484{ 1485 int i; 1486 char c; 1487 struct entry *n; 1488 const char *skip_cint = ""; 1489 1490 if (e[0].etype != ETYPE_STRUCT && e[0].etype != ETYPE_UNION) 1491 abort (); 1492 1493 if (e_exists (e)) 1494 return; 1495 1496 n = (struct entry *) malloc ((e[0].len + 1) * sizeof (struct entry)); 1497 memcpy (n, e, (e[0].len + 1) * sizeof (struct entry)); 1498 e_insert (n); 1499 1500 if (idx == limidx) 1501 switchfiles (e[0].len); 1502 1503 for (i = 1; i <= e[0].len; ++i) 1504 if ((e[i].etype == ETYPE_TYPE || e[i].etype == ETYPE_ARRAY) 1505 && (e[i].type->type == TYPE_CINT || e[i].type->type == TYPE_CUINT)) 1506 break; 1507 if (i <= e[0].len) 1508 skip_cint = "CI"; 1509 if (e[0].attrib) 1510 fprintf (outfile, (generate_random () & 1) 1511 ? "TX%s(%d,%s %s,," : "TX%s(%d,%s,%s,", skip_cint, 1512 idx, e[0].etype == ETYPE_STRUCT ? "struct" : "union", 1513 e[0].attrib); 1514 else if (e[0].etype == ETYPE_STRUCT) 1515 fprintf (outfile, "T%s(%d,", skip_cint, idx); 1516 else 1517 fprintf (outfile, "U%s(%d,", skip_cint, idx); 1518 c = 'a'; 1519 for (i = 1; i <= e[0].len; ) 1520 i += subfield (e + i, &c); 1521 fputs (",", outfile); 1522 c = 'a'; 1523 for (i = 1; i <= e[0].len; ) 1524 { 1525 i += subvalues (e + i, namebuf, &c); 1526 if (e[0].etype == ETYPE_UNION) 1527 break; 1528 } 1529 fputs (")\n", outfile); 1530 if (output_one && idx == limidx) 1531 exit (0); 1532 ++idx; 1533} 1534 1535enum FEATURE 1536{ 1537 FEATURE_VECTOR = 1, 1538 FEATURE_COMPLEX = 2, 1539 FEATURE_ALIGNEDPACKED = 4, 1540 FEATURE_ZEROARRAY = 8, 1541 FEATURE_ZEROBITFLD = 16, 1542 ALL_FEATURES = FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY 1543 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD 1544}; 1545 1546void 1547singles (enum FEATURE features) 1548{ 1549 struct entry e[2]; 1550 int i; 1551 memset (e, 0, sizeof (e)); 1552 e[0].etype = ETYPE_STRUCT; 1553 output (e); 1554 e[0].etype = ETYPE_UNION; 1555 output (e); 1556 for (i = 0; 1557 i < ((features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1); 1558 ++i) 1559 { 1560 e[0].attrib = attributes[i]; 1561 e[0].etype = ETYPE_STRUCT; 1562 output (e); 1563 e[0].etype = ETYPE_UNION; 1564 output (e); 1565 } 1566 e[0].len = 1; 1567 e[0].attrib = NULL; 1568 for (i = 0; i < NTYPES2; ++i) 1569 { 1570 e[0].etype = ETYPE_STRUCT; 1571 e[1].etype = ETYPE_TYPE; 1572 e[1].type = &base_types[i]; 1573 output (e); 1574 e[0].etype = ETYPE_UNION; 1575 output (e); 1576 } 1577 if (features & FEATURE_COMPLEX) 1578 for (i = 0; i < NCTYPES2; ++i) 1579 { 1580 e[0].etype = ETYPE_STRUCT; 1581 e[1].etype = ETYPE_TYPE; 1582 e[1].type = &complex_types[i]; 1583 output (e); 1584 e[0].etype = ETYPE_UNION; 1585 output (e); 1586 } 1587 if (features & FEATURE_VECTOR) 1588 for (i = 0; i < NVTYPES2; ++i) 1589 { 1590 e[0].etype = ETYPE_STRUCT; 1591 e[1].etype = ETYPE_TYPE; 1592 e[1].type = &vector_types[i]; 1593 output (e); 1594 e[0].etype = ETYPE_UNION; 1595 output (e); 1596 } 1597} 1598 1599void 1600choose_type (enum FEATURE features, struct entry *e, int r, int in_array) 1601{ 1602 int i; 1603 1604 i = NTYPES2 - NTYPES1; 1605 if (features & FEATURE_COMPLEX) 1606 i += NCTYPES2; 1607 if (features & FEATURE_VECTOR) 1608 i += NVTYPES2; 1609 if ((r & 3) == 0) 1610 { 1611 if (in_array) 1612 { 1613 i += NAATYPES2; 1614 if (features & FEATURE_COMPLEX) 1615 i += NCAATYPES2; 1616 } 1617 else 1618 { 1619 i += NATYPES2; 1620 if (features & FEATURE_COMPLEX) 1621 i += NCATYPES2; 1622 } 1623 } 1624 r >>= 2; 1625 r %= i; 1626 if (r < NTYPES2 - NTYPES1) 1627 e->type = &base_types[r + NTYPES1]; 1628 r -= NTYPES2 - NTYPES1; 1629 if (e->type == NULL && (features & FEATURE_COMPLEX)) 1630 { 1631 if (r < NCTYPES2) 1632 e->type = &complex_types[r]; 1633 r -= NCTYPES2; 1634 } 1635 if (e->type == NULL && (features & FEATURE_VECTOR)) 1636 { 1637 if (r < NVTYPES2) 1638 e->type = &vector_types[r]; 1639 r -= NVTYPES2; 1640 } 1641 if (e->type == NULL && !in_array) 1642 { 1643 if (r < NATYPES2) 1644 e->type = &attrib_types[r]; 1645 r -= NATYPES2; 1646 } 1647 if (e->type == NULL && !in_array && (features & FEATURE_COMPLEX)) 1648 { 1649 if (r < NCATYPES2) 1650 e->type = &complex_attrib_types[r]; 1651 r -= NCATYPES2; 1652 } 1653 if (e->type == NULL && in_array) 1654 { 1655 if (r < NAATYPES2) 1656 e->type = &attrib_array_types[r]; 1657 r -= NAATYPES2; 1658 } 1659 if (e->type == NULL && in_array && (features & FEATURE_COMPLEX)) 1660 { 1661 if (r < NCAATYPES2) 1662 e->type = &complex_attrib_array_types[r]; 1663 r -= NCAATYPES2; 1664 } 1665 if (e->type == NULL) 1666 abort (); 1667} 1668 1669/* This is from gcc.c-torture/execute/builtin-bitops-1.c. */ 1670static int 1671my_ffsll (unsigned long long x) 1672{ 1673 int i; 1674 if (x == 0) 1675 return 0; 1676 /* We've tested LLONG_MAX for 64 bits so this should be safe. */ 1677 for (i = 0; i < 64; i++) 1678 if (x & (1ULL << i)) 1679 break; 1680 return i + 1; 1681} 1682 1683void 1684generate_fields (enum FEATURE features, struct entry *e, struct entry *parent, 1685 int len) 1686{ 1687 int r, i, j, ret = 1, n, incr, sametype; 1688 1689 for (n = 0; n < len; n += incr) 1690 { 1691 r = generate_random (); 1692 /* 50% ETYPE_TYPE base_types NTYPES1 1693 12.5% ETYPE_TYPE other 1694 12.5% ETYPE_ARRAY 1695 12.5% ETYPE_BITFLD 1696 12.5% ETYPE_STRUCT|ETYPE_UNION|ETYPE_STRUCT_ARRAY|ETYPE_UNION_ARRAY */ 1697 i = (r & 7); 1698 r >>= 3; 1699 incr = 1; 1700 switch (i) 1701 { 1702 case 0: 1703 case 1: 1704 case 2: 1705 case 3: 1706 e[n].etype = ETYPE_TYPE; 1707 e[n].type = &base_types[r % NTYPES1]; 1708 break; 1709 case 4: 1710 e[n].etype = ETYPE_TYPE; 1711 choose_type (features, &e[n], r, 0); 1712 break; 1713 case 5: 1714 e[n].etype = ETYPE_ARRAY; 1715 i = r & 1; 1716 r >>= 1; 1717 if (i) 1718 e[n].type = &base_types[r % NTYPES1]; 1719 else 1720 choose_type (features, &e[n], r, 1); 1721 r = generate_random (); 1722 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0) 1723 { 1724 e[n].arr_len = 0; 1725 if (n == len - 1 && (r & 4) 1726 && (parent->etype == ETYPE_STRUCT 1727 || parent->etype == ETYPE_STRUCT_ARRAY)) 1728 { 1729 int k; 1730 for (k = 0; k < n; ++k) 1731 if (e[k].etype != ETYPE_BITFLD || e[k].len) 1732 { 1733 e[n].arr_len = 255; 1734 break; 1735 } 1736 } 1737 } 1738 else if ((r & 3) != 3) 1739 e[n].arr_len = (r >> 2) & 7; 1740 else 1741 e[n].arr_len = (r >> 2) & 31; 1742 break; 1743 case 6: 1744 sametype = 1; 1745 switch (r & 7) 1746 { 1747 case 0: 1748 case 1: 1749 case 2: 1750 break; 1751 case 3: 1752 case 4: 1753 case 5: 1754 incr = 1 + (r >> 3) % (len - n); 1755 break; 1756 case 6: 1757 case 7: 1758 sametype = 0; 1759 incr = 1 + (r >> 3) % (len - n); 1760 break; 1761 } 1762 for (j = n; j < n + incr; ++j) 1763 { 1764 int mi, ma; 1765 1766 e[j].etype = ETYPE_BITFLD; 1767 if (j == n || !sametype) 1768 { 1769 int k; 1770 r = generate_random (); 1771 k = r & 3; 1772 r >>= 2; 1773 if (!k) 1774 e[j].type 1775 = &aligned_bitfld_types[r % n_aligned_bitfld_types]; 1776 else 1777 e[j].type 1778 = &bitfld_types[r % n_bitfld_types]; 1779 } 1780 else 1781 e[j].type = e[n].type; 1782 r = generate_random (); 1783 mi = 0; 1784 ma = 0; 1785 switch (e[j].type->bitfld) 1786 { 1787 case 'C': ma = 8; break; 1788 case 'S': ma = 16; break; 1789 case 'I': ma = 32; break; 1790 case 'L': 1791 case 'Q': ma = 64; break; 1792 case 'B': ma = 1; break; 1793 case ' ': 1794 if (e[j].type->type == TYPE_UENUM) 1795 mi = my_ffsll (e[j].type->maxval + 1) - 1; 1796 else if (e[j].type->type == TYPE_SENUM) 1797 mi = my_ffsll (e[j].type->maxval + 1); 1798 else 1799 abort (); 1800 if (!mi) 1801 mi = 1; 1802 if (mi > 32) 1803 ma = 64; 1804 else if (mi > 16 || !short_enums) 1805 ma = 32; 1806 else if (mi > 8) 1807 ma = 16; 1808 else 1809 ma = 8; 1810 break; 1811 default: 1812 abort (); 1813 } 1814 e[j].len = ma + 1; 1815 if (sametype && (r & 3) == 0 && ma > 1) 1816 { 1817 int sum = 0, k; 1818 for (k = n; k < j; ++k) 1819 sum += e[k].len; 1820 sum %= ma; 1821 e[j].len = sum ? ma - sum : ma; 1822 } 1823 r >>= 2; 1824 if (! (features & FEATURE_ZEROBITFLD) && mi == 0) 1825 mi = 1; 1826 if (e[j].len < mi || e[j].len > ma) 1827 e[j].len = mi + (r % (ma + 1 - mi)); 1828 r >>= 6; 1829 if ((features & FEATURE_ZEROBITFLD) && (r & 3) == 0 1830 && mi == 0) 1831 e[j].len = 0; 1832 } 1833 break; 1834 case 7: 1835 switch (r & 7) 1836 { 1837 case 0: 1838 case 1: 1839 case 2: 1840 e[n].etype = ETYPE_STRUCT; 1841 break; 1842 case 3: 1843 case 4: 1844 e[n].etype = ETYPE_UNION; 1845 break; 1846 case 5: 1847 case 6: 1848 e[n].etype = ETYPE_STRUCT_ARRAY; 1849 break; 1850 case 7: 1851 e[n].etype = ETYPE_UNION_ARRAY; 1852 break; 1853 } 1854 r >>= 3; 1855 e[n].len = r % (len - n); 1856 incr = 1 + e[n].len; 1857 generate_fields (features, &e[n + 1], &e[n], e[n].len); 1858 if (e[n].etype == ETYPE_STRUCT_ARRAY 1859 || e[n].etype == ETYPE_UNION_ARRAY) 1860 { 1861 r = generate_random (); 1862 if ((features & FEATURE_ZEROARRAY) && (r & 3) == 0) 1863 { 1864 e[n].arr_len = 0; 1865 if (n + incr == len && (r & 4) 1866 && (parent->etype == ETYPE_STRUCT 1867 || parent->etype == ETYPE_STRUCT_ARRAY)) 1868 { 1869 int k; 1870 for (k = 0; k < n; ++k) 1871 if (e[k].etype != ETYPE_BITFLD || e[k].len) 1872 { 1873 e[n].arr_len = 255; 1874 break; 1875 } 1876 } 1877 } 1878 else if ((r & 3) != 3) 1879 e[n].arr_len = (r >> 2) & 7; 1880 else 1881 e[n].arr_len = (r >> 2) & 31; 1882 } 1883 break; 1884 } 1885 r = generate_random (); 1886 if ((r & 7) == 0) 1887 { 1888 r >>= 3; 1889 i = (features & FEATURE_ALIGNEDPACKED) ? NATTRIBS2 : NATTRIBS1; 1890 e[n].attrib = attributes[r % i]; 1891 if (! (features & FEATURE_ALIGNEDPACKED) 1892 && strcmp (e[n].attrib, "atpa") == 0 1893 && ((e[n].type >= &attrib_types[0] 1894 && e[n].type < &attrib_types[NATYPES2]) 1895 || (e[n].type >= &complex_attrib_types[0] 1896 && e[n].type < &complex_attrib_types[NCATYPES2]) 1897 || (e[n].type >= &attrib_array_types[0] 1898 && e[n].type < &attrib_array_types[NAATYPES2]) 1899 || (e[n].type >= &complex_attrib_array_types[0] 1900 && e[n].type < &complex_attrib_array_types[NAATYPES2]) 1901 || (e[n].type >= &aligned_bitfld_types[0] 1902 && e[n].type < &aligned_bitfld_types[n_aligned_bitfld_types]))) 1903 e[n].attrib = NULL; 1904 } 1905 } 1906} 1907 1908void 1909generate_random_tests (enum FEATURE features, int len) 1910{ 1911 struct entry e[len + 1]; 1912 int i, r; 1913 if (len > 'z' - 'a' + 1) 1914 abort (); 1915 memset (e, 0, sizeof (e)); 1916 r = generate_random (); 1917 if ((r & 7) == 0) 1918 e[0].etype = ETYPE_UNION; 1919 else 1920 e[0].etype = ETYPE_STRUCT; 1921 r >>= 3; 1922 e[0].len = len; 1923 if ((r & 31) == 0) 1924 { 1925 r >>= 5; 1926 if (features & FEATURE_ALIGNEDPACKED) 1927 r %= NATTRIBS2; 1928 else 1929 r %= NATTRIBS1; 1930 e[0].attrib = attributes[r]; 1931 } 1932 generate_fields (features, &e[1], &e[0], len); 1933 output (e); 1934} 1935 1936struct { const char *name; enum FEATURE f; } 1937features[] = { 1938{ "normal", 0 }, 1939{ "complex", FEATURE_COMPLEX }, 1940{ "vector", FEATURE_VECTOR }, 1941{ "[0] :0", FEATURE_ZEROARRAY | FEATURE_ZEROBITFLD }, 1942{ "complex vector [0]", 1943 FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY }, 1944{ "aligned packed complex vector [0] :0", 1945 FEATURE_COMPLEX | FEATURE_VECTOR | FEATURE_ZEROARRAY 1946 | FEATURE_ALIGNEDPACKED | FEATURE_ZEROBITFLD }, 1947}; 1948 1949int 1950main (int argc, char **argv) 1951{ 1952 int i, j, count, c, n = 3000; 1953 char *optarg; 1954 1955 if (sizeof (int) != 4 || sizeof (long long) != 8) 1956 return 1; 1957 1958 i = 1; 1959 while (i < argc) 1960 { 1961 c = '\0'; 1962 if (argv[i][0] == '-' && argv[i][2] == '\0') 1963 c = argv[i][1]; 1964 optarg = argv[i + 1]; 1965 if (!optarg) 1966 goto usage; 1967 switch (c) 1968 { 1969 case 'n': 1970 n = atoi (optarg); 1971 break; 1972 case 'd': 1973 destdir = optarg; 1974 break; 1975 case 's': 1976 srcdir = optarg; 1977 break; 1978 case 'i': 1979 output_one = 1; 1980 limidx = atoi (optarg); 1981 break; 1982 case 'e': 1983 short_enums = 1; 1984 i--; 1985 break; 1986 default: 1987 fprintf (stderr, "unrecognized option %s\n", argv[i]); 1988 goto usage; 1989 } 1990 i += 2; 1991 } 1992 1993 if (output_one) 1994 { 1995 outfile = fopen ("/dev/null", "w"); 1996 if (outfile == NULL) 1997 { 1998 fputs ("could not open /dev/null", stderr); 1999 return 1; 2000 } 2001 n = limidx + 1; 2002 } 2003 2004 if (destdir == NULL && !output_one) 2005 { 2006 usage: 2007 fprintf (stderr, "Usage:\n\ 2008%s [-e] [-s srcdir -d destdir] [-n count] [-i idx]\n\ 2009Either -s srcdir -d destdir or -i idx must be used\n", argv[0]); 2010 return 1; 2011 } 2012 2013 if (srcdir == NULL && !output_one) 2014 goto usage; 2015 2016 if (srcdir != NULL) 2017 { 2018 const char *s = srcdir; 2019 char *ss, *t; 2020 t = ss = malloc (strlen (srcdir) + 1); 2021 if (!ss) 2022 abort (); 2023 do { 2024 if (*s == '\\') 2025 *t++ = '/'; 2026 else 2027 *t++ = *s; 2028 } while (*s++); 2029 srcdir_safe = ss; 2030 } 2031 2032 for (i = 0; i < NTYPES2; ++i) 2033 if (base_types[i].bitfld) 2034 bitfld_types[n_bitfld_types++] = base_types[i]; 2035 for (i = 0; i < NATYPES2; ++i) 2036 if (attrib_types[i].bitfld) 2037 aligned_bitfld_types[n_aligned_bitfld_types++] = attrib_types[i]; 2038 for (i = 0; i < sizeof (features) / sizeof (features[0]); ++i) 2039 { 2040 int startidx = idx; 2041 if (! output_one) 2042 limidx = idx; 2043 if (!i) 2044 count = 200; 2045 else 2046 count = 20; 2047 for (j = 1; j <= 9; ++j) 2048 while (idx < startidx + j * count) 2049 generate_random_tests (features[i].f, j); 2050 while (idx < startidx + count * 10) 2051 generate_random_tests (features[i].f, 10 + (generate_random () % 16)); 2052 } 2053 for (i = 0; n > 3000 && i < sizeof (features) / sizeof (features[0]); ++i) 2054 { 2055 int startidx; 2056 startidx = idx; 2057 if (! output_one) 2058 limidx = idx; 2059 singles (features[i].f); 2060 if (!i) 2061 { 2062 count = 1000; 2063 while (idx < startidx + 1000) 2064 generate_random_tests (features[i].f, 1); 2065 } 2066 else 2067 { 2068 startidx = idx; 2069 count = 100; 2070 while (idx < startidx + 100) 2071 generate_random_tests (features[i].f, 1); 2072 } 2073 startidx = idx; 2074 for (j = 2; j <= 9; ++j) 2075 while (idx < startidx + (j - 1) * count) 2076 generate_random_tests (features[i].f, j); 2077 while (idx < startidx + count * 9) 2078 generate_random_tests (features[i].f, 10 + (generate_random () % 16)); 2079 } 2080 if (! output_one) 2081 limidx = idx; 2082 while (idx < n) 2083 generate_random_tests (ALL_FEATURES, 1 + (generate_random () % 25)); 2084 fclose (outfile); 2085 return 0; 2086} 2087