This change updates the gcc.c-torture/execute/ to avoid obsolete
language constructs. In the changed tests, use of the features
appears to be accidental, and updating allows the tests run with
the default compiler flags.
gcc/testsuite/
* gcc.c-torture/execute/
20000112-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/
20000113-1.c (foobar): Add missing
void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/
20000314-2.c (main): Likewise.
* gcc.c-torture/execute/
20000402-1.c (main): Likewise.
* gcc.c-torture/execute/
20000403-1.c (main): Likewise.
* gcc.c-torture/execute/
20000503-1.c (main): Likewise.
* gcc.c-torture/execute/
20000605-2.c (main): Likewise.
* gcc.c-torture/execute/
20000717-1.c (main): Likewise.
* gcc.c-torture/execute/
20000717-5.c (main): Likewise.
* gcc.c-torture/execute/
20000726-1.c (main): Likewise.
* gcc.c-torture/execute/
20000914-1.c(blah): Add missing
void types.
(main): Add missing int and void types.
* gcc.c-torture/execute/
20001009-1.c (main): Likewise.
* gcc.c-torture/execute/
20001013-1.c (main): Likewise.
* gcc.c-torture/execute/
20001031-1.c (main): Likewise.
* gcc.c-torture/execute/
20010221-1.c (main): Likewise.
* gcc.c-torture/execute/
20010723-1.c (main): Likewise.
* gcc.c-torture/execute/
20010915-1.c (s): Call
__builtin_strcmp instead of strcmp.
* gcc.c-torture/execute/
20010924-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/
20011128-1.c (main): Likewise.
* gcc.c-torture/execute/
20020226-1.c (main): Likewise.
* gcc.c-torture/execute/
20020328-1.c (foo): Add missing
void types.
* gcc.c-torture/execute/
20020406-1.c (DUPFFexgcd): Call
__builtin_printf instead of printf.
(main): Likewise.
* gcc.c-torture/execute/
20020508-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/
20020508-2.c (main): Likewise.
* gcc.c-torture/execute/
20020508-3.c (main): Likewise.
* gcc.c-torture/execute/
20020611-1.c (main): Likewise.
* gcc.c-torture/execute/
20021010-2.c (main): Likewise.
* gcc.c-torture/execute/
20021113-1.c (foo): Add missing
void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/
20021120-3.c (foo): Call
__builtin_sprintf instead of sprintf.
* gcc.c-torture/execute/
20030125-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/
20030216-1.c (main): Likewise.
* gcc.c-torture/execute/
20030404-1.c (main): Likewise.
* gcc.c-torture/execute/
20030606-1.c (main): Likewise.
Call __builtin_memset instead of memset.
* gcc.c-torture/execute/
20030828-1.c (main): Add missing int
and void types.
* gcc.c-torture/execute/
20030828-2.c (main): Likewise.
* gcc.c-torture/execute/
20031012-1.c: Call __builtin_strlen
instead of strlen.
* gcc.c-torture/execute/
20031211-1.c (main): Add missing int
and void types.
* gcc.c-torture/execute/
20040319-1.c (main): Likewise.
* gcc.c-torture/execute/
20040411-1.c (sub1): Call
__builtin_memcpy instead of memcpy.
* gcc.c-torture/execute/
20040423-1.c (sub1): Likewise.
* gcc.c-torture/execute/
20040917-1.c (main): Add missing int
and void types.
* gcc.c-torture/execute/
20050131-1.c (main): Likewise.
* gcc.c-torture/execute/
20051113-1.c (main): Likewise.
* gcc.c-torture/execute/
20121108-1.c (main): Call
__builtin_printf instead of printf.
* gcc.c-torture/execute/
20170401-2.c (main): Add missing int
and void types.
* gcc.c-torture/execute/900409-1.c (main): Likewise.
* gcc.c-torture/execute/920202-1.c (f): Add int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/920302-1.c (execute): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/920410-1.c (main): Likewise.
* gcc.c-torture/execute/920501-2.c (main): Likewise.
* gcc.c-torture/execute/920501-3.c (execute): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/920501-5.c (x): Add int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/920501-6.c (main): Add int return
type.
* gcc.c-torture/execute/920501-8.c (main): Add missing
int and void types. Call __builtin_strcmp instead of strcmp.
* gcc.c-torture/execute/920506-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/920612-2.c (main): Likewise.
* gcc.c-torture/execute/920618-1.c (main): Likewise.
* gcc.c-torture/execute/920625-1.c (main): Likewise.
* gcc.c-torture/execute/920710-1.c (main): Likewise.
* gcc.c-torture/execute/920721-1.c (main): Likewise.
* gcc.c-torture/execute/920721-4.c (main): Likewise.
* gcc.c-torture/execute/920726-1.c (first, second): Call
__builtin_strlen instead of strlen.
(main): Add missing int and void types. Call __builtin_strcmp
instead of strcmp.
* gcc.c-torture/execute/920810-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/920829-1.c (main): Likewise.
* gcc.c-torture/execute/920908-1.c (main): Likewise.
* gcc.c-torture/execute/920922-1.c (main): Likewise.
* gcc.c-torture/execute/920929-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/921006-1.c (main): Likewise. Call
__builtin_strcmp instead of strcmp.
* gcc.c-torture/execute/921007-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/921016-1.c (main): Likewise.
* gcc.c-torture/execute/921019-1.c (main): Likewise.
* gcc.c-torture/execute/921019-2.c (main): Likewise.
* gcc.c-torture/execute/921029-1.c (main): Likewise.
* gcc.c-torture/execute/921104-1.c (main): Likewise.
* gcc.c-torture/execute/921112-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/921113-1.c (w, f1, f2, gitter): Add
void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/921117-1.c (check): Call
__builtin_strcmp instead of strcmp.
(main): Add missing int and void types. Call __builtin_strcpy
instead of strcpy.
* gcc.c-torture/execute/921123-2.c (main): Add missing
int and void types.
* gcc.c-torture/execute/921202-2.c (main): Likewise.
* gcc.c-torture/execute/921204-1.c (main): Likewise.
* gcc.c-torture/execute/921208-1.c (main): Likewise.
* gcc.c-torture/execute/930123-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/930126-1.c (main): Likewise.
* gcc.c-torture/execute/930406-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/930408-1.c (p, f): Add missing void
types.
(main): Add missing int and void types.
* gcc.c-torture/execute/930429-1.c (main): Likewise.
* gcc.c-torture/execute/930603-2.c (f): Add missing void
types.
(main): Add missing int and void types.
* gcc.c-torture/execute/930608-1.c (main): Likewise.
* gcc.c-torture/execute/930614-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/930614-2.c (main): Likewise.
* gcc.c-torture/execute/930622-2.c (main): Likewise.
* gcc.c-torture/execute/930628-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/930725-1.c (main): Likewise. Call
__builtin_strcmp instead of strcmp.
* gcc.c-torture/execute/930930-2.c (main): Add missing
int and void types.
* gcc.c-torture/execute/931002-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-10.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-11.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-12.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-13.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-14.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-2.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-3.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-4.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-5.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-6.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-7.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-8.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931004-9.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/931005-1.c (main): Likewise.
* gcc.c-torture/execute/931110-1.c (main): Likewise.
* gcc.c-torture/execute/931110-2.c (main): Likewise.
* gcc.c-torture/execute/941014-1.c (main): Likewise.
* gcc.c-torture/execute/941014-2.c (main): Likewise.
* gcc.c-torture/execute/941015-1.c (main): Likewise.
* gcc.c-torture/execute/941021-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/941025-1.c (main): Likewise.
* gcc.c-torture/execute/941031-1.c (main): Likewise.
* gcc.c-torture/execute/950221-1.c (g2): Add int return type.
(f): Add missing void types. Call __builtin_strcpy instead
of strcpy.
(main): Add missing int and void types.
* gcc.c-torture/execute/950426-2.c (main): Likewise.
* gcc.c-torture/execute/950503-1.c (main): Likewise.
* gcc.c-torture/execute/950511-1.c (main): Likewise.
* gcc.c-torture/execute/950607-1.c (main): Likewise.
* gcc.c-torture/execute/950607-2.c (main): Likewise.
* gcc.c-torture/execute/950612-1.c (main): Likewise.
* gcc.c-torture/execute/950628-1.c (main): Likewise.
* gcc.c-torture/execute/950704-1.c (main): Likewise.
* gcc.c-torture/execute/950706-1.c (main): Likewise.
* gcc.c-torture/execute/950710-1.c (main): Likewise.
* gcc.c-torture/execute/950714-1.c (main): Likewise.
* gcc.c-torture/execute/950809-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/950906-1.c (g, f): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/950915-1.c (main): Likewise.
* gcc.c-torture/execute/950929-1.c (main): Likewise.
* gcc.c-torture/execute/951003-1.c (f): Add missing int
parameter type.
(main): Add missing int and void types.
* gcc.c-torture/execute/951115-1.c (g, f): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/951204-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/960116-1.c (p): Add int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/960117-1.c (main): Likewise.
* gcc.c-torture/execute/960209-1.c (main): Likewise.
* gcc.c-torture/execute/960215-1.c (main): Likewise.
* gcc.c-torture/execute/960219-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/960301-1.c (main): Likewise.
* gcc.c-torture/execute/960302-1.c (foo, main): Add missing
int and void types.
* gcc.c-torture/execute/960311-1.c (main): Likewise.
* gcc.c-torture/execute/960311-2.c (main): Likewise.
* gcc.c-torture/execute/960311-3.c (main): Likewise.
* gcc.c-torture/execute/960312-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/960317-1.c (main): Likewise.
* gcc.c-torture/execute/960321-1.c (main): Likewise.
* gcc.c-torture/execute/960326-1.c (main): Likewise.
* gcc.c-torture/execute/960327-1.c (g, main): Add missing
int and void types.
(f): Add missing void types.
* gcc.c-torture/execute/960405-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/960416-1.c (main): Likewise.
* gcc.c-torture/execute/960419-1.c (main): Likewise.
* gcc.c-torture/execute/960419-2.c (main): Likewise.
* gcc.c-torture/execute/960512-1.c (main): Likewise.
* gcc.c-torture/execute/960513-1.c (main): Likewise.
* gcc.c-torture/execute/960521-1.c (f): Add missing void
types.
(main): Add missing int and void types.
* gcc.c-torture/execute/960608-1.c (f): Add int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/960801-1.c (main): Likewise.
* gcc.c-torture/execute/960802-1.c (main): Likewise.
* gcc.c-torture/execute/960909-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/961004-1.c (main): Likewise.
* gcc.c-torture/execute/961017-1.c (main): Likewise.
* gcc.c-torture/execute/961017-2.c (main): Likewise.
* gcc.c-torture/execute/961026-1.c (main): Likewise.
* gcc.c-torture/execute/961122-1.c (addhi, subhi): Add void
return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/961122-2.c (main): Likewise.
* gcc.c-torture/execute/961125-1.c (main): Likewise.
* gcc.c-torture/execute/961206-1.c (main): Likewise.
* gcc.c-torture/execute/961213-1.c (main): Likewise.
* gcc.c-torture/execute/970214-1.c (main): Likewise.
* gcc.c-torture/execute/970214-2.c (main): Likewise.
* gcc.c-torture/execute/970217-1.c (sub): Add int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/970923-1.c (main): Likewise.
* gcc.c-torture/execute/980223.c (main): Likewise.
* gcc.c-torture/execute/980506-1.c (main): Likewise.
* gcc.c-torture/execute/980506-2.c (main): Likewise.
* gcc.c-torture/execute/980506-3.c (build_lookup): Call
__builtin_strlen instead of strlen and __builtin_memset
instead of memset.
* gcc.c-torture/execute/980526-3.c (main): Likewise.
* gcc.c-torture/execute/980602-1.c (main): Likewise.
* gcc.c-torture/execute/980604-1.c (main): Likewise.
* gcc.c-torture/execute/980605-1.c (dummy): Add missing int
parameter type.
(main): Add missing int and void types.
* gcc.c-torture/execute/980701-1.c (ns_name_skip): Add missing
int return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/980709-1.c (main): Likewise.
* gcc.c-torture/execute/990117-1.c (main): Likewise.
* gcc.c-torture/execute/990127-1.c (main): Likewise.
* gcc.c-torture/execute/990128-1.c (main): Likewise.
* gcc.c-torture/execute/990130-1.c (main): Likewise.
* gcc.c-torture/execute/990324-1.c (main): Likewise.
* gcc.c-torture/execute/990524-1.c (main): Likewise.
* gcc.c-torture/execute/990531-1.c (main): Likewise.
* gcc.c-torture/execute/990628-1.c (fetch, load_data): Call
__builtin_memset instead of memset.
(main): Add missing int and void types.
* gcc.c-torture/execute/991019-1.c (main): Likewise.
* gcc.c-torture/execute/991023-1.c (foo, main): Likewise.
* gcc.c-torture/execute/991112-1.c (isprint): Declare.
* gcc.c-torture/execute/991118-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/alias-1.c (ptr2): Add cast to float *
in initializer.
(typepun): Add missing void types.
(main): Add missing int and void types.
* gcc.c-torture/execute/alias-2.c (main): Likewise.
* gcc.c-torture/execute/alias-3.c (inc): Add missing
void types.
* gcc.c-torture/execute/alias-4.c (main): Add missing int
return type.
* gcc.c-torture/execute/arith-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/arith-rand-ll.c (main): Likewise.
* gcc.c-torture/execute/arith-rand.c (main): Likewise.
* gcc.c-torture/execute/bf-layout-1.c (main): Likewise.
* gcc.c-torture/execute/bf-pack-1.c (foo): Add missing
void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/bf-sign-1.c (main): Likewise.
* gcc.c-torture/execute/bf-sign-2.c (main): Likewise.
* gcc.c-torture/execute/bf64-1.c (main): Likewise.
* gcc.c-torture/execute/builtin-prefetch-2.c (stat_int_arr):
Add missing int array element type.
* gcc.c-torture/execute/builtin-prefetch-3.c (stat_int_arr):
Likewise.
* gcc.c-torture/execute/cbrt.c (main): Add missing int and
void types.
* gcc.c-torture/execute/complex-1.c (main): Likewise.
* gcc.c-torture/execute/complex-2.c (main): Likewise.
* gcc.c-torture/execute/complex-3.c (main): Likewise.
* gcc.c-torture/execute/complex-4.c (main): Likewise.
* gcc.c-torture/execute/complex-5.c (main): Likewise.
* gcc.c-torture/execute/compndlit-1.c (main): Likewise.
* gcc.c-torture/execute/conversion.c (test_integer_to_float)
(test_longlong_integer_to_float, test_float_to_integer)
(test_float_to_longlong_integer): Add missing void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/cvt-1.c (main): Likewise.
* gcc.c-torture/execute/divconst-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/divconst-2.c (main): Likewise.
* gcc.c-torture/execute/divconst-3.c (main): Likewise.
* gcc.c-torture/execute/enum-1.c (main): Likewise.
* gcc.c-torture/execute/func-ptr-1.c (main): Likewise.
* gcc.c-torture/execute/ieee/
20011123-1.c (main): Likewise.
* gcc.c-torture/execute/ieee/920518-1.c (main): Likewise.
* gcc.c-torture/execute/ieee/920810-1.c (main): Likewise.
Call __builtin_strcmp instead of strcmp.
* gcc.c-torture/execute/ieee/930529-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/ieee/fp-cmp-1.c (main): Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-2.c (main): Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-3.c (main): Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-6.c (main): Likewise.
* gcc.c-torture/execute/ieee/fp-cmp-9.c (main): Likewise.
* gcc.c-torture/execute/ieee/minuszero.c (main): Likewise.
* gcc.c-torture/execute/ieee/mzero2.c (expect): Call
__builtin_memcmp instead of memcmp.
(main): Add missing int and void types.
* gcc.c-torture/execute/ieee/mzero3.c (main): Likewise.
(expectd, expectf): Call __builtin_memcmp instead of memcmp.
* gcc.c-torture/execute/ieee/mzero5.c (negzero_check):
Likewise.
* gcc.c-torture/execute/ieee/rbug.c (main): Add missing
int and void types.
* gcc.c-torture/execute/index-1.c (main): Likewise.
* gcc.c-torture/execute/loop-1.c (main): Likewise.
* gcc.c-torture/execute/loop-2b.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/loop-6.c (main): Likewise.
* gcc.c-torture/execute/loop-7.c (main): Likewise.
* gcc.c-torture/execute/lto-tbaa-1.c (use_a, set_b, use_c):
Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/memcpy-1.c (main): Likewise.
* gcc.c-torture/execute/memcpy-2.c (main): Likewise.
* gcc.c-torture/execute/memcpy-bi.c (main): Likewise.
* gcc.c-torture/execute/memset-1.c (main): Likewise.
* gcc.c-torture/execute/memset-2.c: Include <string.h>.
* gcc.c-torture/execute/memset-3.c: Likewise.
* gcc.c-torture/execute/nest-stdar-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/nestfunc-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/packed-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/pr15262-1.c (main): Likewise. Call
__builtin_malloc instead of malloc.
* gcc.c-torture/execute/pr15262-2.c (foo): Add int return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/pr15262.c (main): Likewise.
* gcc.c-torture/execute/pr17252.c (main): Likewise.
* gcc.c-torture/execute/pr21331.c (main): Likewise.
* gcc.c-torture/execute/pr34176.c (foo): Add missing int
type to definition of foo.
* gcc.c-torture/execute/pr42231.c (max): Add missing int type
to definition.
* gcc.c-torture/execute/pr42614.c (expect_func): Call
__builtin_abs instead of abs.
* gcc.c-torture/execute/pr54937.c (t): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/ptr-arith-1.c (main): Likewise.
* gcc.c-torture/execute/regstack-1.c (main): Likewise.
* gcc.c-torture/execute/scope-1.c (f): Add missing void types.
(main): Add missing int and void types.
* gcc.c-torture/execute/simd-5.c (main): Call __builtin_memcmp
instead of memcmp.
* gcc.c-torture/execute/strcmp-1.c (main): Add missing
int and void types.
* gcc.c-torture/execute/strcpy-1.c (main): Likewise.
* gcc.c-torture/execute/strct-pack-1.c (main): Likewise.
* gcc.c-torture/execute/strct-pack-2.c (main): Likewise.
* gcc.c-torture/execute/strct-pack-4.c (main): Likewise.
* gcc.c-torture/execute/strct-stdarg-1.c (f): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/strct-varg-1.c (f): Add void return
type.
(main): Add missing int and void types.
* gcc.c-torture/execute/strlen-1.c (main): Likewise.
* gcc.c-torture/execute/strncmp-1.c (main): Likewise.
* gcc.c-torture/execute/struct-ini-1.c (main): Likewise.
* gcc.c-torture/execute/struct-ini-2.c (main): Likewise.
* gcc.c-torture/execute/struct-ini-3.c (main): Likewise.
* gcc.c-torture/execute/struct-ini-4.c (main): Likewise.
* gcc.c-torture/execute/struct-ret-1.c (main): Likewise.
* gcc.c-torture/execute/struct-ret-2.c (main): Likewise.
* gcc.c-torture/execute/va-arg-1.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/va-arg-10.c (main): Likewise.
* gcc.c-torture/execute/va-arg-2.c (main): Likewise.
* gcc.c-torture/execute/va-arg-4.c (main): Likewise.
* gcc.c-torture/execute/va-arg-5.c (va_double)
(va_long_double): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/va-arg-6.c (f): Add void return type.
(main): Add missing int and void types.
* gcc.c-torture/execute/va-arg-9.c (main): Likewise.
* gcc.c-torture/execute/widechar-1.c (main): Likewise.
|| strchr (fmt, 'n') != 0);
}
-main()
+int
+main(void)
{
if (special_format ("ee"))
abort ();
unsigned x2:2;
unsigned x3:3;
};
-
+
+void
foobar (int x, int y, int z)
{
struct x a = {x, y, z};
exit (0);
}
-main()
+int
+main(void)
{
foobar (1, 2, 3);
}
return 0;
}
-main()
+int
+main(void)
{
uint64 f = getmask();
if (sizeof (long long) == 8
void checkit(int);
-main () {
+int main (void) {
const ull a = 0x1400000000ULL;
const ull b = 0x80000000ULL;
const ull c = a/b;
int seqgt2 (unsigned long a, unsigned short win, unsigned long b);
-main()
+int
+main(void)
{
if (! seqgt (*aa, 0x1000, *bb) || ! seqgt2 (*aa, 0x1000, *bb))
abort ();
return ((0 > a - 2) ? 0 : a - 2) * sizeof (long);
}
-main ()
+int
+main (void)
{
if (sub (0) != 0)
abort ();
abort ();
}
-main()
+int
+main(void)
{
struct F x, y;
x.i = 0;
return bar (i, t);
}
-main ()
+int
+main (void)
{
trio t = { 1, 2, 3 };
return bar (i, j, k, t);
}
-main ()
+int
+main (void)
{
trio t = { 1, 2, 3 };
static struct adjust_template adjust = {0, 0, 1, 1};
-main ()
+int
+main (void)
{
short x = 1, y = 1;
LAST_CPLUS_TREE_CODE
};
-blah(){}
+void blah(void){}
+void
convert_like_real (convs)
tree convs;
{
abort ();
}
-main()
+int
+main(void)
{
tree convs = (void *)malloc (sizeof (struct tree_common));;
void abort(void);
int a,b;
-main()
+int
+main(void)
{
int c=-2;
int d=0xfe;
return 0;
}
-main()
+int main(void)
{
if (foo (&z, 10))
abort ();
return i;
}
-main ()
+int
+main (void)
{
if (t2 () != 4096)
abort ();
int n = 2;
-main ()
+int
+main (void)
{
int i, x = 45;
return giv;
}
-
-main()
+int
+main(void)
{
if (test () != 8)
abort ();
char *m (char *x) { abort (); }
char *s (char *v, char **pp)
{
- if (strcmp (v, "a") != 0 || check++ > 1)
+ if (__builtin_strcmp (v, "a") != 0 || check++ > 1)
abort ();
*pp = v+1;
return 0;
{ 'e', 'b' }
};
-main()
+int
+main(void)
{
if (a1.a1c != '4')
abort();
void exit (int);
-main()
+int
+main(void)
{
char blah[33] = "01234567890123456789";
exit (0);
int shift1 = SHIFT1;
int shift2 = SHIFT2;
-main ()
+int
+main (void)
{
if (ROR (uc, shift1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
int b = 0;
-func () { }
+void func (void) { }
void
testit(int x)
FFelem q, lcu, lcvrecip, p;
int df, dg, du, dv;
- printf("DUPFFexgcd called on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g));
+ __builtin_printf("DUPFFexgcd called on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g));
if (DUPFFdeg(f) < DUPFFdeg(g)) return DUPFFexgcd(gcofac, fcofac, g, f); /*** BUG IN THIS LINE ***/
if (DUPFFdeg(f) != 2 || DUPFFdeg(g) != 1) abort();
if (f->coeffs[0] == 0) return f;
f = DUPFFnew(1); f->coeffs[1] = 1; f->deg = 1;
g = DUPFFnew(2); g->coeffs[2] = 1; g->deg = 2;
- printf("calling DUPFFexgcd on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g)) ;
+ __builtin_printf("calling DUPFFexgcd on degrees %d and %d\n", DUPFFdeg(f), DUPFFdeg(g)) ;
h = DUPFFexgcd(&cf, &cg, f, g);
return 0;
}
int shift1 = SHIFT1;
int shift2 = SHIFT2;
-main ()
+int
+main (void)
{
if (ROR (uc, shift1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
int shift1 = SHIFT1;
int shift2 = SHIFT2;
-main ()
+int
+main (void)
{
if (ROR (c, shift1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
int shift1 = SHIFT1;
int shift2 = SHIFT2;
-main ()
+int
+main (void)
{
if (ROR (c, shift1) != ROR (CHAR_VALUE, SHIFT1))
abort ();
unsigned int n = 30;
-main ()
+int
+main (void)
{
x ();
if (p != 1 || k != 1)
IOGBounds global_bounds = { 100, 150, 100, 150 };
IOGBounds global_saveRect = { 75, 175, 75, 175 };
-main()
+int
+main(void)
{
unsigned int *vramPtr;
int width;
void abort (void);
void exit (int);
+void
foo (int *p)
{
*p = 10;
}
-main()
+int
+main(void)
{
- int *ptr = alloca (sizeof (int));
+ int *ptr = __builtin_alloca (sizeof (int));
*ptr = 5;
foo (ptr);
if (*ptr == 5)
{
register unsigned int z LOC;
- sprintf (c, "%d", x / y);
+ __builtin_sprintf (c, "%d", x / y);
z = x + 1;
return z / (y + 1);
}
{
return floor(a);
}
-main()
+int
+main(void)
{
#ifdef __OPTIMIZE__
if (t(0)!=0)
void link_error (void);
const double one=1.0;
-main ()
+int
+main (void)
{
#ifdef __OPTIMIZE__
if ((int) one != 1)
This ended up causing CCP to think that 'k' was the constant '1'. */
void abort (void);
-main()
+int
+main(void)
{
int i, j, k;
return x;
}
-main()
+int
+main(void)
{
int a[5];
- memset (a, 1, sizeof (a));
+ __builtin_memset (a, 1, sizeof (a));
if (foo(a, 0) - a != 1 || a[0] != 55 || a[1] != a[4])
abort();
- memset (a, 1, sizeof (a));
+ __builtin_memset (a, 1, sizeof (a));
if (foo(a, 2) - a != 2 || a[0] != 55 || a[1] != 2)
abort();
return *p + 1;
}
-main ()
+int
+main (void)
{
/* Variable 'i' is never used but it's aliased to a global pointer. The
alias analyzer was not considering that 'i' may be used in the call to
int code;
};
-main()
+int
+main(void)
{
int tmp[2];
struct rtx_def *r, s;
a[0]=0;
memset( &a[0], 0xCD, STRLEN );
a[STRLEN]=0;
- if (strlen(a) != STRLEN)
+ if (__builtin_strlen(a) != STRLEN)
abort ();
}
unsigned int x;
-main()
+int
+main(void)
{
struct a a = {0};
x = 0xbeef;
return foo;
}
-main()
+int
+main(void)
{
if (blah (-1) != 1)
abort ();
if (j == 2)
{
- memcpy (x, y, 10 * sizeof (int));
+ __builtin_memcpy (x, y, 10 * sizeof (int));
return sizeof (c);
}
else
if (j == 2)
{
- memcpy (x, y, 10 * sizeof (int));
+ __builtin_memcpy (x, y, 10 * sizeof (int));
return sizeof (c);
}
else
inlinable();
}
-main ()
+int
+main (void)
{
test_var = 10;
/* Variable test_var should be considered call-clobbered by the call
return a;
}
-main()
+int
+main(void)
{
if (foo (9) != 10)
abort ();
}
return count;
}
-main() {
+int main(void) {
Struct3 *p = malloc (sizeof (int) + 3 * sizeof(Union));
memset(p, 0, sizeof(int) + 3*sizeof(Union));
p->Count = 3;
int main(void)
{
int t = string_to_ip (temp);
- printf ("%x\n", t);
- printf ("%x\n", result);
+ __builtin_printf ("%x\n", t);
+ __builtin_printf ("%x\n", result);
if (t != result)
__builtin_abort ();
- printf ("WORKS.\n");
+ __builtin_printf ("WORKS.\n");
return 0;
}
static struct adjust_template adjust = {1, 1};
-main ()
+int
+main (void)
{
short x = 1, y = 1;
long f5(long a){return a&0x0000ffffL;}
long f6(long a){return a&~0x0000ffffL;}
-main ()
+int
+main (void)
{
long a = 0x89ABCDEF;
static int rule_text_needs_stack_pop = 0;
static int input_stack_pos = 1;
+int
f (void)
{
rule_text_needs_stack_pop = 1;
return 0;
}
-main ()
+int
+main (void)
{
f ();
exit (0);
short optab[5];
char buf[10];
+void
execute (ip)
register short *ip;
{
short p[5];
-main ()
+int
+main (void)
{
execute ((short *) 0);
p[0] = optab[1];
p[2] = optab[1];
p[3] = optab[2];
execute (&p);
- if (strcmp (buf, "xyxyz"))
+ if (__builtin_strcmp (buf, "xyxyz"))
abort ();
exit (0);
}
void exit (int);
-main(){int d[40000];d[0]=0;exit(0);}
+int main(void){int d[40000];d[0]=0;exit(0);}
}
}
-main ()
+int
+main (void)
{
unsigned long long t;
unsigned x0, a;
void exit (int);
int tab[9];
+void
execute(oip, ip)
unsigned short *oip, *ip;
{
goto *(&&base + *ip++);
}
-main()
+int
+main(void)
{
unsigned short ip[10];
int i;
void abort (void);
void exit (int);
+int
x (int i)
{
void *j[] = {&&x, &&y, &&z};
z:return 5;
}
-main ()
+int
+main (void)
{
if (x (0) != 2 || x (1) != 3 || x (2) != 5)
abort();
return xp - tab;
}
+int
main (argc, argv)
int argc;
char *argv[];
va_end (ap);
}
-main()
+int
+main(void)
{
va (1, 1.0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- if (strcmp ("1,1.000000,2,3,4,5,6,7,8,9,10,11,12,13,14,15", buf))
+ if (__builtin_strcmp ("1,1.000000,2,3,4,5,6,7,8,9,10,11,12,13,14,15", buf))
abort();
exit(0);
}
void abort (void);
void exit (int);
int l[]={0,1};
-main(){int*p=l;switch(*p++){case 0:exit(0);case 1:break;case 2:break;case 3:case 4:break;}abort();}
+int main(void){int*p=l;switch(*p++){case 0:exit(0);case 1:break;case 2:break;case 3:case 4:break;}abort();}
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
int i = 0;
int a (int x)
void abort (void);
void exit (int);
-main(){if(1.17549435e-38F<=1.1)exit(0);abort();}
+int main(void){if(1.17549435e-38F<=1.1)exit(0);abort();}
va_end(args);
}
-main()
+int
+main(void)
{
va1(4,pts[0],pts[1],pts[2],pts[3]);
va2(4,ipts[0],ipts[1],ipts[2],ipts[3]);
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
if ((double) 18446744073709551615ULL < 1.84467440737095e+19 ||
(double) 18446744073709551615ULL > 1.84467440737096e+19)
void abort (void);
void exit (int);
long f(short a,short b){return (long)a/b;}
-main(){if(f(-32768,-1)!=32768L)abort();else exit(0);}
+int main(void){if(f(-32768,-1)!=32768L)abort();else exit(0);}
return -1;
}
-main()
+int
+main(void)
{
int i;
for (i = 1; i <= 6; i++)
{
number = va_arg(args, int);
sprintf(bp, "%d", number);
- bp += strlen(bp);
+ bp += __builtin_strlen(bp);
}
else
*bp++ = fmt[pos];
{
number = va_arg(args, int);
sprintf(bp, "%d", number);
- bp += strlen(bp);
+ bp += __builtin_strlen(bp);
}
else
*bp++ = fmt[pos];
return dummy;
}
-main()
+int
+main(void)
{
char buf1[100], buf2[100];
first(buf1, "i i ", 5, 20);
second(buf2, "i i ", 5, 20);
- if (strcmp ("5 20 ", buf1) || strcmp ("5 20 ", buf2))
+ if (__builtin_strcmp ("5 20 ", buf1) || __builtin_strcmp ("5 20 ", buf2))
abort();
exit(0);
}
child->size=size;
return child;
}
-main()
+int main(void)
{
t foo,*bar;
memset(&foo,37,sizeof(t));
void abort (void);
void exit (int);
long long c=2863311530LL,c3=2863311530LL*3;
-main(){if(c*3!=c3)abort();exit(0);}
+int main(void){if(c*3!=c3)abort();exit(0);}
return X;
}
-main()
+int
+main(void)
{
T X,Y;
int i;
return p + a;
}
-main ()
+int
+main (void)
{
unsigned long x = 0x80000000UL;
if (f(&x) != &x + 0x81)
/* { dg-skip-if "requires alloca" { ! alloca } { "-O0" } { "" } } */
/* REPRODUCED:RUN:SIGNAL MACHINE:sparc OPTIONS: */
void exit (int);
+void
f(int n)
{
int i;
for(i=0;i<n;i++)
v[i]=0;
}
-main()
+int
+main(void)
{
f(100);
exit(0);
/* REPRODUCED:RUN:SIGNAL MACHINE:i386 OPTIONS:-O */
void abort(void);
void exit(int);
-main()
+int
+main(void)
{
-if(strcmp("X","")<0)abort();
+if(__builtin_strcmp("X","")<0)abort();
exit(0);
}
void exit(int);
static int strcmp(){return-1;}
#define strcmp __builtin_strcmp
-main()
+int
+main(void)
{
if(strcmp("X","X\376")>=0)abort();
exit(0);
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
int j=1081;
struct
void *foo[]={(void *)&("X"[0])};
-main ()
+int
+main (void)
{
if (((char*)foo[0])[0] != 'X')
abort ();
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
double x,y=0.5;
x=y/0.2;
return back;
}
-main()
+int
+main(void)
{
if (build(0, 1) != 0x0000000000000001LL)
abort();
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
unsigned long val = 1;
double d;
} x[2], v;
+void
f (x, v)
union u *x, v;
{
*++x = v;
}
-main()
+int
+main(void)
{
x[1].t.i1 = x[1].t.i2 = 0;
v.t.i1 = 1;
float x, y;
} vector_t;
-w(float x, float y) {}
+void w(float x, float y) {}
+void
f1(float x, float y)
{
if (x != 0 || y != 0)
abort();
}
+void
f2(float x, float y)
{
if (x != 1 || y != 1)
abort();
}
+void
gitter(int count, vector_t pos[], list_t list, int *nww, vector_t limit[2], float r)
{
float d;
vector_t pos[1] = {{0., 0.}};
vector_t limit[2] = {{0.,0.},{1.,1.}};
-main()
+int
+main(void)
{
int nww;
struct_list list;
{
if (p.flag != 99)
return 1;
- return strcmp (p.text, "0123456789");
+ return __builtin_strcmp (p.text, "0123456789");
}
-main ()
+int
+main (void)
{
cell.flag = 99;
- strcpy (cell.text, "0123456789");
+ __builtin_strcpy (cell.text, "0123456789");
if (check (cell))
abort();
a = j.b3;
}
-main ()
+int
+main (void)
{
four_quarters x;
x.b0 = x.b1 = x.b2 = 0;
return x & 0xff;
}
-main()
+int
+main(void)
{
if (f(0x0123456789ABCDEFLL) != 0xCD)
abort();
return o;
}
-main()
+int
+main(void)
{
bu a;
bu r;
return (*f)(a);
}
-main()
+int
+main(void)
{
if (Int(&f,2.0) != 4.0)
abort();
void abort (void);
void exit (int);
+void
f(int *x)
{
*x = 0;
}
-main()
+int
+main(void)
{
int s, c, x;
char a[] = "c";
return x;
}
-main()
+int
+main(void)
{
static struct s i;
i.a = 12;
void exit (int);
-f()
+void
+f(void)
{
int x = 1;
#if defined(STACK_SIZE)
exit(0);
}
-main()
+int
+main(void)
{
f();
}
E eval;
} s;
-p()
+void
+p(void)
{
abort();
}
-f()
+void
+f(void)
{
switch (s.eval)
{
}
}
-main()
+int
+main(void)
{
s.eval = e1;
f();
return p;
}
-main ()
+int
+main (void)
{
char *p = "";
if (f (p) != p + 1)
int w[2][2];
-f ()
+void
+f (void)
{
int i, j;
w[i][j] = 1;
}
-main ()
+int
+main (void)
{
f ();
if (w[0][0] != 1 || w[1][1] != 1 || w[1][0] != 0 || w[0][1] != 0)
double f (double a) {}
double (* const a[]) (double) = {&f};
-main ()
+int
+main (void)
{
double (*p) ();
p = &f;
void abort (void);
void exit (int);
+void
f (double *ty)
{
*ty = -1.0;
}
-main ()
+int
+main (void)
{
double foo[6];
double tx = 0.0, ty, d;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
int i, j, k, l;
float x[8][2][8][2];
return n;
}
-main ()
+int
+main (void)
{
long long n;
void abort (void);
void exit (int);
+void
f (double x[2], double y[2])
{
if (x == y)
abort ();
}
-main ()
+int
+main (void)
{
struct { int f[3]; double x[1][2]; } tp[4][2];
int i, j, ki, kj, mi, mj;
return (v == 0 ? g () : "abc");
}
-main ()
+int
+main (void)
{
v = 1;
- if (!strcmp (f (), "abc"))
+ if (!__builtin_strcmp (f (), "abc"))
exit (0);
abort();
}
return dw.u[0] != 0 ? 1 : 0;
}
-main ()
+int
+main (void)
{
if (test_endianness () != test_endianness_vol ())
abort ();
void exit (int);
+void
f (void (*func) ())
{
func ();
}
-main ()
+int
+main (void)
{
void t0 ()
{
int c;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char d;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char e;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char e;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char f;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+void
+main (int)
{
struct tiny x[3];
x[0].c = 10;
char f;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
int c;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
short c;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
short c;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
short d;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
short d;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char c;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char c;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
char d;
};
+void
f (int n, struct tiny x, struct tiny y, struct tiny z, long l)
{
if (x.c != 10)
abort ();
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
return s1a;
}
-main ()
+int
+main (void)
{
T s1a, s1b;
s1a.x = 100;
small s[10];
} x;
-main ()
+int
+main (void)
{
int i;
for (i = 0; i < 10; i++)
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
static int a[] = {3, 4};
register int *b;
int f (int a, int b) { }
-main ()
+int
+main (void)
{
unsigned long addr1;
unsigned long addr2;
return foo_p;
}
-main ()
+int
+main (void)
{
volatile foo_t *foo_p;
return 2;
}
-main ()
+int
+main (void)
{
unsigned long long value = 0xc000000000000001LL;
int x, y;
double glob_dbl;
+void
f (pdbl, value)
double *pdbl;
double value;
*pdbl = value;
}
-main ()
+int
+main (void)
{
f ((void *) 0, 55.1);
return (x > 1) ? y : (y & 1);
}
-main ()
+int
+main (void)
{
if (f (2L, 0xdecadeL) != 0xdecadeL)
abort ();
return avs;
}
-main ()
+int
+main (void)
{
if (f ((mpt) 3, (mpt) 17) != 17)
abort ();
{
}
+int
g2 (a)
long a;
{
exit (0);
}
-f ()
+void
+f (void)
{
register char *p, *q;
register int i;
const char *rl_cp;
int len;
rl_cp = g1 (el, &len);
- strcpy (p, rl_cp);
+ __builtin_strcpy (p, rl_cp);
}
else
{
}
}
-main ()
+int
+main (void)
{
el = 0;
parsefile->fd = 0xdeadbeefL;
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
long int i = -2147483647L - 1L; /* 0x80000000 */
char ca = 1;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
int tmp;
unsigned long long utmp1, utmp2;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
struct { long status; } h;
return 2;
}
-main ()
+int
+main (void)
{
Point b, p1, p2;
int answer;
return ((unsigned long long) ((signed long long) diff < 0 ? -diff : diff));
}
-main ()
+int
+main (void)
{
int i;
for (i = 0; i <= 10; i++)
return virk;
}
-main ()
+int
+main (void)
{
if (f ().hours != 1 || f ().day != 2 || f ().month != 3 || f ().year != 4)
abort ();
return 0;
}
-main ()
+int
+main (void)
{
f (0, 0);
if (errflag)
return (n > 0) - (n < 0);
}
-main ()
+int
+main (void)
{
if (f (-1) != -1)
abort ();
}
}
-main ()
+int
+main (void)
{
f ();
exit (0);
int array[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
-main ()
+int
+main (void)
{
int i, j;
int *p;
int *sp, fc, *sc, a[2];
};
+void
f (struct S *x)
{
int *t = x->sc;
x->sp = t;
}
-main ()
+int
+main (void)
{
struct S s;
static int sc[3] = {2, 3, 4};
void abort (void);
void exit (int);
+void
g (int i)
{
}
+void
f (int i)
{
g (0);
g (0);
}
-main ()
+int
+main (void)
{
f (10);
exit (0);
return ((long long) a * (long long) b) >> 16;
}
-main ()
+int
+main (void)
{
if (f () < 0)
abort ();
int f (char *p) { }
-main ()
+int
+main (void)
{
char c;
char c2;
void abort (void);
void exit (int);
-int f (i) { return 12; }
+int f (int i) { return 12; }
int g () { return 0; }
-main ()
+int
+main (void)
{
int i, s;
int var = 0;
+void
g ()
{
var = 1;
}
+void
f ()
{
int f2 = 0;
g ();
}
-main ()
+int
+main (void)
{
f ();
if (var != 1)
void abort (void);
void exit (int);
+void
f (char *x)
{
*x = 'x';
}
-main ()
+int
+main (void)
{
int i;
char x = '\0';
void abort (void);
void exit (int);
-static inline
+static inline int
p (int *p)
{
return !((long) p & 1);
return 0;
}
-main ()
+int
+main (void)
{
if (f ((int*) 0xffffffff) != 0)
abort ();
return get_id (c);
}
-main ()
+int
+main (void)
{
get_tok ();
exit (0);
a_ptr->a_character = (unsigned char) r;
}
-main ()
+int
+main (void)
{
if (f (1, 0UL) != 0)
abort ();
long double Y2 = 3;
long double Y1 = 1;
long double X, Y, Z, T, R, S;
-main ()
+int
+main (void)
{
X = (C + U) * Y2;
Y = C - U - U;
void abort (void);
void exit (int);
+void
f (int i)
{
if (((1 << i) & 1) == 0)
abort ();
}
-main ()
+int
+main (void)
{
f (0);
exit (0);
return 2;
}
-main ()
+int
+main (void)
{
if (bar (1U) != 1)
abort ();
long a = 1;
-foo ()
+int
+foo (void)
{
switch (a % 2 % 2 % 2 % 2 % 2 % 2 % 2 % 2)
{
}
}
-main ()
+int
+main (void)
{
if (foo () != 1)
abort ();
if (data & 0x80) a1();
}
-main ()
+int
+main (void)
{
count = 0;
b (0);
if (data & 0x8000) a1();
}
-main ()
+int
+main (void)
{
count = 0;
b (0);
if (data & 0x80000000) a1();
}
-main ()
+int
+main (void)
{
count = 0;
b (0);
int *sp, fc, *sc, a[2];
};
+void
f (struct S *x)
{
int *t = x->sc;
x->sp = t;
}
-main ()
+int
+main (void)
{
struct S s;
static int sc[3] = {2, 3, 4};
return 1;
}
-main ()
+int
+main (void)
{
if (f (0, -1))
abort ();
return a[i-2000000000L];
}
-main ()
+int
+main (void)
{
if (acc_a (2000000000L) != 'd')
abort ();
struct s s = { .b = 3, .d = {2,0,0} };
-main ()
+int
+main (void)
{
if (s.b != 3)
abort ();
void abort (void);
void exit (int);
-g ()
+int
+g (void)
{
return '\n';
}
-f ()
+void
+f (void)
{
char s[] = "abcedfg012345";
char *sp = s + 12;
abort ();
}
-main ()
+int
+main (void)
{
f ();
exit (0);
long double x = X + X;
long double y = 2.0L * X;
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
if (x != y)
df(f_le, t_le)
df(f_be, t_be)
-main ()
+int
+main (void)
{
t_be x;
x.s.h = 0x10000000U;
abort();
}
-main()
+int
+main(void)
{
int *p = &i;
#define SIZE 8
-main()
+int
+main(void)
{
int a[SIZE] = {1};
int i;
return c;
}
-main ()
+int
+main (void)
{
__complex__ double c;
return d;
}
-main ()
+int
+main (void)
{
if (! (int) (f (2.0L, 1)))
abort ();
#else
#define BLOCK_SIZE 32768
#endif
-foo ()
+void
+foo (void)
{
int i;
for (i = 0; i < n; i++)
b[i] = -1;
}
-main ()
+int
+main (void)
{
n = BLOCK_SIZE;
a = malloc (n * sizeof(*a));
unsigned char e : 1;
} a_struct;
+int
foo (flags)
a_struct *flags;
{
|| flags->b != 3);
}
-main ()
+int
+main (void)
{
a_struct flags;
return ul;
}
-main ()
+int
+main (void)
{
if (f () != (unsigned short) -1)
abort ();
f3 (v);
}
-main ()
+int
+main (void)
{
f4 ();
if (val != 0x5e000132)
return bit;
}
+void
f (x)
int x;
{
abort ();
}
-main ()
+int
+main (void)
{
f (1);
exit (0);
int k = 0;
-main()
+int
+main(void)
{
int i;
int j;
void exit (int);
-main ()
+int
+main (void)
{
unsigned char z = 0;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
int i = 0;
return -1;
}
-main ()
+int
+main (void)
{
if (test (0) != 0)
abort ();
long long acc;
+void
addhi (short a)
{
acc += (long long) a << 32;
}
+void
subhi (short a)
{
acc -= (long long) a << 32;
}
-main ()
+int
+main (void)
{
acc = 0xffff00000000ll;
addhi (1);
return ((a >= 0 && a <= 10) && ! (a >= 0));
}
-main ()
+int
+main (void)
{
if (f (0))
abort ();
return ptr;
}
-main ()
+int
+main (void)
{
char *s = ":ab";
char *lim = s + 3;
return 1;
}
-main()
+int
+main(void)
{
if (sub1 (0x80000000ULL))
abort ();
return n;
}
-main ()
+int
+main (void)
{
int res;
unsigned int ar[] = { 10, 11, 12, 13, 14 };
void exit (int);
#define L 1
-main ()
+int
+main (void)
{
exit (L'1' != L'1');
}
void exit (int);
#define m(L) (L'1' + (L))
-main ()
+int
+main (void)
{
exit (m (0) != L'1');
}
void exit (int);
+int
sub (int i, int array[i++])
{
return i;
}
-main()
+int
+main(void)
{
int array[10];
exit (sub (10, array) != 11);
return 0;
}
-
-main()
+int
+main(void)
{
if (ts (0) || tu (0))
abort ();
object cons1[2] = { {(char *) &nil, 0}, {(char *) &nil, 0} };
object cons2[2] = { {(char *) &cons1, 64}, {(char *) &nil, 0} };
-main()
+int
+main(void)
{
object x = {(char *) &cons2, 64};
object y = {(char *) &nil, 0};
goto foo;
}
-main()
+int
+main(void)
{
struct decision *p = 0;
clear_modes (p);
return sp->i+1;
}
-main()
+int
+main(void)
{
if (f () != 1)
abort ();
{
int m;
- m = strlen (pattern) - 1;
+ m = __builtin_strlen (pattern) - 1;
- memset (lookup_table, ++m, 257);
+ __builtin_memset (lookup_table, ++m, 257);
return m;
}
return 1;
}
-main()
+int
+main(void)
{
unsigned int i, j, k, l;
i = 5; j = 2; k=0; l=2;
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
int i;
for (i = 1; i < 100; i++)
int c = 1;
int d = 0;
-main ()
+int
+main (void)
{
double e;
double f;
#endif
__inline__ static int
-dummy (x)
+dummy (int x)
{
int y;
y = (long) (x * 4711.3);
abort ();
}
-main ()
+int
+main (void)
{
f ();
exit (0);
void abort (void);
void exit (int);
+int
ns_name_skip (unsigned char **x, unsigned char *y)
{
*x = 0;
return (ptr - saveptr);
}
-main()
+int
+main(void)
{
if (dn_skipname (&a[0], &a[1]) == 0)
abort ();
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
volatile double a;
double c;
return tmp1 < tmp2;
}
-main ()
+int
+main (void)
{
if (foo (2, 24, 3, 4) == 0)
abort ();
extern void abort (void);
extern void exit (int);
-main()
+int
+main(void)
{
int a,b,c;
int *pa, *pb, *pc;
void sub( struct s *p, struct s **pp );
int look( struct s *p, struct s **pp );
-main()
+int
+main(void)
{
struct s *pp;
struct s *next;
asm("" : "+r"(*bar()));
}
-main()
+int
+main(void)
{
foo();
if (count != 1)
exit (0);
}
-main()
+int
+main(void)
{
f(0xffffff01);
}
abort ();
}
-main()
+int
+main(void)
{
loop (a, b);
exit (0);
return data.word;
}
-main()
+int
+main(void)
{
/* XXX This test could be generalized. */
if (sizeof (long) != 4)
{
static int fetch_count;
- memset(&data_tmp, 0x55, sizeof(data_tmp));
+ __builtin_memset(&data_tmp, 0x55, sizeof(data_tmp));
sqlca.sqlcode = (++fetch_count > 1 ? 100 : 0);
}
int num = num_records();
data_ptr = malloc(num * sizeof(struct data_record));
- memset(data_ptr, 0xaa, num * sizeof(struct data_record));
+ __builtin_memset(data_ptr, 0xaa, num * sizeof(struct data_record));
fetch();
p = data_ptr;
}
}
-
-main()
+int
+main(void)
{
load_data();
if (sizeof (int) == 2 && data_ptr[0].dummy != 0x5555)
return m;
}
-main()
+int
+main(void)
{
int i;
material_type x;
void exit (int);
int blah;
-foo()
+
+int
+foo(void)
{
int i;
return blah;
}
-
-main()
+int
+main(void)
{
if (foo () != 0xfcc)
abort ();
Reported by Jim Meyering; distilled from bash. */
void abort(void);
+int isprint (int);
int rl_show_char (int c) { return 0; }
struct tmp3 tmp3 = {0x123, 0x1FFFF00000000LL};
struct tmp4 tmp4 = {0x1FFFF00000000LL, 0x123};
-main()
+int
+main(void)
{
if (sizeof (long long) != 8)
int val;
int *ptr = &val;
-float *ptr2 = &val;
+float *ptr2 = (float *) &val;
__attribute__((optimize ("-fno-strict-aliasing")))
-typepun ()
+void
+typepun (void)
{
*ptr2=0;
}
-main()
+int
+main(void)
{
*ptr=1;
typepun ();
int a[10]={};
extern int b[10] __attribute__ ((alias("a")));
int off;
-main()
+int
+main(void)
{
b[off]=1;
a[off]=2;
static int a=0;
extern int b __attribute__ ((alias("a")));
__attribute__ ((noinline))
-static inc()
+static void inc(void)
{
b++;
}
extern int b __attribute__ ((alias ("a")));
int c = 1;
extern int d __attribute__ ((alias ("c")));
+int
main (int argc)
{
int *p;
return ret;
return i;
}
-main ()
+
+int
+main (void)
{
if (sat_add (~0U) != ~0U)
abort ();
#define ABS(x) ((x) >= 0 ? (x) : -(x))
-main ()
+int
+main (void)
{
long long int i;
#define ABS(x) ((x) >= 0 ? (x) : -(x))
-main ()
+int
+main (void)
{
long int i;
struct { long f8:8; long f24:24; } a;
struct { long f32:32; } b;
-main ()
+int
+main (void)
{
if (sizeof (a) != sizeof (b))
abort ();
unsigned long whole:32 __attribute__ ((packed));
};
+void
f (struct foo *q)
{
if (q->half != 0x1234)
abort ();
}
-main ()
+int
+main (void)
{
struct foo bar;
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
struct {
signed int s:3;
struct X x;
-main ()
+int
+main (void)
{
if ((x.u3 - 2) >= 0) /* promoted value should be signed */
abort ();
return tmp2;
}
-main()
+int
+main(void)
{
struct tmp tmp = {0x123, 0xFFF000FFF000FLL};
struct tmp2 tmp2 = {0xFFF000FFF000FLL, 0x123};
int *glob_ptr_int = glob_int_arr;
int glob_int = 4;
-static stat_int_arr[100];
+static int stat_int_arr[100];
static int *stat_ptr_int = stat_int_arr;
static int stat_int;
volatile int * volatile glob_vol_ptr_vol_int = glob_vol_int_arr;
volatile int glob_vol_int;
-static stat_int_arr[100];
+static int stat_int_arr[100];
static volatile int stat_vol_int_arr[100];
static int * volatile stat_vol_ptr_int = stat_int_arr;
static volatile int *stat_ptr_vol_int = stat_vol_int_arr;
return lt;
}
-main ()
+int
+main (void)
{
if ((int) (cbrtl (27.0) + 0.5) != 3)
abort ();
exit (0);
}
#else
-main () { exit (0); }
+int main (void) { exit (0); }
#endif
return x;
}
-main ()
+int
+main (void)
{
__complex__ double x;
__complex__ double ag = 1.0 + 1.0i;
__complex__ double bg = -2.0 + 2.0i;
-main ()
+int
+main (void)
{
__complex__ double a, b, c;
return c;
}
-main ()
+int
+main (void)
{
struct complex z = f (1.0, 0.0);
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
if ((__complex__ double) 0.0 != (__complex__ double) (-0.0))
abort ();
float __complex__ w = 8.0 + 19.0 * (1.0fi);
float __complex__ z;
-main ()
+int
+main (void)
{
z = p (x,y);
struct S x = {1, 1, 1};
-main ()
+int
+main (void)
{
x = (struct S) {b:0, a:0, c:({ struct S o = x; o.a == 1 ? 10 : 20;})};
if (x.c != 10)
return t == 0 || x / t > 100000000000000000000000000000000.0;
}
+void
test_integer_to_float()
{
if (u2f(0U) != (float) 0U) /* 0 */
return s;
}
+void
test_longlong_integer_to_float()
{
if (ull2f(0ULL) != (float) 0ULL) /* 0 */
return (int) d;
}
+void
test_float_to_integer()
{
if (f2u(0.0) != 0)
return (long long int) d;
}
+void
test_float_to_longlong_integer()
{
if (f2ull(0.0) != 0LL)
}
#endif
-main()
+int
+main(void)
{
test_integer_to_float();
test_float_to_integer();
return g2 (i);
}
-main ()
+int
+main (void)
{
if (f (123456789L) != 123456789L)
abort ();
unsigned a, b, c, d;
} t1;
+void
f (t1 *ps)
{
ps->a = 10000;
ps->d = ps->c / 3;
}
-main ()
+int
+main (void)
{
t1 s;
f (&s);
-1L, 0x7fffffffL, -0x7fffffffL - 1L
};
-main ()
+int
+main (void)
{
int i;
return x / 10000000000LL;
}
-main ()
+int
+main (void)
{
if (f (10000000000LL) != 1 || f (100000000000LL) != 10)
abort ();
return 0;
}
-main ()
+int
+main (void)
{
tok = 0;
if (atom () != 1)
static double f (float a);
static double (*fp) (float a);
-main ()
+int
+main (void)
{
fp = f;
if (fp ((float) 1) != 1.0)
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
double db1 = 1.7976931348623157e+308;
long double ldb1 = db1;
void exit (int);
unsigned u=2147483839;float f0=2147483648e0,f1=2147483904e0;
-main()
+int
+main(void)
{
float f=u;
if(f==f0)
void abort (void);
void exit (int);
double normalize(x)double x;{if(x==0)x=0;return x;}
-main(){char b[9];sprintf(b,"%g",normalize(-0.0));if(strcmp(b,"0"))abort();exit(0);}
+int main(void){char b[9];sprintf(b,"%g",normalize(-0.0));if(__builtin_strcmp(b,"0"))abort();exit(0);}
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
union {
double d;
exit (0);
}
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
/* Move this line earlier, for architectures (like alpha) that issue
exit (0);
}
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
/* Move this line earlier, for architectures (like alpha) that issue
exit (0);
}
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
/* Move this line earlier, for architectures (like alpha) that issue
extern void abort (void);
extern void exit (int);
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
/* NaN is an IEEE unordered operand. All these test should be false. */
extern void abort (void);
extern void exit (int);
-main ()
+int
+main (void)
{
#if ! defined (__vax__) && ! defined (_CRAY)
/* NaN is an IEEE unordered operand. All these test should be false. */
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
union
{
else if (value != value)
abort (); /* actual value is a NaN */
- else if (memcmp ((void *)&value, (void *)&expected, sizeof (double)) != 0)
+ else if (__builtin_memcmp ((void *)&value, (void *)&expected,
+ sizeof (double)) != 0)
abort (); /* values don't match */
}
-main ()
+int
+main (void)
{
expect (pzero + pzero, pzero);
expect (pzero + nzero, pzero);
double negd (double);
float negf (float);
-main ()
+int
+main (void)
{
expectd (negd (zerod), nzerod);
expectf (negf (zerof), nzerof);
expectd (double value, double expected)
{
if (value != expected
- || memcmp ((void *)&value, (void *) &expected, sizeof (double)) != 0)
+ || __builtin_memcmp ((void *)&value, (void *) &expected,
+ sizeof (double)) != 0)
abort ();
}
expectf (float value, float expected)
{
if (value != expected
- || memcmp ((void *)&value, (void *) &expected, sizeof (float)) != 0)
+ || __builtin_memcmp ((void *)&value, (void *) &expected,
+ sizeof (float)) != 0)
abort ();
}
negzero_check (double d)
{
if (d == 0)
- return !!memcmp ((void *)&zero, (void *)&d, sizeof (double));
+ return !!__builtin_memcmp ((void *)&zero, (void *)&d, sizeof (double));
return 0;
}
return x;
}
-main ()
+int
+main (void)
{
unsigned long long int k;
double x;
return a[n - 100000];
}
-main ()
+int
+main (void)
{
if (f (100030L) != 30)
abort();
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
int i, j, k[3];
int a[2];
+void
f (int i)
{
for (; i < INT_MAX; i++)
}
}
-main ()
+int
+main (void)
{
a[0] = a[1] = 0;
f (0);
void abort (void);
void exit (int);
-main()
+int
+main(void)
{
char c;
char d;
abort ();
}
-main()
+int
+main(void)
{
foo (64);
exit (0);
float *b;
} *c;
int d;
+void
use_a (struct a *a)
{
}
+void
set_b (int **a)
{
*a=&d;
}
+void
use_c (struct c *a)
{
}
struct b b2;
struct b b3;
int **ptr = &b2.b;
-main ()
+int
+main (void)
{
a= (void *)0;
b.b=&e;
return memcpy (o, i, l);
}
-main ()
+int
+main (void)
{
unsigned i;
unsigned char src[MEMCPY_SIZE];
long double align_fp;
} u1, u2;
-main ()
+int
+main (void)
{
int off1, off2, len, i;
char *p, *q, c;
TN ((n) + 2) \
TN ((n) + 3)
-main ()
+int
+main (void)
{
int i,j;
char A = 'A';
-main ()
+int
+main (void)
{
int off, len, i;
char *p, *q;
Written by Roger Sayle, April 22, 2002. */
+#include <string.h>
+
void abort (void);
void exit (int);
Written by Roger Sayle, July 22, 2002. */
+#include <string.h>
+
void abort (void);
void exit (int);
void abort (void);
void exit (int);
-main ()
+int
+main (void)
{
double f (int x, ...)
{
return b;
}
+void
f ()
{
int i, j;
abort ();
}
-main ()
+int
+main (void)
{
f ();
exit (0);
short i __attribute__ ((packed));
} t;
+void
f ()
{
t.i = x1;
abort ();
}
-main ()
+int
+main (void)
{
f ();
exit (0);
int foo () { return 3; }
-main ()
+int
+main (void)
{
struct A loc, *locp;
float f, g, *p;
g = 1;
/* Store into *locp and cache its current value. */
- locp = malloc (sizeof (*locp));
+ locp = __builtin_malloc (sizeof (*locp));
locp->i = 10;
T355 = locp->i;
float X;
+int
foo (struct B b, struct A *q, float *h)
{
X += *h;
return *(b.p);
}
-main()
+int
+main(void)
{
struct A a;
struct B b;
return T355;
}
-main ()
+int
+main (void)
{
struct A loc;
int str;
char *a;
-main ()
+int
+main (void)
{
/* Make 'a' point to itself. */
a = (char *)&a;
if (retval == -1) return 0;
return 3; }
-main ()
+int
+main (void)
{ if (foo () != 0) abort ();
return 0; }
struct mult_index * __attribute__((noinline))
foo (size_t n)
{
- static count = 0;
+ static int count = 0;
if (count++ > 0)
abort ();
return 0;
extern void abort (void);
-static max;
+static int max;
static void __attribute__((noinline)) storemax (int i)
{
void
expect_func (int a, unsigned char *b)
{
- if (abs ((a == 0)))
+ if (__builtin_abs ((a == 0)))
abort ();
- if (abs ((b == 0)))
+ if (__builtin_abs ((b == 0)))
abort ();
}
void (*terminate_me)(int);
__attribute__((noinline,noclone))
+void
t(int c)
{ int i;
for (i=0;i<c;i++)
a[i]=0;
}
}
-main()
+int
+main(void)
{
terminate_me = exit;
t(100);
return &s[i + 3 - 1];
}
-main ()
+int
+main (void)
{
char *str = "abcdefghijkl";
char *x2 = f (str, 12);
long double Y2 = 11;
long double Y1 = 17;
long double X, Y, Z, T, R, S;
-main ()
+int
+main (void)
{
X = (C + U) * Y2;
Y = C - U - U;
int v = 3;
-f ()
+void
+f (void)
{
int v = 4;
{
}
}
-main ()
+int
+main (void)
{
f ();
exit (0);
{
func2 ();
- if (memcmp (&w1, &w3, sizeof (Q)) != 0)
+ if (__builtin_memcmp (&w1, &w3, sizeof (Q)) != 0)
abort ();
- if (memcmp (&w2, &w4, sizeof (Q)) != 0)
+ if (__builtin_memcmp (&w2, &w4, sizeof (Q)) != 0)
abort ();
- if (memcmp (&z1, &z3, sizeof (Q)) != 0)
+ if (__builtin_memcmp (&z1, &z3, sizeof (Q)) != 0)
abort ();
- if (memcmp (&z2, &z4, sizeof (Q)) != 0)
+ if (__builtin_memcmp (&z2, &z4, sizeof (Q)) != 0)
abort ();
return 0;
abort ();
}
-main ()
+int
+main (void)
{
size_t off1, off2, len, i;
unsigned char *buf1, *buf2;
long double align_fp;
} u1, u2;
-main ()
+int
+main (void)
{
int off1, off2, len, i;
char *p, *q, c;
return 0;
}
-main ()
+int
+main (void)
{
TRIAL trial;
short *ap[2] __attribute__ ((aligned (2),packed));
} A;
-main ()
+int
+main (void)
{
short i, j = 1;
A a, *ap = &a;
return 0x1234;
}
-main ()
+int
+main (void)
{
three_char_t three_char;
char g;
};
+void
f (int n, ...)
{
struct tiny x;
va_end (ap);
}
-main ()
+int
+main (void)
{
struct tiny x[3];
x[0].c = 10;
struct s { int x, y; };
+void
f (int attr, ...)
{
struct s va_values;
va_end (va);
}
-main ()
+int
+main (void)
{
struct s a, b;
long double align_fp;
} u;
-main ()
+int
+main (void)
{
size_t off, len, len2, i;
char *p;
abort ();
}
-main ()
+int
+main (void)
{
size_t off1, off2, len, i;
unsigned char *buf1, *buf2;
struct S object = {'X', 8, 9};
-main ()
+int
+main (void)
{
if (object.f1 != 'X' || object.f2[0] != 8 || object.f2[1] != 9)
abort ();
int c:4;
} x = { 2,3,4 };
-main ()
+int
+main (void)
{
if (x.a != 2)
abort ();
unsigned int f1:1, f2:1, f3:3, f4:3, f5:2, f6:1, f7:1;
} result = {1, 1, 7, 7, 3, 1, 1};
-main ()
+int
+main (void)
{
if ((result.f3 & ~7) != 0 || (result.f4 & ~7) != 0)
abort ();
c: {1, 2, 3}
};
-main()
+int
+main(void)
{
if (s.c[0] != 1)
abort ();
X (*fp) (B, char, double, B) = &f;
-main ()
+int
+main (void)
{
X Xr;
char tmp[100];
return 0x1234;
}
-main ()
+int
+main (void)
{
three_byte_t three_byte;
void exit (int);
typedef unsigned long L;
+void
f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...)
{
va_list select;
va_end (select);
}
-main ()
+int
+main (void)
{
f (1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L, 11L, 0L);
exit (0);
va_end(ap);
}
-main ()
+int
+main (void)
{
char *f = "0123456789abcdef";
va_end(ap);
}
-main ()
+int
+main (void)
{
char *f = "0123456789abcdef";
va_end (ap);
}
-main ()
+int
+main (void)
{
static big x = { "abc" };
void abort (void);
void exit (int);
+void
va_double (int n, ...)
{
va_list args;
va_end (args);
}
+void
va_long_double (int n, ...)
{
va_list args;
va_end (args);
}
-main ()
+int
+main (void)
{
va_double (4, 3.141592, 2.71827, 2.2360679, 2.1474836);
va_long_double (4, 3.141592L, 2.71827L, 2.2360679L, 2.1474836L);
void abort (void);
void exit (int);
+void
f (int n, ...)
{
va_list args;
va_end(args);
}
-main ()
+int
+main (void)
{
f (4, 10, 10000000000LL, 11, 3.14L, 12, 13, 20000000000LL, 14, 2.72);
exit (0);
va_end(ap);
}
-main ()
+int
+main (void)
{
char *f = "0123456789abcdef";
#define zero C
#endif
-main()
+int
+main(void)
{
if (zero != 0)
abort ();
projects / thirdparty / gcc.git / commitdiff
