diff options
Diffstat (limited to 'gcc_arm/testsuite/gcc.c-torture')
965 files changed, 25542 insertions, 0 deletions
diff --git a/gcc_arm/testsuite/gcc.c-torture/ChangeLog b/gcc_arm/testsuite/gcc.c-torture/ChangeLog new file mode 100755 index 0000000..736b565 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/ChangeLog @@ -0,0 +1,797 @@ +1999-02-03 Nick Clifton <nickc@cygnus.com> + + * execute/memcheck/blkarg.c (foo): Use 10 leading arguments in + order to force structure S onto the stack even on the alpha. + (test): Pass 10 leading arguments to function foo as well as the + structure S. + + * execute/memcheck/blkarg.x: New file: Expected failure for all + targets. + + * execute/memcheck/driver.c (main): Use exit or abort to terminate + program execution. + +1999-01-28 Michael Meissner <meissner@cygnus.com> + + * execute/990128-1.c: New test. + +1999-01-27 Michael Meissner <meissner@cygnus.com> + + * execute/990127-{1,2}.c: New tests. + +1998-12-14 Nick Clifton <nickc@cygnus.com> + + * execute/920501-4.c (main): Fix typo: replace | with ||. + +1998-11-30 Nick Clifton <nickc@cygnus.com> + + * execute/981130-1.c: New test. + * execute/981130-1.x: New test failure expectations. + +Sun Oct 11 05:04:28 1998 Ken Raeburn <raeburn@cygnus.com> + + * execute/memcheck: New directory of tests for + -fcheck-memory-usage. + +1998-10-06 Ken Raeburn <raeburn@cygnus.com> + + * special/981006-1.c: New test. Make sure gcc doesn't lose track + of the possible targets of tablejump insns. + * special/special.exp: Run it. + +Thu Oct 1 17:15:26 1998 Nick Clifton <nickc@cygnus.com> + + * compile/981001-1.c: New test. + * execute/981001-1.c: New test. + +Mon Aug 31 12:00:00 1998 Catherine Moore <clm@cygnus.com> + + * execute/941014-1.x: New file. + +Wed Aug 26 16:10:00 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * execute/loop-4b.c: New test. + +Mon Aug 24 14:20:32 1998 Nick Clifton <nickc@cygnus.com> + + * execute/bcp-1.c (main): Fix optimize test loop to count number + tests in opt_t0 not good_t0. + +Thu Aug 13 00:13:55 1998 Jeffrey A Law (law@cygnus.com) + + * execute/ieee/ieee.exp: Pass -ffloat-store to compiler for + ieee tests. + +Mon Jul 27 11:05:07 1998 Nick Clifton <nickc@cygnus.com> + + * execute/ieee/930529-1.c (main): Check to see if __thumb__ is + defined, and test for ARM style doubles if so. + +Fri Jul 24 11:02:43 1998 Nick Clifton <nickc@cygnus.com> + + * execute/comp-goto-1.c (main): Make main() return an int. + +Thu Jun 18 15:12:30 1998 Michael Meissner <meissner@cygnus.com> + + * execute/980618-{1,2}.c: New tests that showed up m32r bugs. + +Fri Jun 5 21:54:26 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * execute/980605-1.c: New test. + +Sun May 31 23:23:29 1998 Michael Meissner <meissner@cygnus.com> + + * execute/ieee/mzero2.c: New test to better test IEEE -0 support. + +Wed Apr 8 13:09:15 1998 Jim Wilson <wilson@cygnus.com> + + * execute/980407-1.c: Delete test. Is duplicate of loop-4.c. + +Tue Apr 7 12:01:24 1998 Jim Wilson <wilson@cygnus.com> + + * execute/980407-1.c: New test from Joern Rennecke. + +Fri Apr 3 12:27:49 1998 Jim Wilson <wilson@cygnus.com> + + * compile/980329-1.c: New test. + +Mon Feb 23 15:16:53 1998 Robert Lipe <robertl@dgii.com> + From Bruno Haible <haible@ilog.fr>: + * execute/980223.c: New test. + +Fri Feb 6 14:30:48 1998 Jim Wilson <wilson@cygnus.com> + + * execute/980205.c: New test. + +Mon Dec 8 23:55:26 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * noncompile/noncompile.exp (921102-1.c): Fixed comment. + (940510-1.c): Removed duplicate. + (971104-1.c): New test. + +Wed Nov 19 14:27:04 1997 Michael Meissner <meissner@cygnus.com> + + * execute/950221-1.c (filler): If STACK_SIZE is defined, use that + to size the filler array. + +Wed Sep 3 17:29:35 1997 Bob Manson <manson@charmed.cygnus.com> + + * execute/ieee/ieee.exp: Check for ieee_multilib_flags target + feature; pass this to c-torture-execute as needed. + +Fri Aug 29 12:48:09 1997 Jeffrey A Law (law@cygnus.com) + + * execute/921007-1.c: Make strcmp static. + +Tue Jul 29 00:40:38 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * conversion.c (test_float_to_integer): Make double precision tests + dependent on sizeof (double). + +Tue Jun 17 22:11:16 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * compile/961203-1.cexp: New script. + +Wed Jun 4 03:38:50 1997 J"orn Rennecke <amylaar@cygnus.co.uk> + + * execute/ieee/ieee.exp: Set -mieee for SH. + +Thu May 15 14:00:04 1997 Mike Meissner <meissner@cygnus.com> + + * execute/va-arg-3.c: If NO_VARARGS is defined, nop test. + + * execute/strct-varg-1.c: If NO_VARARGS is defined, use stdargs.h + interface. + +Fri Mar 21 16:34:52 1997 Michael Meissner <meissner@cygnus.com> + + * execute/920501-7.c (main,x): If NO_LABELS_VALUES is defined, + don't do test. + +Wed Mar 19 13:06:26 1997 Michael Meissner <meissner@cygnus.com> + + * execute/ieee/rbug.c (main): Don't do long long to double + conversion if double isn't at least 8 bytes. + + * execute/cvt-1.c: Make all functions use long, not int to work + with targets where int is 16 bits. + + * execute/920715-1.c (main): If double isn't at least 8 bytes, + just exit, since 4 byte doubles don't have enough bits of + precision for the test to complete. + +Fri Mar 14 17:51:02 1997 Michael Meissner <meissner@cygnus.com> + + * execute/920715-1.cexp (d10v-*-*): Expect to fail if d10v is not + compiled with the -mdouble64 flag. + * execute/ieee/rbug.cexp (d10v-*-*): Ditto. + + * execute/cvt-1.cexp (d10v-*-*): Expect to fail if d10v is not + compiled with the -mint32 flag. + +Wed Mar 12 01:23:08 1997 Torbjorn Granlund <tege@pdc.kth.se> + + * execute/961213-1.c: New test (from hjl@lucon.org). + + * execute/complex-5.c: New test (from moshier@world.std.com). + + * execute/970217-1.c: New test (from eggert@twinsun.com). + + * execute/970214-[12].c: New tests (from eggert@twinsun.com). + + * compile/970214-1.c: New test (from wilson@cygnus.com). + + * execute/ieee/930529-1.c: Also handle arm's unusual byte/word + ordering (from amylaar@cygnus.com). + + * execute/index-1.c: Make large vars and values `long' + (from law@cygnus.com). + + * execute/941014-2.c: Declare malloc. + + * compile/970206-1.c: New test (from dje@cygnus.com). + + * execute/960521-1.c: Rewrite to take STACK_SIZE into account + (from amylaar@cygnus.co.uk). + + * execute/961223-1.c: New test (from wilson@cygnus.com). + + * compile/961203-1.c: New test (from amylaar@cygnus.co.uk). + + * compile/961126-1.c: New test (from wilson@cygnus.com). + + * execute/961125-1.c: New test (from meyering@asic.sc.ti.com). + + * execute/961122-2.c: New test (from + schwab@issan.informatik.uni-dortmund.de). + + * execute/961122-1.c: New test (from Philippe De Muyter). + + * execute/loop-2[ef].c: Default MAP_FIXED to 0 (from + amylaar@cygnus.co.uk). + + Changes from meissner@cygnus.com: + * execute/920501-9.c (print_longlong): Print pieces as a long, not int. + * execute/950915-1.c: (a,b): Make types long to prevent implicit + overflow on 16-bit systems. + * execute/dbra-1.c: Pass long values to functions expecting + long values. + * execute/950607-2.c: (Point): Make field type long, since 23250 - + (-23250) is larger than 16 bits. + * execute/960416-1.c: Make st type unsigned long, not unsigned int. + * execute/bf-sign-2.c: Make bitfields whose size is > 16 bits + long, not int for 16-bit hosts. + * execute/961017-2.c: Make z unsigned long, not unsigned int. + + * execute/cmpsi-1.c: Rewrite not to depend on type sizes. + + * execute/960909-1.c (ffs): New function (from law@cygnus.com). + + * execute/fp-cmp-1.c: Add test for SIGNAL_SUPPRESS around signal call. + Move to execute/ieee. + + * execute/970312-1.c: New test. + * execute/cvt-1.c: New test. + +Thu Feb 13 13:52:23 1997 Michael Meissner <meissner@cygnus.com> + + * compile/920301-1.c: If NO_LABEL_VALUES is defined, nop test + using labels as values extension. + * compile/920415-1.c: Ditto. + * compile/920428-3.c: Ditto. + * compile/920501-1.c: Ditto. + * compile/920501-7.c: Ditto. + * compile/941014-4.c: Ditto. + * compile/950613-1.c: Ditto. + * compile/labels-1.c: Ditto. + * execute/920302-1.c: Ditto. + * execute/920415-1.c: Ditto. + * execute/920428-2.c: Ditto. + * execute/920501-3.c: Ditto. + * execute/920501-4.c: Ditto. + * execute/920501-5.c: Ditto. + * execute/920721-4.c: Ditto. + * execute/comp-goto-1.c: Ditto. + + * compile/930506-2.c: If NO_TRAMPOLINES is defined, nop the test. + * execute/921215-1.c: Ditto. + * execute/931002-1.c: Ditto. + * execute/nestfunc-1.c: Ditto. + +Wed Jan 22 00:04:53 1997 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/961017-1.c: Add missing exit (0). + +Fri Dec 6 19:38:57 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/961206-1.c: New test. + +Wed Nov 13 17:13:05 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/loop-2[ef].c: Misc portability changes + (from amylaar@cygnus.co.uk). + +Tue Nov 12 15:00:42 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/961112-1.c: New test (based on a test by wilson@cygnus.com). + + * execute/ieee/DESC: New file. + + * execute/{loop-2[bcdef].c,loop-3[bc].c}: + New tests (from amylaar@cygnus.co.uk). + + * execute/ieee/nan.c: Delete test. + + * execute/fp-cmp-1.c: Disable for Cray and VAX. + + * execute/960416-1.c: Make it work for big-endian machines (from + amylaar@cygnus.co.uk). + +Mon Nov 11 18:00:35 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/960830-1.c: Make it work for non-x86 machines. + + * execute/961017-2.c: Call exit(0). + +Fri Nov 8 19:19:17 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/960311-3.c: #include <stdio.h>. + * execute/920501-8.c: Likewise. + * execute/920501-9.c: Likewise. + * execute/941014-2.c: Likewise. + * execute/960311-1.c: Likewise. + * execute/960311-2.c: Likewise. + + * execute/961017-[12].c: New test (from wilson@cygnus.com). + * compile/961031-1.c: New test (from wilson@cygnus.com). + * compile/961019-1.c: New test (from wilson@cygnus.com). + * utils/ctest.c: Print and pass (to run_a_test) all arguments. + * execute/{920711-1.c,920810-1.c,920922-1.c,930603-3.c,931018-1.c} + * execute/{941025-1.c,950221-1.c,950426-2.c,960209-1.c,960321-1.c} + * execute/{960327-1.c,arith-rand.c,bf-pack-1.c,cbrt.c,divconst-2.c} + * execute/memcpy-1.c: 16-bit changes (from law@cygnus.com). + + * compile/960514-1.c: New test (from rwilhelm@physik.tu-muenchen.de). + + * execute/960512-1.c: New test (from amylaar@meolyon.hanse.de). + + * execute/960513-1.c: New test (from amylaar@meolyon.hanse.de). + + * execute/960405-1.c: New test (from moshier@world.std.com). + +Fri Nov 1 13:06:28 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/dbra-1.c: New test. + +Mon Oct 28 02:31:10 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/961026-1.c: New test (from rankin@eql.caltech.edu). + + * execute/enum-1.c: New test (from law@cygnus.com). + +Tue Oct 22 22:13:12 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/960801-1.c: Generalize. + +Fri Oct 18 04:14:01 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * utils/ctest.c (run_a_test): Don't call `fatal' when the compiler + returns non-zero, but there is no error message from the compiler. + +Wed Oct 16 01:39:57 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/arith-rand.c (main): Decrease the number of iteration to + 1000. + +Fri Oct 11 16:40:44 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * compile/961010-1.c: New test (from ian@cygnus.com). + +Fri Oct 4 18:29:00 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/961004-1.c: New test (from wilson@cygnus.com). + + * compile/961004-1.c: New test (from amylaar@cygnus.co.uk). + +Thu Oct 3 02:51:24 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/fp-cmp-1.c: Move signal handler setup to after == and != + compares. + +Wed Oct 2 04:53:54 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/fp-cmp-1.c: New test. + +Mon Sep 30 01:11:06 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * compile/960620-1.c: Delete test. + +Fri Sep 13 12:12:30 1996 Ian Lance Taylor <ian@cygnus.com> + + * execute/ieee/920810-1.c: Include <stdio.h>. + +Mon Sep 9 18:56:33 1996 Torbjorn Granlund <tege@quiet.matematik.su.se> + + * execute/960909-1.c: New test. + +Fri Aug 30 06:31:25 1996 Torbjorn Granlund <tege@quiet.tmg.se> + + * execute/960830-1.c: New test. + +Thu Aug 29 22:06:49 1996 Torbjorn Granlund <tege@quiet.tmg.se> + + * compile/960829-1.c: New test. + +Tue Aug 13 19:23:06 1996 Torbjorn Granlund <tege@noisy.tmg.se> + + * utils/ctest.c (run_a_test): Call wait repeatedly until + we get back the right pid. + +Sat Aug 3 16:36:43 1996 Torbjorn Granlund <tege@noisy.tmg.se> + + * execute/960416-1.c: New test (from amylaar@meolyon.hanse.de). + + * execute/960419-[12].c: New tests (from jtc@cygnus.com). + + * execute/960416-1.c: New test (from amylaar@meolyon.hanse.de). + + * execute/920721-1.c: Make it work for 16-bit systems + (from law@cygnus.com). + * execute/920728-1.c: Likewise. + + * compile/960201-1.c: New test (from eggert@twinsun.com). + * compile/960130-1.c: New test (from eggert@twinsun.com). + +Sat Aug 3 16:10:20 1996 Andrew Cagney <cagney@highland.com.au> + + * utils/ctest.c (run_a_test): Flush output before first fork to + avoid later duplication. + + * utils/ctest.c (run_a_test): If really verbose, and a run command + was specified (-run), print the command to be executed out. + * (run_a_test): For the -run option, accept an argument list. + + * utils/ctest.c (main): Change verbose flag so it increments the + verbosity instead of just setting it. Backward compatible hack + that allows multiple levels of tracing. Perhaphs a separate flag + would be better. + (main): If really verbose, print the GCC command that is to be executed. + (run_a_test): If really verbose, print the output from compiler + and allow the output from the run to be displayed. + + * utils/ctest.c (main): New option -postopts added. This allows + the user to specify arguments that should be appended to the GCC + command (in addition to the -options flag that specfies arguments + that are to be prepended). + (usage): Adjust. + +Sat Aug 3 16:10:20 1996 Torbjorn Granlund <tege@noisy.tmg.se> + + From Mike Meissner: + * utils/ctest.c: Sort test files by calling `ls -r'. + * utils/ctest.c: Flush stdout after each printf. + * utils/ctest.c: When `-run', up timeout to 1000. Allow + explicit setting of timeout through new -cc-timeout option. + +Fri Aug 2 19:53:27 1996 Torbjorn Granlund <tege@noisy.tmg.se> + + * execute/960521-1.c: New test + (from eggert@twinsun.com and Andreas Schwab). + + * compile/960620-1.c: New test (from rwilhelm@physik.tu-muenchen.de). + + * compile/960704-1.c: New test (from wilson@cygnus.com). + + * execute/bf-sign-2.c: New test (from gavin@nando.net). + + * execute/960802-1.c: New test (from law@cygnus.com). + + * execute/960801-1.c: New test (from dje@cygnus.com). + +Sun Jun 9 17:35:56 1996 Torbjorn Granlund <tege@noisy.tmg.se> + + * execute/960608-1.c: New test (from law@cygnus.com). + +Tue Apr 2 23:18:51 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/900409-1.c: Change types from int to long + (from law@cygnus.com). + + * execute/960402-1.c: New test. + +Fri Mar 29 23:40:01 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960327-1.c: New test (from law@cygnus.com). + +Tue Mar 26 22:57:34 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960326-1.c: New test (from wilson@cygnus.com). + * execute/960321-1.c: New test (from law@cygnus.com). + * compile/960319-1.c: New test (from amylaar@meolyon.hanse.de). + * execute/960317-1.c: New test (from amylaar@meolyon.hanse.de). + * execute/960312-1.c: New test (from amylaar@meolyon.hanse.de). + * execute/960311-[123].c: New tests (from dje@cygnus.com). + * execute/960302-1.c: New test (from law@cygnus.com). + * execute/960215-1.c: New test (from moshier@world.std.com). + +Fri Mar 1 06:01:58 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/regstack-1.c: New test (from moshier@world.std.com). + * execute/960301-1.c: New test (from rankin@eql.caltech.edu). + * execute/struct-ini-4.c: New test (from wilson@cygnus.com). + +Sun Feb 25 01:10:12 1996 Paul Eggert <eggert@twinsun.com> + + * special/doit (960224-1, 960224-2): New tests. + +Wed Feb 21 07:18:19 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * compile/960221-1.c: New test (from law@cygnus.com). + * compile/960220-1.c: New test. + +Mon Feb 19 03:14:18 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960219-1.c: New test. + * compile/960218-1.c: New test (from eggert@twinsun.com). + +Sun Feb 18 04:01:54 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960218-1.c: New test. + +Sat Feb 10 03:07:04 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960209-1.c: New test (from law@cygnus.com). + +Wed Jan 24 23:23:05 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/960117-1.c: New test (from dje@cygnus.com). + * execute/960116-1.c: New test (from Philippe De Muyter). + +Mon Jan 22 23:46:17 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * noncompile/930714-1.c: Moved from compile. + +Mon Jan 22 19:08:04 1996 Paul Eggert <eggert@twinsun.com> + + * special/doit (920717-1): Make sure `not found' message is ignored + when invoking cc. + +Tue Jan 16 14:24:36 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * noncompile/951227-1.c: New test (from eggert). + * special/doit (951130-1): New test (from eggert). + * noncompile/951025-1.c: New test. + +Thu Jan 11 09:36:49 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * execute/widechar-1.c: New test (from eggert). + +Tue Jan 9 12:44:21 1996 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * compile/960106-1.c: New test. + +Mon Dec 25 19:21:08 1995 Torbjorn Granlund <tege@noisy.matematik.su.se> + + * compile/951222-1.c: New test (from kenner). + +Wed Dec 20 14:45:42 1995 Torbjorn Granlund <tege@noisy.tmg.se> + + * compile/951220-1.c: New test. + +Wed Dec 6 13:46:17 1995 Torbjorn Granlund <tege@noisy.tmg.se> + + From Alan Modra: + * utils/ctest.c (main): mktemp needs 6 X's on some systems. + +Mon Dec 4 21:39:39 1995 Torbjorn Granlund <tege@noisy.tmg.se> + + * compile/widechar-1.c: New test. + + * unsorted/{bugx.c,bugy.c,inline.c}: Delete huge/duplicate tests. + + * execute/951204-1.c: New test. + * compile/951128-1.c: New test. + +Mon Nov 27 00:16:37 1995 Torbjorn Granlund <tege@noisy.tmg.se> + + * execute/bf-layout-1.c: New test. + +Wed Nov 22 21:38:25 1995 Torbjorn Granlund <tege@noisy.tmg.se> + + * noncompile/951123-1.c: New test. + +Wed Nov 16 23:31:23 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/951116-1.c: New test. + +Wed Nov 15 20:34:03 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/ctest.c: New name for runtests.c (not to confuse it with + DejaGNU runtest). + + * utils/runtests.c (RLIMIT_CORE): Default to 4. + + * execute/951115-1.c: New test (PA delay slot filling bug). + +Tue Nov 14 00:27:10 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (run_a_test): Read from errmess pipe before + blocking on child process. Also, loop calling read(2) until pipe + is empty or 8000 chars are read. + (usage): New function. + (main): Call usage for -help. + +Sun Nov 7 17:15:12 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/951106-1.c: New test (MIPS3). + +Sun Nov 5 12:22:20 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (run_a_test): Don't print exit status for failing + noncompile test. + +Thu Oct 26 00:45:43 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (run_a_test): Save and restore filedesc for + stdout, so that failure in execve is reported properly. + From Arne Juul: + (run_a_test): To work around NetBSD bug, don't pass NULL as 2nd + execve argument. + +Wed Oct 25 16:13:46 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (main): Fix typo testing `execute_these_files'. + +Tue Oct 10 17:41:47 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950714-1.c (main): Call exit(0). + + * compile/951004-1.c: New test. + +Tue Oct 3 22:59:13 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950929-1.c: New test (from ian@cygnus.com). + + * execute/951003-1.c: New test (from dje@cygnus.com). + +Tue Sep 26 15:31:49 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950714-1.c: New test (from wilson@cygnus.com). + + * execute/950706-1.c: New test (from rearnsha) + + * execute/ieee/{minuszero.c,rbug.c,nan.c}: New tests (from moshier). + + * execute/scope-2.c: New test (from rfg). + + * execute/bf-sign-1.c: New test (from jtc@cygnus.com). + + * noncompile/930927-1.c: Delete this duplicated test. + + * unsorted/gdb.c: Delete this test. + * */*.c: Delete whitespace at the end of lines. + + * execute/loop-3.c: New test (from amylaar@meolyon.hanse.de). + +Mon Sep 25 14:08:32 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * Make file permissions be regular. + + * utils/runtests.c (main): Combine `flag_execute' and + `execute_these_files' into the latter. + (run_a_test): Test only `execute_these_files'. + + * execute/920411-1.c: Generalize to work even for big-endian + 64-bit machines (from amylaar@meolyon.hanse.de). + +Sun Sep 24 16:26:03 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (set_watchdog): Actually use `seconds' parameter. + +Sat Sep 23 00:08:33 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/950922-1.c: New test. + +Thu Sep 21 12:25:40 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * utils/runtests.c (environ): Declare. + (run_a_test): Pass environ to execve calls. + (main): Don't NULL-terminate `passes' array. + (main): Make ii loop's termination condition depend on n_passes. + (run_a_test): Check result from read; '\0'-terminate buf. + (main): Avoid d_namlen, use strlen of d_name instead (from meyering). + + * compile/950919-1.c: New test. + + * execute/conversion.c (test_longlong_integer_to_float): Modify + some tests conditionally for __HAVE_68881__. + + * execute/950915-1.c: New test. + + * utils/runtests.c: New file to run tests faster. + * {execute/compile/unsorted/noncompile}/DESC: New files. + + * compile/950921-1.c: New test (from Ian Taylor). + +Wed Sep 20 14:53:33 1995 Doug Evans <dje@canuck.cygnus.com> + + * execute/920501-7.c (STACK_SIZE): Check for and use to limit + depth of recursion. + +Mon Sep 18 23:43:28 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/gcc-failure/940409-1.c: Moved from compile. + + * execute/920411-1.c: Moved from execute/gcc_failure. + * execute/gcc_failure/920627-2.c: Delete spurious test. + + * utils/runtests.c: New program. + +Tue Sep 12 22:05:15 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/divconst-3.c: New test. + +Mon Sep 11 12:48:04 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compat/struct-ret-1.c: Add prototype for f. + * compat/strct-layout.c: Conditionalize main. + +Sun Sep 10 20:47:34 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/strct-pack-5.c: Delete, test is useless because of + lack of 68k structure packing. + +Thu Sep 7 13:07:40 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/{930628-1.c,941202-1.c,arith-1.c,gofast.c,struct-ret-1.c, + va-arg-4.c}: Call exit(0), don't do return 0. + +Tue Sep 5 15:23:14 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compat/strct-layout.c (main): Add missing call to exit. + +Tue Sep 5 15:23:14 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + 1.35 Released. + + * noncompile/doit (case $arg): Fix typo. + + * execute/compndlit-1.c: New test. + * execute/loop-2.c: New test. + * execute/950809-1.c: New test. + * execute/va-arg-5.c: New test. + * execute/va-arg-6.c: New test. + * execute/ptr-arith-1.c: New test. + * execute/cmpsi-1.c: New test. + + * compile/cmpdi-1.c: New test. + * compile/950719-1.c: New test. + * compile/950729-1.c: New test. + * compile/950816-[123].c: New test. + * compile/: New test. + * compile/: New test. + * compile/: New test. + * compile/: New test. + +Fri Sep 5 09:30:32 1995 Michael Meissner <meissner@tiktok.cygnus.com> + + * */doit: Add -run <cmd> option to allow the use of a simulator to + run commands in the execute subdirectory. Accept the switch in + the other doit commands. + +Tue Jul 11 01:02:21 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950710-1.c: New test (from meyering). + +Wed Jul 5 16:03:45 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/950618-1.c: New test. + * execute/scope-1.c: New test. + * execute/950621-1.c: New test. + * execute/950704-1.c: New test. + * execute/950628-1.c: New test. + +Wed Jun 14 15:20:44 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950612-1.c: New test. + * execute/cmpdi-1.c: New test. + * execute/tstdi-1.c: New test. + * compile/950613-1.c: New test. + * compile/950530-1.c: New test. + * compile/950610-1.c: New test. + * compile/950612-1.c: New test. + + * execute/strct-pack-5.c: Clean up, use defined type s2_t. + * execute/strct-pack-4.c: Clean up. + +Sat Jun 10 12:37:22 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/cbrt.c: Disable for vax. + +Fri Jun 9 21:49:58 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/940115-1.c: Cast parameters to char *. + +Thu Jun 8 00:33:51 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * compile/950607-1.c: New test. + * execute/cbrt.c: New test. + * execute/950607-[12].c: New tests. + * execute/memcpy-1.c: Try more cases. + * execute/struct-ret-2.c: New test. + * execute/complex-4.c: New test. + +Wed Jun 7 12:40:05 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/950601.c: Delete this messy and redundant test. + + * compile/funcptr-1.c: Clean up. + + * execute/950512-1.c (main): Call f1 and f2 with 0 too. + (f2): Use type `long long', not `long'. + + * execute/950605-1.c: New test. + +Wed Jun 1 01:57:45 1995 Torbjorn Granlund <tege@bozo.matematik.su.se> + + * execute/divconst-[12].c: New tests. diff --git a/gcc_arm/testsuite/gcc.c-torture/ChangeLog.Cygnus b/gcc_arm/testsuite/gcc.c-torture/ChangeLog.Cygnus new file mode 100755 index 0000000..c6bf575 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/ChangeLog.Cygnus @@ -0,0 +1,6 @@ +1998-12-17 Nick Clifton <nickc@cygnus.com> + + * special/special.exp: Suppress use of -fpic when compiling + special/981006-1 for the FR30. + + diff --git a/gcc_arm/testsuite/gcc.c-torture/code_quality/920608-1.c b/gcc_arm/testsuite/gcc.c-torture/code_quality/920608-1.c new file mode 100755 index 0000000..cae1978 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/code_quality/920608-1.c @@ -0,0 +1,25 @@ +foo (p) + int *p; +{ + int x; + int a; + + a = p[0]; + x = a + 5; + a = -1; + p[0] = x - 5; + return a; +} + +bar (p) +{ + short x; + int a; + + x = ((short *) p)[1]; +#if INHIBIT_COMBINE + ((short *) p)[0] = x; +#endif + + return (x < 45); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/code_quality/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/code_quality/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/code_quality/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/code_quality/code_quality.exp b/gcc_arm/testsuite/gcc.c-torture/code_quality/code_quality.exp new file mode 100755 index 0000000..b8b72ea --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/code_quality/code_quality.exp @@ -0,0 +1,55 @@ +# +# Expect driver script for GCC Regression Tests +# Copyright (C) 1993, 1997 Free Software Foundation +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# +# Written by Jeffrey Wheat (cassidy@cygnus.com) +# + +# +# These tests come from Torbjorn Granlund's (tege@cygnus.com) +# C torture test suite, and other contributors. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +# +# This loop will run c-torture on any *.c file found in this directory. +# If a *.c has a corresponding *.exp file, then the test is skipped as +# as the *.exp will drive the test itself. I did things this way so that +# generic tests did not need a seperate .exp for it. Only the tests that +# required unique options would need it's own .exp file. +# + +foreach testcase [glob -nocomplain $srcdir/$subdir/*.c] { + if [file exists [file rootname $testcase].exp] then { + verbose "INFO:\"[file rootname $testcase].exp\" exists, skipping test" 3 + continue + } + + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $testcase] then { + continue + } + + c-torture $testcase +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/code_quality/configure.in b/gcc_arm/testsuite/gcc.c-torture/code_quality/configure.in new file mode 100755 index 0000000..0fb5342 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/code_quality/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=code_quality.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/compat/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/configure.in b/gcc_arm/testsuite/gcc.c-torture/compat/configure.in new file mode 100755 index 0000000..a4a5810 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=struct-big.c +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/strct-layout.c b/gcc_arm/testsuite/gcc.c-torture/compat/strct-layout.c new file mode 100755 index 0000000..b77e163 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/strct-layout.c @@ -0,0 +1,69 @@ +typedef struct +{ + char a; + int b; + char c; + short d; + double e; + char f; +} T; + +#if COMPILER != 1 +f (T *x) +{ + x[0].a = 'a'; + x[0].b = 47114711; + x[0].c = 'c'; + x[0].d = 1234; + x[0].e = 3.141592897932; + x[0].f = '*'; + + x[1].a = 'A'; + x[1].b = 71417141; + x[1].c = 'C'; + x[1].d = 4321; + x[1].e = 2.718281828459; + x[1].f = '?'; +} +#endif + +#if COMPILER != 2 +g (T *x) +{ + if (x[0].a != 'a') + abort (); + if (x[0].b != 47114711) + abort (); + if (x[0].c != 'c') + abort (); + if (x[0].d != 1234) + abort (); + if (x[0].e != 3.141592897932) + abort (); + if (x[0].f != '*') + abort (); + + if (x[1].a != 'A') + abort (); + if (x[1].b != 71417141) + abort (); + if (x[1].c != 'C') + abort (); + if (x[1].d != 4321) + abort (); + if (x[1].e != 2.718281828459) + abort (); + if (x[1].f != '?') + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + T x[2]; + f (x); + g (x); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-align.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-align.c new file mode 100755 index 0000000..69fe6b3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-align.c @@ -0,0 +1,52 @@ +typedef union +{ + struct {int a; int b;} s; + double d; +} T; + +int h (T *); +T g (T); + +#if COMPILER != 1 +h (T *x) +{ + if (x->s.a != 0 || x->s.b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +T +g (T x) +{ + if (x.s.a != 13 || x.s.b != 47) + abort (); + x.s.a = 0; + x.s.b = 1; + h (&x); + return x; +} +#endif + +#if COMPILER != 1 +f () +{ + T x; + x.s.a = 13; + x.s.b = 47; + g (x); + if (x.s.a != 13 || x.s.b != 47) + abort (); + x = g (x); + if (x.s.a != 0 || x.s.b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + f (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-big.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-big.c new file mode 100755 index 0000000..e1d5c6a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-big.c @@ -0,0 +1,54 @@ +typedef struct {int a, b, c, d, e;} T; + +int h (T *); +T g (T); + +#if COMPILER != 1 +h (T *x) +{ + if (x->a != 0 || x->b != 1 || x->c != 2 || x->d != 3 || x->e != 4) + abort (); +} +#endif + +#if COMPILER != 2 +T +g (T x) +{ + if (x.a != 13 || x.b != 47 || x.c != 123456 || x.d != -4711 || x.e != -2) + abort (); + x.a = 0; + x.b = 1; + x.c = 2; + x.d = 3; + x.e = 4; + h (&x); + return x; +} +#endif + +#if COMPILER != 1 +f () +{ + T x; + x.a = 13; + x.b = 47; + x.c = 123456; + x.d = -4711; + x.e = -2; + g (x); + if (x.a != 13 || x.b != 47 || x.c != 123456 || x.d != -4711 || x.e != -2) + abort (); + x = g (x); + if (x.a != 0 || x.b != 1 || x.c != 2 || x.d != 3 || x.e != 4) + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + f (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-i.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-i.c new file mode 100755 index 0000000..25cbee6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-i.c @@ -0,0 +1,46 @@ +typedef struct {int a;} T; + +int h (T *); +T g (T); + +#if COMPILER != 1 +h (T *x) +{ + if (x->a != 47114711) + abort (); +} +#endif + +#if COMPILER != 2 +T +g (T x) +{ + if (x.a != 13) + abort (); + x.a = 47114711; + h (&x); + return x; +} +#endif + +#if COMPILER != 1 +f () +{ + T x; + x.a = 13; + g (x); + if (x.a != 13) + abort (); + x = g (x); + if (x.a != 47114711) + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + f (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-ic.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ic.c new file mode 100755 index 0000000..7c5fa79 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ic.c @@ -0,0 +1,48 @@ +typedef struct {int a; char b;} T; + +int h (T *); +T g (T); + +#if COMPILER != 1 +h (T *x) +{ + if (x->a != 0 || x->b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +T +g (T x) +{ + if (x.a != 13 || x.b != 47) + abort (); + x.a = 0; + x.b = 1; + h (&x); + return x; +} +#endif + +#if COMPILER != 1 +f () +{ + T x; + x.a = 13; + x.b = 47; + g (x); + if (x.a != 13 || x.b != 47) + abort (); + x = g (x); + if (x.a != 0 || x.b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + f (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-ii.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ii.c new file mode 100755 index 0000000..11ebc37 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ii.c @@ -0,0 +1,48 @@ +typedef struct {int a, b;} T; + +int h (T *); +T g (T); + +#if COMPILER != 1 +h (T *x) +{ + if (x->a != 0 || x->b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +T +g (T x) +{ + if (x.a != 13 || x.b != 47) + abort (); + x.a = 0; + x.b = 1; + h (&x); + return x; +} +#endif + +#if COMPILER != 1 +f () +{ + T x; + x.a = 13; + x.b = 47; + g (x); + if (x.a != 13 || x.b != 47) + abort (); + x = g (x); + if (x.a != 0 || x.b != 1) + abort (); +} +#endif + +#if COMPILER != 2 +main () +{ + f (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compat/struct-ret-1.c b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ret-1.c new file mode 100755 index 0000000..a585c8f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compat/struct-ret-1.c @@ -0,0 +1,25 @@ +typedef struct { int re; int im; } T; + +T f (int, int); + +#if COMPILER != 1 +T +f (int arg1, int arg2) +{ + T x; + x.re = arg1; + x.im = arg2; + return x; +} +#endif + +#if COMPILER != 2 +main () +{ + T result; + result = f (3, 4); + if (result.re != 3 || result.im != 4) + abort (); + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/900116-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/900116-1.c new file mode 100755 index 0000000..37c7eb7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/900116-1.c @@ -0,0 +1,14 @@ +struct st {char a, b, c, d; } + +zloop (struct st *s, int *p, int *q) +{ + int i; + struct st ss; + + for (i = 0; i < 100; i++) + { + ss = s[i]; + p[i] = ss.c; + q[i] = ss.b; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/900216-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/900216-1.c new file mode 100755 index 0000000..8a4bfb7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/900216-1.c @@ -0,0 +1,9 @@ +foo (p, a, b) + unsigned short *p; +{ + unsigned int x; + + x = p[0]; + + return (x == 134U); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/900313-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/900313-1.c new file mode 100755 index 0000000..f2bc40d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/900313-1.c @@ -0,0 +1,172 @@ +main () +{ + char *a; + foo (alloca (10000)); + foo (alloca (100000)); + foo (alloca ((int) &main)); +} + +many_par (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) +{ + char *x; + int aa, ba, ca, da, ea, fa, ga, ha, ia, ja, ka, la, ma, na, oa, pa; + + aa = bar (); + ba = bar (); + ca = bar (); + da = bar (); + ea = bar (); + fa = bar (); + ga = bar (); + ha = bar (); + ia = bar (); + ja = bar (); + ka = bar (); + la = bar (); + ma = bar (); + na = bar (); + oa = bar (); + pa = bar (); + foobar (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, aa, ba, ca, + da, ea, fa, ga, ha, ia, ja, ka, la, ma, na, oa, pa); + +} + +foobar (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, aa, ba, ca, + da, ea, fa, ga, ha, ia, ja, ka, la, ma, na, oa, pa) +{ + int ab, bb, cb, db, eb, fb, gb, hb, ib, jb, kb, lb, mb, nb, ob, pb; + int qb, rb, sb, tb, ub, vb, xb, yb; + + ab = bar (); + bb = bar (); + cb = bar (); + db = bar (); + eb = bar (); + fb = bar (); + gb = bar (); + hb = bar (); + ib = bar (); + jb = bar (); + kb = bar (); + lb = bar (); + mb = bar (); + nb = bar (); + ob = bar (); + pb = bar (); + qb = bar (); + rb = bar (); + sb = bar (); + tb = bar (); + ub = bar (); + vb = bar (); + xb = bar (); + yb = bar (); + + boofar (a); + boofar (b); + boofar (c); + boofar (d); + boofar (e); + boofar (f); + boofar (g); + boofar (h); + boofar (i); + boofar (j); + boofar (k); + boofar (l); + boofar (m); + boofar (n); + boofar (o); + boofar (p); + boofar (aa); + boofar (ba); + boofar (ca); + boofar (da); + boofar (ea); + boofar (fa); + boofar (ga); + boofar (ha); + boofar (ia); + boofar (ja); + boofar (ka); + boofar (la); + boofar (ma); + boofar (na); + boofar (oa); + boofar (pa); + + boofar (ab); + boofar (bb); + boofar (cb); + boofar (db); + boofar (eb); + boofar (fb); + boofar (gb); + boofar (hb); + boofar (ib); + boofar (jb); + boofar (kb); + boofar (lb); + boofar (mb); + boofar (nb); + boofar (ob); + boofar (pb); + + boofar (a); + boofar (b); + boofar (c); + boofar (d); + boofar (e); + boofar (f); + boofar (g); + boofar (h); + boofar (i); + boofar (j); + boofar (k); + boofar (l); + boofar (m); + boofar (n); + boofar (o); + boofar (p); + boofar (aa); + boofar (ba); + boofar (ca); + boofar (da); + boofar (ea); + boofar (fa); + boofar (ga); + boofar (ha); + boofar (ia); + boofar (ja); + boofar (ka); + boofar (la); + boofar (ma); + boofar (na); + boofar (oa); + boofar (pa); + + boofar (ab); + boofar (bb); + boofar (cb); + boofar (db); + boofar (eb); + boofar (fb); + boofar (gb); + boofar (hb); + boofar (ib); + boofar (jb); + boofar (kb); + boofar (lb); + boofar (mb); + boofar (nb); + boofar (ob); + boofar (pb); + +} + +test_exit_ignore_stack () +{ + foobar (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/900407-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/900407-1.c new file mode 100755 index 0000000..fdf4779 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/900407-1.c @@ -0,0 +1,10 @@ +foo (a, b, p) + int *p; +{ + int c; + p[1] = a + 0x1000; + c = b + 0xffff0000; + if ((b + 0xffff0000) == 0) + c++; + p[2] = c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/900516-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/900516-1.c new file mode 100755 index 0000000..69e9614 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/900516-1.c @@ -0,0 +1 @@ +f(c){return!(c?2.0:1.0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920301-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920301-1.c new file mode 100755 index 0000000..c4d663e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920301-1.c @@ -0,0 +1,4 @@ +#ifndef NO_LABEL_VALUES +f(){static void*t[]={&&x};x:;} +#endif +g(){static unsigned p[5];} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920409-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920409-1.c new file mode 100755 index 0000000..b96ec53 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920409-1.c @@ -0,0 +1 @@ +x(){int y;y>0.0?y:y-1;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920409-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920409-2.c new file mode 100755 index 0000000..ef2bdb8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920409-2.c @@ -0,0 +1,2 @@ +double x(){int x1,x2;double v; +if(((long)(x1-x2))<1)return -1.0;v=t(v);v=y(1,v>0.0?(int)v:((int)v-1));} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920410-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920410-1.c new file mode 100755 index 0000000..4bfa7a6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920410-1.c @@ -0,0 +1,30 @@ +int alloc_float(f) + float f; +{ union + { + float f; + int i; + } + u; + u.f=f; + return u.i&~1; +} + +float c_float(int obj) +{ union + { + float f; + int i; + } u; + + u.i=obj; + return u.f; +} + +main() +{ int x=alloc_float(1.2); + int y=alloc_float(5.7); + int z=alloc_float(c_float(x)*c_float(y)); + + printf("%g\n",(double)c_float(z)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920410-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920410-2.c new file mode 100755 index 0000000..958aae9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920410-2.c @@ -0,0 +1,12 @@ +joe() +{ + int j; + + while( 1 ) + { + for( j = 0; j < 4; j++ ) + ; + for( j = 0; j < 4; j++ ) + ; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920411-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920411-2.c new file mode 100755 index 0000000..0cc13c8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920411-2.c @@ -0,0 +1 @@ +x(){int n;double x;n=x<1?n:n+1;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920413-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920413-1.c new file mode 100755 index 0000000..45b5fc5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920413-1.c @@ -0,0 +1,2 @@ +union u {double d;long long ll;}; +f(double x, int n){union u v;v.d=x;if(n>=0){v.ll<<=63;}else{v.ll+=1<<-n;v.ll>>=-n;}return v.ll;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920415-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920415-1.c new file mode 100755 index 0000000..8d9bc06 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920415-1.c @@ -0,0 +1,17 @@ +#ifndef NO_LABEL_VALUES +f () +{ + __label__ l; + void *x() + { + return &&l; + } + goto *x (); + abort (); + return; + l: + exit (0); +} +#else +int x; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-1.c new file mode 100755 index 0000000..fdc478a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-1.c @@ -0,0 +1 @@ +x(){char*q;return(long)q>>8&0xff;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-2.c new file mode 100755 index 0000000..23f32a8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-2.c @@ -0,0 +1,531 @@ +double sin(double x); +double cos(double x); +double tan(double x); +double asin(double x); +double acos(double x); +double atan(double x); +double atan2(double y, double x); +double sinh(double x); +double cosh(double x); +double tanh(double x); +double exp(double x); +double expm1(double x); +double log(double x); +double log10(double x); +double log1p(double x); +double pow(double x, double y); +double sqrt(double x); +double cbrt(double x); +double ceil(double x); +double floor(double x); +double fabs(double x); +double frexp(double value, int *eptr); +double ldexp(double value, int exp); +double modf(double value, double *iptr); +double erf(double x); +double erfc(double x); +double atof(const char *nptr); +double hypot(double x, double y); +double lgamma(double x); +double j0(double x); +double j1(double x); +double jn(int n, double x); +double y0(double x); +double y1(double x); +double yn(int n, double x); +extern struct _iobuf { + int _cnt; + char *_ptr; + char *_base; + int _bufsiz; + short _flag; + char _file; +} _iob[]; +typedef unsigned long size_t; +typedef char *va_list; +struct _iobuf *fopen(const char *filename, const char *type); +struct _iobuf *freopen(const char *filename, const char *type, struct _iobuf *stream); +struct _iobuf *fdopen(int fildes, const char *type); +struct _iobuf *popen(const char *command, const char *type); +int pclose(struct _iobuf *stream); +int fflush(struct _iobuf *stream); +int fclose(struct _iobuf *stream); +int remove(const char *path); +int rename(const char *from, const char *to); +struct _iobuf *tmpfile(void); +char *tmpnam(char *s); +int setvbuf(struct _iobuf *iop, char *buf, int type, size_t size); +int setbuf(struct _iobuf *stream, char *buf); +int setbuffer(struct _iobuf *stream, char *buf, size_t size); +int setlinebuf(struct _iobuf *stream); +int fprintf(struct _iobuf *stream, const char *format, ...); +int printf(const char *format, ...); +char *sprintf(char *s, const char *format, ...); +int vfprintf(struct _iobuf *stream, const char *format, va_list arg); +int vprintf(const char *format, va_list arg); +int vsprintf(char *s, const char *format, va_list arg); +int fscanf(struct _iobuf *stream, const char *format, ...); +int scanf(const char *format, ...); +int sscanf(char *s, const char *format, ...); +int fgetc(struct _iobuf *stream); +int getw(struct _iobuf *stream); +char *fgets(char *s, int n, struct _iobuf *stream); +char *gets(char *s); +int fputc(int c, struct _iobuf *stream); +int putw(int w, struct _iobuf *stream); +int fputs(const char *s, struct _iobuf *stream); +int puts(const char *s); +int ungetc(int c, struct _iobuf *stream); +int fread(void *ptr, size_t size, size_t count, struct _iobuf *iop); +int fwrite(const void *ptr, size_t size, size_t count, struct _iobuf *iop); +int fseek(struct _iobuf *stream, long offset, int ptrname); +long ftell(struct _iobuf *stream); +void rewind(struct _iobuf *stream); +int fgetpos(struct _iobuf *stream, long *pos); +int fsetpos(struct _iobuf *stream, const long *pos); +void perror(const char *s); +typedef unsigned char byte; +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned long ulong; +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef unsigned long u_long; +typedef unsigned short ushort_; +typedef struct _physadr { int r[1]; } *physadr; +typedef struct label_t { + int val[11]; +} label_t; +typedef struct _quad { long val[2]; } quad; +typedef long daddr_t; +typedef char * caddr_t; +typedef u_long ino_t; +typedef long swblk_t; +typedef long time_t; +typedef short dev_t; +typedef long off_t; +typedef u_short uid_t; +typedef u_short gid_t; +typedef signed char prio_t; +typedef long fd_mask; +typedef struct fd_set { + fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ]; +} fd_set; +typedef struct qhdr { + struct qhdr *link, *rlink; +} *queue_t; +typedef char *ptr_ord_t; +typedef double floatp; +typedef char *(*proc_alloc_t)(unsigned num_elements, unsigned element_size, const char *client_name ); +typedef void (*proc_free_t)(char *data, unsigned num_elements, unsigned element_size, const char *client_name ); +extern struct _iobuf *gs_out; +typedef struct gs_point_s { + double x, y; +} gs_point; +typedef struct gs_int_point_s { + int x, y; +} gs_int_point; +typedef struct gs_rect_s { + gs_point p, q; +} gs_rect; +typedef struct gs_int_rect_s { + gs_int_point p, q; +} gs_int_rect; +typedef struct gs_state_s gs_state; +typedef struct { + proc_alloc_t alloc; + proc_free_t free; +} gs_memory_procs; +char *gs_malloc(uint, uint, const char * ); +void gs_free(char *, uint, uint, const char * ); +extern char gs_debug[128]; +extern int gs_log_error(int, const char *, int ); +typedef long fixed; +typedef struct gs_fixed_point_s { + fixed x, y; +} gs_fixed_point; +typedef struct gs_fixed_rect_s { + gs_fixed_point p, q; +} gs_fixed_rect; +typedef struct gs_matrix_s { + long _xx; float xx; long _xy; float xy; long _yx; float yx; long _yy; float yy; long _tx; float tx; long _ty; float ty; +} gs_matrix; +void gs_make_identity(gs_matrix * ); +int gs_make_translation(floatp, floatp, gs_matrix * ), + gs_make_scaling(floatp, floatp, gs_matrix * ), + gs_make_rotation(floatp, gs_matrix * ); +int gs_matrix_multiply(const gs_matrix *, const gs_matrix *, gs_matrix * ), + gs_matrix_invert(const gs_matrix *, gs_matrix * ), + gs_matrix_rotate(const gs_matrix *, floatp, gs_matrix * ); +int gs_point_transform(floatp, floatp, const gs_matrix *, gs_point * ), + gs_point_transform_inverse(floatp, floatp, const gs_matrix *, gs_point * ), + gs_distance_transform(floatp, floatp, const gs_matrix *, gs_point * ), + gs_distance_transform_inverse(floatp, floatp, const gs_matrix *, gs_point * ), + gs_bbox_transform_inverse(gs_rect *, gs_matrix *, gs_rect * ); +typedef struct gs_matrix_fixed_s { + long _xx; float xx; long _xy; float xy; long _yx; float yx; long _yy; float yy; long _tx; float tx; long _ty; float ty; + fixed tx_fixed, ty_fixed; +} gs_matrix_fixed; +extern void gs_update_matrix_fixed(gs_matrix_fixed * ); +int gs_point_transform2fixed(gs_matrix_fixed *, floatp, floatp, gs_fixed_point * ), + gs_distance_transform2fixed(gs_matrix_fixed *, floatp, floatp, gs_fixed_point * ); +typedef struct { + long xx, xy, yx, yy; + int skewed; + int shift; + int max_bits; + fixed round; +} fixed_coeff; + +typedef enum { + gs_cap_butt = 0, + gs_cap_round = 1, + gs_cap_square = 2 +} gs_line_cap; +typedef enum { + gs_join_miter = 0, + gs_join_round = 1, + gs_join_bevel = 2 +} gs_line_join; +gs_state *gs_state_alloc(proc_alloc_t, proc_free_t ); +int gs_state_free(gs_state * ); +int gs_gsave(gs_state * ), + gs_grestore(gs_state * ), + gs_grestoreall(gs_state * ); +gs_state *gs_gstate(gs_state * ); +int gs_currentgstate(gs_state * , const gs_state * ), + gs_setgstate(gs_state * , const gs_state * ); +gs_state *gs_state_swap_saved(gs_state *, gs_state * ); +void gs_state_swap(gs_state *, gs_state * ); +int gs_initgraphics(gs_state * ); +typedef struct gx_device_s gx_device; +int gs_flushpage(gs_state * ); +int gs_copypage(gs_state * ); +int gs_output_page(gs_state *, int, int ); +int gs_copyscanlines(gx_device *, int, byte *, uint, int *, uint * ); +gx_device * gs_getdevice(int ); +int gs_copydevice(gx_device **, gx_device *, proc_alloc_t ); +int gs_makeimagedevice(gx_device **, gs_matrix *, uint, uint, byte *, int, proc_alloc_t ); +void gs_nulldevice(gs_state * ); +int gs_setdevice(gs_state *, gx_device * ); +gx_device * gs_currentdevice(gs_state * ); +const char * gs_devicename(gx_device * ); +void gs_deviceinitialmatrix(gx_device *, gs_matrix * ); +int gs_closedevice(gx_device * ); +int gs_setlinewidth(gs_state *, floatp ); +float gs_currentlinewidth(const gs_state * ); +int gs_setlinecap(gs_state *, gs_line_cap ); +gs_line_cap gs_currentlinecap(const gs_state * ); +int gs_setlinejoin(gs_state *, gs_line_join ); +gs_line_join gs_currentlinejoin(const gs_state * ); +int gs_setmiterlimit(gs_state *, floatp ); +float gs_currentmiterlimit(const gs_state * ); +int gs_setdash(gs_state *, const float *, uint, floatp ); +uint gs_currentdash_length(const gs_state * ); +int gs_currentdash_pattern(const gs_state *, float * ); +float gs_currentdash_offset(const gs_state * ); +int gs_setflat(gs_state *, floatp ); +float gs_currentflat(const gs_state * ); +int gs_setstrokeadjust(gs_state *, int ); +int gs_currentstrokeadjust(const gs_state * ); +typedef enum { + gs_color_space_DeviceGray = 0, + gs_color_space_DeviceRGB, + gs_color_space_DeviceCMYK +} gs_color_space; +typedef struct gs_color_s gs_color; +extern const uint gs_color_sizeof; +int gs_setgray(gs_state *, floatp ); +float gs_currentgray(gs_state * ); +int gs_sethsbcolor(gs_state *, floatp, floatp, floatp ), + gs_currenthsbcolor(gs_state *, float [3] ), + gs_setrgbcolor(gs_state *, floatp, floatp, floatp ), + gs_currentrgbcolor(gs_state *, float [3] ); +int gs_currentcolorspace(gs_state *, gs_color_space * ); +typedef float (*gs_transfer_proc)(gs_state *, floatp ); +int gs_settransfer(gs_state *, gs_transfer_proc ), + gs_settransfer_remap(gs_state *, gs_transfer_proc, int ); +gs_transfer_proc gs_currenttransfer(gs_state * ); +int gs_setcolortransfer(gs_state *, gs_transfer_proc , + gs_transfer_proc , gs_transfer_proc , + gs_transfer_proc ), + gs_setcolortransfer_remap(gs_state *, gs_transfer_proc , + gs_transfer_proc , gs_transfer_proc , + gs_transfer_proc , int ); +void gs_currentcolortransfer(gs_state *, gs_transfer_proc [4] ); +int gs_setscreen(gs_state *, floatp, floatp, float (*)(floatp, floatp ) ); +int gs_currentscreen(gs_state *, float *, float *, float (**)(floatp, floatp ) ); +int gs_sethalftonephase(gs_state *, int, int ); +int gs_currenthalftonephase(gs_state *, gs_int_point * ); +typedef struct gs_screen_enum_s gs_screen_enum; +extern const uint gs_screen_enum_sizeof; +int gs_screen_init(gs_screen_enum *, gs_state *, floatp, floatp ); +int gs_screen_currentpoint(gs_screen_enum *, gs_point * ); +int gs_screen_next(gs_screen_enum *, floatp ); +struct gs_state_s { + gs_state *saved; + gs_memory_procs memory_procs; + gs_matrix_fixed ctm; + gs_matrix ctm_inverse; + int inverse_valid; + struct gx_path_s *path; + struct gx_clip_path_s *clip_path; + int clip_rule; + struct line_params_s *line_params; + struct halftone_params_s *halftone; + float (*ht_proc)(floatp, floatp ); + gs_int_point ht_phase; + gs_int_point phase_mod; + struct gs_color_s *color; + struct gx_device_color_s *dev_color; + struct gx_transfer_s *transfer; + struct gs_font_s *font; + gs_matrix char_tm; + int char_tm_valid; + byte in_cachedevice; + byte in_charpath; + + + + + int level; + float flatness; + int stroke_adjust; + struct device_s *device; + int device_is_shared; + +}; +typedef unsigned long gx_bitmap_id; +typedef struct gx_bitmap_s { + byte *data; + int raster; + gs_int_point size; + gx_bitmap_id id; + ushort rep_width, rep_height; +} gx_bitmap; +typedef unsigned long gx_color_index; +typedef unsigned short gx_color_value; +typedef struct gx_device_color_info_s { + int num_components; + + int depth; + gx_color_value max_gray; + gx_color_value max_rgb; + + gx_color_value dither_gray; + gx_color_value dither_rgb; + +} gx_device_color_info; +typedef struct gx_device_procs_s gx_device_procs; +struct gx_device_s { + int params_size; gx_device_procs *procs; const char *dname; int width; int height; float x_pixels_per_inch; float y_pixels_per_inch; float l_margin, b_margin, r_margin, t_margin; gx_device_color_info color_info; int is_open; +}; +typedef struct gs_prop_item_s gs_prop_item; +struct gx_device_procs_s { + int (*open_device)(gx_device *dev ); + void (*get_initial_matrix)(gx_device *dev, gs_matrix *pmat ); + int (*sync_output)(gx_device *dev ); + int (*output_page)(gx_device *dev, int num_copies, int flush ); + int (*close_device)(gx_device *dev ); + gx_color_index (*map_rgb_color)(gx_device *dev, gx_color_value red, gx_color_value green, gx_color_value blue ); + int (*map_color_rgb)(gx_device *dev, gx_color_index color, gx_color_value rgb[3] ); + int (*fill_rectangle)(gx_device *dev, int x, int y, int width, int height, gx_color_index color ); + int (*tile_rectangle)(gx_device *dev, gx_bitmap *tile, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1, int phase_x, int phase_y ); + int (*copy_mono)(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1 ); + int (*copy_color)(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height ); + int (*draw_line)(gx_device *dev, int x0, int y0, int x1, int y1, gx_color_index color ); + int (*get_bits)(gx_device *dev, int y, unsigned char *data, unsigned int size, int pad_to_word ); + int (*get_props)(gx_device *dev, gs_prop_item *plist ); + + int (*put_props)(gx_device *dev, gs_prop_item *plist, int count ); + +}; +extern unsigned int gx_device_bytes_per_scan_line(gx_device *dev, int pad_to_word ); +int gx_default_open_device(gx_device *dev ); +void gx_default_get_initial_matrix(gx_device *dev, gs_matrix *pmat ); +int gx_default_sync_output(gx_device *dev ); +int gx_default_output_page(gx_device *dev, int num_copies, int flush ); +int gx_default_close_device(gx_device *dev ); +gx_color_index gx_default_map_rgb_color(gx_device *dev, gx_color_value red, gx_color_value green, gx_color_value blue ); +int gx_default_map_color_rgb(gx_device *dev, gx_color_index color, gx_color_value rgb[3] ); +int gx_default_tile_rectangle(gx_device *dev, gx_bitmap *tile, int x, int y, int width, int height, gx_color_index color0, gx_color_index color1, int phase_x, int phase_y ); +int gx_default_copy_color(gx_device *dev, unsigned char *data, int data_x, int raster, gx_bitmap_id id, int x, int y, int width, int height ); +int gx_default_draw_line(gx_device *dev, int x0, int y0, int x1, int y1, gx_color_index color ); +int gx_default_get_bits(gx_device *dev, int y, unsigned char *data, unsigned int size, int pad_to_word ); +int gx_default_get_props(gx_device *dev, gs_prop_item *plist ); +int gx_default_put_props(gx_device *dev, gs_prop_item *plist, int count ); +typedef struct device_s { + gx_device *info; + int is_band_device; + gx_color_index white, black; +} device; +int gs_initmatrix(gs_state * ), + gs_defaultmatrix(const gs_state *, gs_matrix * ), + gs_currentmatrix(const gs_state *, gs_matrix * ), + gs_setmatrix(gs_state *, const gs_matrix * ), + gs_translate(gs_state *, floatp, floatp ), + gs_scale(gs_state *, floatp, floatp ), + gs_rotate(gs_state *, floatp ), + gs_concat(gs_state *, const gs_matrix * ); +int gs_transform(gs_state *, floatp, floatp, gs_point * ), + gs_dtransform(gs_state *, floatp, floatp, gs_point * ), + gs_itransform(gs_state *, floatp, floatp, gs_point * ), + gs_idtransform(gs_state *, floatp, floatp, gs_point * ); +static int +ctm_set_inverse(gs_state *pgs) +{ int code = gs_matrix_invert(&*(gs_matrix *)&(pgs)->ctm , &pgs->ctm_inverse); + 0; + if ( code < 0 ) return code; + pgs->inverse_valid = 1; + return 0; +} +void +gs_update_matrix_fixed(gs_matrix_fixed *pmat) +{ (*pmat). tx = ((float)(((*pmat). tx_fixed = ((fixed)(((*pmat). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (*pmat). ty = ((float)(((*pmat). ty_fixed = ((fixed)(((*pmat). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))); +} +int +gs_initmatrix(gs_state *pgs) +{ gx_device *dev = pgs->device->info; + (*dev->procs->get_initial_matrix)(dev, &*(gs_matrix *)&(pgs)->ctm ); + (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return 0; +} +int +gs_defaultmatrix(const gs_state *pgs, gs_matrix *pmat) +{ gx_device *dev = pgs->device->info; + (*dev->procs->get_initial_matrix)(dev, pmat); + return 0; +} +int +gs_currentmatrix(const gs_state *pgs, gs_matrix *pmat) +{ *pmat = *(gs_matrix *)&(pgs)->ctm; + return 0; +} +int +gs_setmatrix(gs_state *pgs, const gs_matrix *pmat) +{ *(gs_matrix *)&(pgs)->ctm = *pmat; + (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return 0; +} +int +gs_translate(gs_state *pgs, floatp dx, floatp dy) +{ gs_point pt; + int code; + if ( (code = gs_distance_transform(dx, dy, &*(gs_matrix *)&(pgs)->ctm , &pt)) < 0 ) + return code; + pgs->ctm.tx += pt.x; + pgs->ctm.ty += pt.y; + (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return 0; +} +int +gs_scale(gs_state *pgs, floatp sx, floatp sy) +{ pgs->ctm.xx *= sx; + pgs->ctm.xy *= sx; + pgs->ctm.yx *= sy; + pgs->ctm.yy *= sy; + pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return 0; +} +int +gs_rotate(gs_state *pgs, floatp ang) +{ int code = gs_matrix_rotate(&*(gs_matrix *)&(pgs)->ctm , ang, &*(gs_matrix *)&(pgs)->ctm ); + pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return code; +} +int +gs_concat(gs_state *pgs, const gs_matrix *pmat) +{ int code = gs_matrix_multiply(pmat, &*(gs_matrix *)&(pgs)->ctm , &*(gs_matrix *)&(pgs)->ctm ); + (pgs->ctm). tx = ((float)(((pgs->ctm). tx_fixed = ((fixed)(((pgs->ctm). tx)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , (pgs->ctm). ty = ((float)(((pgs->ctm). ty_fixed = ((fixed)(((pgs->ctm). ty)*(float)(1<<12 ) )) )*(1.0/(1<<12 ) ))) , pgs->inverse_valid = 0, pgs->char_tm_valid = 0; + return code; +} +int +gs_transform(gs_state *pgs, floatp x, floatp y, gs_point *pt) +{ return gs_point_transform(x, y, &*(gs_matrix *)&(pgs)->ctm , pt); +} +int +gs_dtransform(gs_state *pgs, floatp dx, floatp dy, gs_point *pt) +{ return gs_distance_transform(dx, dy, &*(gs_matrix *)&(pgs)->ctm , pt); +} +int +gs_itransform(gs_state *pgs, floatp x, floatp y, gs_point *pt) +{ + + if ( !!(((*(long *)(&((&pgs->ctm)->xy)) | *(long *)(&( (&pgs->ctm)->yx)) ) << 1) == 0) ) + { return gs_point_transform_inverse(x, y, &*(gs_matrix *)&(pgs)->ctm , pt); + } + else + { if ( !pgs->inverse_valid ) { int code = ctm_set_inverse(pgs); if ( code < 0 ) return code; }; + return gs_point_transform(x, y, &pgs->ctm_inverse, pt); + } +} +int +gs_idtransform(gs_state *pgs, floatp dx, floatp dy, gs_point *pt) +{ + + if ( !!(((*(long *)(&((&pgs->ctm)->xy)) | *(long *)(&( (&pgs->ctm)->yx)) ) << 1) == 0) ) + { return gs_distance_transform_inverse(dx, dy, + &*(gs_matrix *)&(pgs)->ctm , pt); + } + else + { if ( !pgs->inverse_valid ) { int code = ctm_set_inverse(pgs); if ( code < 0 ) return code; }; + return gs_distance_transform(dx, dy, &pgs->ctm_inverse, pt); + } +} +int +gs_translate_to_fixed(register gs_state *pgs, fixed px, fixed py) +{ pgs->ctm.tx = ((float)((pgs->ctm.tx_fixed = px)*(1.0/(1<<12 ) ))); + pgs->ctm.ty = ((float)((pgs->ctm.ty_fixed = py)*(1.0/(1<<12 ) ))); + pgs->inverse_valid = 0; + pgs->char_tm_valid = 1; + return 0; +} +int +gx_matrix_to_fixed_coeff(const gs_matrix *pmat, register fixed_coeff *pfc, + int max_bits) +{ gs_matrix ctm; + int scale = -10000; + int expt, shift; + ctm = *pmat; + pfc->skewed = 0; + if ( !((*(long *)(&(ctm.xx)) << 1) == 0) ) + { (void)frexp(ctm.xx, &scale); + } + if ( !((*(long *)(&(ctm.xy)) << 1) == 0) ) + { (void)frexp(ctm.xy, &expt); + if ( expt > scale ) scale = expt; + pfc->skewed = 1; + } + if ( !((*(long *)(&(ctm.yx)) << 1) == 0) ) + { (void)frexp(ctm.yx, &expt); + if ( expt > scale ) scale = expt; + pfc->skewed = 1; + } + if ( !((*(long *)(&(ctm.yy)) << 1) == 0) ) + { (void)frexp(ctm.yy, &expt); + if ( expt > scale ) scale = expt; + } + scale = sizeof(long) * 8 - 1 - max_bits - scale; + shift = scale - 12; + if ( shift > 0 ) + { pfc->shift = shift; + pfc->round = (fixed)1 << (shift - 1); + } + else + { pfc->shift = 0; + pfc->round = 0; + scale -= shift; + } + pfc->xx = (((*(long *)(&(ctm.xx)) << 1) == 0) ? 0 : (long)ldexp(ctm.xx, scale)); + pfc->yy = (((*(long *)(&(ctm.yy)) << 1) == 0) ? 0 : (long)ldexp(ctm.yy, scale)); + if ( pfc->skewed ) + { pfc->xy = (((*(long *)(&(ctm.xy)) << 1) == 0) ? 0 : (long)ldexp(ctm.xy, scale)); + pfc->yx = (((*(long *)(&(ctm.yx)) << 1) == 0) ? 0 : (long)ldexp(ctm.yx, scale)); + } + else + pfc->xy = pfc->yx = 0; + pfc->max_bits = max_bits; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-3.c new file mode 100755 index 0000000..13640c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-3.c @@ -0,0 +1,5 @@ +#ifndef NO_LABEL_VALUES +x(a){static void*j[]={&&l1,&&l2};goto*j[a];l1:return 0;l2:return 1;} +#else +main(){ exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-4.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-4.c new file mode 100755 index 0000000..cc5e30c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-4.c @@ -0,0 +1 @@ +x(a){struct{int p[a],i;}l;l.i;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-5.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-5.c new file mode 100755 index 0000000..ff31379 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-5.c @@ -0,0 +1 @@ +typedef struct{unsigned b0:1;}*t;x(a,b)t a,b;{b->b0=a->b0;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-6.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-6.c new file mode 100755 index 0000000..e43af7e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-6.c @@ -0,0 +1,22 @@ +typedef struct x +{ + struct x *type; + struct x *chain; + struct x *value; +} *tree; + +int +func (new, old) + register tree new, old; +{ + if (old->type == 0 || new->type == 0) + { + register tree t = old->type; + if (t == 0) + t = new->type; + for (; t; t = t->chain ) + if (t->value) + return 1; + } + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920428-7.c b/gcc_arm/testsuite/gcc.c-torture/compile/920428-7.c new file mode 100755 index 0000000..69b1d97 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920428-7.c @@ -0,0 +1 @@ +x(float*x){int a[4],i=0,j;for(j=0;j<2;j++){f(a[i++]);f(a[i++]);}} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-1.c new file mode 100755 index 0000000..a849564 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-1.c @@ -0,0 +1,7 @@ +/* CYGNUS LOCAL -- meissner/no label values */ +#ifndef NO_LABEL_VALUES +a(){int**b[]={&&c};c:;} +#else +int x; +#endif +/* END CYGNUS LOCAL -- meissner/no label values */ diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-10.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-10.c new file mode 100755 index 0000000..ecb5bb4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-10.c @@ -0,0 +1 @@ +x(y){return 8193*y;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-11.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-11.c new file mode 100755 index 0000000..d636357 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-11.c @@ -0,0 +1 @@ +typedef struct{int s;}S;foo(){int i=(int)&(S){(void*)((int)&(S){1})};} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-12.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-12.c new file mode 100755 index 0000000..594e141 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-12.c @@ -0,0 +1,5 @@ +x(x){ return 3 + x;} +a(x){int y[994]; return 3 + x;} +b(x){int y[999]; return 2*(x + 3);} +A(x){int y[9999];return 2*(x + 3);} +B(x){int y[9949];return 3 + x;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-13.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-13.c new file mode 100755 index 0000000..b5a6798 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-13.c @@ -0,0 +1 @@ +typedef struct{int i;}t;inline y(t u){}x(){t u;y(u);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-15.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-15.c new file mode 100755 index 0000000..81fd664 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-15.c @@ -0,0 +1 @@ +x(a)double a;{int i;return i>a?i:i+1;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-16.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-16.c new file mode 100755 index 0000000..f82b752 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-16.c @@ -0,0 +1 @@ +f(n){struct z{int a,b[n],c[n];};} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-17.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-17.c new file mode 100755 index 0000000..05a4d40 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-17.c @@ -0,0 +1 @@ +x(){static const char x[]="x";char y[2];y[0]=x[1];} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-18.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-18.c new file mode 100755 index 0000000..70f7c0a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-18.c @@ -0,0 +1,2 @@ +union u{int i;float f;}; +x(p)int p;{union u x;for(x.i=0;x.i<p;x.i++)if(x.f>(float)3.0)break;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-19.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-19.c new file mode 100755 index 0000000..1671cc3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-19.c @@ -0,0 +1 @@ +long long x=0;y(){x=0;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-2.c new file mode 100755 index 0000000..905f5dd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-2.c @@ -0,0 +1,11 @@ +extern short distdata[64][64], taxidata[64][64]; +extern short PieceList[2][64]; + +int +ScoreKBNK (short int winner, short int king1, short int king2) +{ + register short s; + + s = taxidata[king1][king2] + distdata[PieceList[winner][1]][king2]; + return s; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-20.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-20.c new file mode 100755 index 0000000..170d050 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-20.c @@ -0,0 +1 @@ +int*f(x)int*x;{if(x[4]){int h[1];if(setjmp(h))return x;}} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-21.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-21.c new file mode 100755 index 0000000..4a9f05a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-21.c @@ -0,0 +1,3 @@ +typedef unsigned short t; +struct foo{t d;}; +int bar(d)t d;{struct foo u;u.d=d;return(int)(&u);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-22.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-22.c new file mode 100755 index 0000000..b15d798 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-22.c @@ -0,0 +1 @@ +x(){int y[]={};} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-23.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-23.c new file mode 100755 index 0000000..291d93e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-23.c @@ -0,0 +1,16 @@ +typedef unsigned char qi; +typedef unsigned short hi; +typedef unsigned long si; +typedef unsigned long long di; +subi(a){return 100-a;} +add(a,b){return a+b;} +mul(a){return 85*a;} +memshift(p)unsigned*p;{unsigned x;for(;;){x=*p++>>16;if(x)return x;}} +ldw(xp)si*xp;{return xp[4];} +ldws_m(xp)si*xp;{si x;do{x=xp[3];xp+=3;}while(x);} +postinc_si(p)si*p;{si x;for(;;){x=*p++;if(x)return x;}} +preinc_si(p)si*p;{si x;for(;;){x=*++p;if(x)return x;}} +postinc_di(p)di*p;{di x;for(;;){x=*p++;if(x)return x;}} +preinc_di(p)di*p;{di x;for(;;){x=*++p;if(x)return x;}} +inc_overlap(p,a)di*p;{do{p=*(di**)p;p=(di*)((int)p+4);}while(*p);} +di move_di(p,p2)di*p,*p2;{di x=p;p2=((di*)x)[1];return p2[1];} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-24.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-24.c new file mode 100755 index 0000000..ae9c145 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-24.c @@ -0,0 +1,221 @@ +char *malloc (); + +main () +{ + char *buf1; + int i; + int cnt; + + buf1 = malloc (8193); + + read (0, buf1, 8192); + + for (i = 500; i > 0; i--) + cnt = shift (buf1, 8192, '\n'); + printf ("%d ", cnt); + + for (i = 500; i > 0; i--) + cnt = shift_xor (buf1, 8192, '\n'); + printf ("%d ", cnt); + + for (i = 500; i > 0; i--) + cnt = bitfield (buf1, 8192, '\n'); + printf ("%d ", cnt); + + for (i = 500; i > 0; i--) + cnt = char_autoincr (buf1, 8192, '\n'); + printf ("%d ", cnt); + + for (i = 500; i > 0; i--) + cnt = xorand (buf1, 8192, '\n'); + printf ("%d ", cnt); +} + +shift (b1, n, c) + int *b1; + int n; + char c; +{ + int nn; + int cnt = 0; + int w1; + + for (nn = n / (4 * 4); nn > 0; nn--) + { + w1 = *b1++; + if ((char)w1 == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + w1 = *b1++; + if ((char)w1 == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + w1 = *b1++; + if ((char)w1 == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + w1 = *b1++; + if ((char)w1 == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + if ((char)(w1 >>= 8) == c) cnt++; + } + return cnt; +} + +shift_xor (b1, n, c) + int *b1; + int n; + char c; +{ + int nn; + int cnt = 0; + int w1; + int cccc = (c << 24) | (c << 16) | (c << 8) | c; + + for (nn = n / (4 * 4); nn > 0; nn--) + { + w1 = *b1++ ^ cccc; + if ((char)w1 == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + w1 = *b1++ ^ cccc; + if ((char)w1 == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + w1 = *b1++ ^ cccc; + if ((char)w1 == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + w1 = *b1++ ^ cccc; + if ((char)w1 == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + if ((char)(w1 >>= 8) == 0) cnt++; + } + return cnt; +} + +typedef +struct +{ + unsigned b0:8; + unsigned b1:8; + unsigned b2:8; + unsigned b3:8; +} foo; + +bitfield (b1, n, c) + foo *b1; + int n; + char c; +{ + int nn; + int cnt = 0; + register foo w1; + + for (nn = n / (4 * 4); nn > 0; nn--) + { + w1 = *b1++; + if (w1.b0 == c) cnt++; + if (w1.b1 == c) cnt++; + if (w1.b2 == c) cnt++; + if (w1.b3 == c) cnt++; + w1 = *b1++; + if (w1.b0 == c) cnt++; + if (w1.b1 == c) cnt++; + if (w1.b2 == c) cnt++; + if (w1.b3 == c) cnt++; + w1 = *b1++; + if (w1.b0 == c) cnt++; + if (w1.b1 == c) cnt++; + if (w1.b2 == c) cnt++; + if (w1.b3 == c) cnt++; + w1 = *b1++; + if (w1.b0 == c) cnt++; + if (w1.b1 == c) cnt++; + if (w1.b2 == c) cnt++; + if (w1.b3 == c) cnt++; + } + return cnt; +} + + +char_autoincr (b1, n, c) + char *b1; + int n; + char c; +{ + int cnt = 0; + char *bend = b1 + n; + *bend = c; + + for (;;) + { + while (*b1++ != c) + ; + cnt++; + if (b1 > bend) + break; + } + return cnt; +} + +typedef unsigned int uint; + +xorand (b1, n, c) + int *b1; + int n; + unsigned char c; +{ + int xm = ((int) c << 24) | ((int) c << 16) | ((int) c << 8) | ((int) c); + byte_match_count2 (b1, n, xm, 0xff000000, 0xff0000, 0xff00, 0xff); +} + +byte_match_count2 (buf, n, xm, m1, m2, m3, m4) + int *buf; + int n; + uint m1, m2, m3, m4; +{ + int w, cnt = 0; + int *bp; + + n /= 4; + + buf[n] = xm; + + bp = buf; + while (bp < buf + n) + { + w = *bp++ ^ xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++ ^ xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++ ^ xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++ ^ xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + } + return cnt; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-3.c new file mode 100755 index 0000000..41ef87f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-3.c @@ -0,0 +1,2 @@ +struct{long long x:24,y:40;}v; +x(){v.y=0;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-4.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-4.c new file mode 100755 index 0000000..9cd2fd7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-4.c @@ -0,0 +1,49 @@ +foo () +{ + int r0[8186 ]; + int r1[2 ]; + int r2[2 ]; + int bitm0[2 ]; + int bitm1[2 ]; + int bitm2[2 ]; + + int i,j,k,m,n,m_max; + int f; + double fm,ft; + + while (1) { + + if (m%4 == 2) + ++m; + + if (m_max != 0 && m > m_max) + break; + + fm=m; + + r0[k=1]=0; + bitm0[0] = 0; + + while ( n%f == 0 ) { + while ( (ft != 0) && (ft < fm )) { + bitm1[i] = 0; + r1[i]=0; + } + + while ( r0[i] != 0 && r1[i] != 0 ) { + if ( r0[i] < r1[i] ) { + bitm2[k] = bitm0[i]; + r2[k++]=0; + } + else if ( r0[i] > r1[j] ) { + bitm2[k] = bitm1[j]; + r2[k++]=r1[j++]; + } + else { + bitm1[k] = bitm0[i]; + r2[k++]=r0[i++]; + } + } + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-6.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-6.c new file mode 100755 index 0000000..d0a4063 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-6.c @@ -0,0 +1 @@ +x(y,z)float*y;{*y=z;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-7.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-7.c new file mode 100755 index 0000000..ee193f7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-7.c @@ -0,0 +1,7 @@ +/* CYGNUS LOCAL -- meissner/no label values */ +#ifndef NO_LABEL_VALUES +x(){if(&&e-&&b<0)x();b:goto*&&b;e:;} +#else +int x; +#endif +/* END CYGNUS LOCAL -- meissner/no label values */ diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-8.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-8.c new file mode 100755 index 0000000..68e3393 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-8.c @@ -0,0 +1 @@ +x(int*p){int x=p;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920501-9.c b/gcc_arm/testsuite/gcc.c-torture/compile/920501-9.c new file mode 100755 index 0000000..98a0600 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920501-9.c @@ -0,0 +1 @@ +short x(a)unsigned a;{a=32987799;return a;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920502-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920502-1.c new file mode 100755 index 0000000..b576c6c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920502-1.c @@ -0,0 +1 @@ +extern void*t[];x(i){goto*t[i];} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920502-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920502-2.c new file mode 100755 index 0000000..d3aa1e2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920502-2.c @@ -0,0 +1 @@ +x(c){1LL<<c;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920529-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920529-1.c new file mode 100755 index 0000000..0f50309 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920529-1.c @@ -0,0 +1,21 @@ +void +f (a, b, m, n) + unsigned short *a, *b; + int m, n; +{ + unsigned long acc; + int qn; + int j; + + abort (); + + acc = a[m - 1]; + a += 0; + for (j = qn - 1; j >= 0; j = j - 1) + { + acc = (acc << 16) | a[j]; + acc = acc % *b; + } + + return; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920611-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920611-2.c new file mode 100755 index 0000000..e54b1cd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920611-2.c @@ -0,0 +1,53 @@ +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned long ulong; + +static unsigned long S[1][1]={0x00820200}; + +static int body(out0,out1,ks,Eswap0,Eswap1) +ulong *out0,*out1; +int *ks; +ulong Eswap0,Eswap1; +{ + register unsigned long l,r,t,u,v; + register unsigned long *s; + register int i,j; + register unsigned long E0,E1; + + l=0; + r=0; + + s=(ulong *)ks; + E0=Eswap0; + E1=Eswap1; + + for (i=0; i<(16 *2); i+=4) + { + v=(r^(r>>16)); + u=(v&E0); + v=(v&E1); + u=(u^(u<<16))^r^s[ i ]; + t=(v^(v<<16))^r^s[ i+1]; + t=(t>>4)|(t<<28); + l^=S[1][(t)&0x3f]| S[3][(t>> 8)&0x3f]| S[5][(t>>16)&0x3f]| S[7][(t>>24)&0x3f]| S[0][(u)&0x3f]| S[2][(u>> 8)&0x3f]| S[4][(u>>16)&0x3f]| S[6][(u>>24)&0x3f]; + v=(l^(l>>16)); + u=(v&E0); + v=(v&E1); + u=(u^(u<<16))^l^s[ i+2 ]; + t=(v^(v<<16))^l^s[ i+2+1]; + t=(t>>4)|(t<<28); + r^= S[1][(t )&0x3f]; + } + t=l; + l=r; + r=t; + + t=r; + r=(l>>1)|(l<<31); + l=(t>>1)|(t<<31); + + *out0=l; + *out1=r; + return(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920615-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920615-1.c new file mode 100755 index 0000000..9b1c6ac --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920615-1.c @@ -0,0 +1,4 @@ +f() +{ + int x[20] = {[0] = 5, [10] = 12}; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920617-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920617-1.c new file mode 100755 index 0000000..2d84e8d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920617-1.c @@ -0,0 +1 @@ +f(){double*xp,y;*xp++=sqrt(y);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920617-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920617-2.c new file mode 100755 index 0000000..3a54509 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920617-2.c @@ -0,0 +1 @@ +f(a,b,c,d)float a[],d;int b[],c;{} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920623-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920623-1.c new file mode 100755 index 0000000..9b6ad51 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920623-1.c @@ -0,0 +1,2 @@ +int f(int c){return f(c--);} +g(){} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920624-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920624-1.c new file mode 100755 index 0000000..8b4d297 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920624-1.c @@ -0,0 +1,2 @@ +int B[],Q[]; +f(){int s;for(s=0;s<=1;s++)switch(s){case 2:case 3:++B[s];case 4:case 5:++Q[s];}} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920625-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920625-1.c new file mode 100755 index 0000000..720d43f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920625-1.c @@ -0,0 +1,279 @@ +typedef unsigned long int unsigned_word; +typedef signed long int signed_word; +typedef unsigned_word word; + +typedef enum { ADD, ADD_CI, ADD_CO, ADD_CIO, SUB, SUB_CI, SUB_CO, +SUB_CIO, ADC_CI, ADC_CO, ADC_CIO, AND, IOR, XOR, ANDC, IORC, EQV, +NAND, NOR, AND_RC, IOR_RC, XOR_RC, ANDC_RC, IORC_RC, EQV_RC, NAND_RC, +NOR_RC, AND_CC, IOR_CC, XOR_CC, ANDC_CC, IORC_CC, EQV_CC, NAND_CC, +NOR_CC, LSHIFTR, ASHIFTR, SHIFTL, LSHIFTR_CO, ASHIFTR_CO, SHIFTL_CO, +ROTATEL, ROTATEL_CO, ROTATEXL_CIO, ASHIFTR_CON, EXTS1, EXTS2, EXTU1, +EXTU2, CLZ, CTZ, FF1, FF0, ABSVAL, NABSVAL, CMP, CPEQ, CPGE, CPGEU, +CPGT, CPGTU, CPLE, CPLEU, CPLT, CPLTU, CPNEQ, CMPPAR, DOZ, COPY, +EXCHANGE, COMCY, } opcode_t; + +typedef struct +{ + opcode_t opcode:8; + unsigned int s1:8; + unsigned int s2:8; + unsigned int d:8; +} insn_t; + +enum prune_flags +{ + NO_PRUNE = 0, + CY_0 = 1, + CY_1 = 2, + CY_JUST_SET = 4, +}; + +int flag_use_carry = 1; + +inline +recurse(opcode_t opcode, + int d, + int s1, + int s2, + word v, + int cost, + insn_t *sequence, + int n_insns, + word *values, + int n_values, + const word goal_value, + int allowed_cost, + int cy, + int prune_flags) +{ + insn_t insn; + + allowed_cost -= cost; + + if (allowed_cost > 0) + { + word old_d; + + old_d = values[d]; + values[d] = v; + + insn.opcode = opcode; + insn.s1 = s1; + insn.s2 = s2; + insn.d = d; + sequence[n_insns] = insn; + + synth(sequence, n_insns + 1, values, n_values, + goal_value, allowed_cost, cy, prune_flags); + + values[d] = old_d; + } + else if (goal_value == v) + { + insn.opcode = opcode; + insn.s1 = s1; + insn.s2 = s2; + insn.d = d; + sequence[n_insns] = insn; + test_sequence(sequence, n_insns + 1); + } +} + +synth(insn_t *sequence, + int n_insns, + word *values, + int n_values, + word goal_value, + int allowed_cost, + int ci, + int prune_hint) +{ + int s1, s2; + word v, r1, r2; + int co; + int last_dest; + + if (n_insns > 0) + last_dest = sequence[n_insns - 1].d; + else + last_dest = -1; + if (ci >= 0 && flag_use_carry) + { + for (s1 = n_values - 1; s1 >= 0; s1--) + { + r1 = values[s1]; + for (s2 = s1 - 1; s2 >= 0; s2--) + { + r2 = values[s2]; + + if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0) + { + if (last_dest >= 0 && s1 != last_dest && s2 != last_dest) + continue; + } + do { word __d = ( r1) + ( r2) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( r1) + ( r2) + (( ci)); ( co) = ( ci); (v) = __d; } while (0); + recurse(ADD_CI, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + do { word __d = ( r1) - ( r2) - (( ci)); ( co) = ( ci) ? __d >= ( r1) : __d > ( r1); (v) = __d; } while (0); + recurse(SUB_CIO, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( r2) - ( r1) - (( ci)); ( co) = ( ci) ? __d >= ( r2) : __d > ( r2); (v) = __d; } while (0); + recurse(SUB_CIO, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + do { word __d = ( r1) - ( r2) - (( ci)); ( co) = ( ci); (v) = __d; } while (0); + recurse(SUB_CI, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + do { word __d = ( r2) - ( r1) - (( ci)); ( co) = ( ci); (v) = __d; } while (0); + recurse(SUB_CI, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + } + } + } + for (s1 = n_values - 1; s1 >= 0; s1--) + { + r1 = values[s1]; + for (s2 = s1 - 1; s2 >= 0; s2--) + { + r2 = values[s2]; + + if (allowed_cost <= 1) + { + if (last_dest >= 0 && s1 != last_dest && s2 != last_dest) + continue; + } + + do { word __d = ( r1) + ( r2); ( co) = __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CO, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + ((v) = ( r1) + ( r2), ( co) = ( ci)); + recurse(ADD, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + do { word __d = ( r1) - ( r2); ( co) = __d > ( r1); (v) = __d; } while (0); + recurse(SUB_CO, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( r2) - ( r1); ( co) = __d > ( r2); (v) = __d; } while (0); + recurse(SUB_CO, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + ((v) = ( r1) - ( r2), ( co) = ( ci)); + recurse(SUB, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ( r2) - ( r1), ( co) = ( ci)); + recurse(SUB, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( r1) & ( r2), ( co) = ( ci)); + recurse(AND, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( r1) | ( r2), ( co) = ( ci)); + recurse(IOR, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( r1) ^ ( r2), ( co) = ( ci)); + recurse(XOR, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( r1) & ~( r2), ( co) = ( ci)); + recurse(ANDC, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ( r2) & ~( r1), ( co) = ( ci)); + recurse(ANDC, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ( r1) | ~( r2), ( co) = ( ci)); + recurse(IORC, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ( r2) | ~( r1), ( co) = ( ci)); + recurse(IORC, n_values, s2, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ( r1) ^ ~( r2), ( co) = ( ci)); + recurse(EQV, n_values, s1, s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + } + } + if (ci >= 0 && flag_use_carry) + { + for (s1 = n_values - 1; s1 >= 0; s1--) + { + r1 = values[s1]; + + if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0) + { + + if (last_dest >= 0 && s1 != last_dest) + continue; + } + + do { word __d = ( r1) + ( r1) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, s1, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + do { word __d = ( r1) + ( r1) + (( ci)); ( co) = ( ci); (v) = __d; } while (0); + recurse(ADD_CI, n_values, s1, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + do { word __d = ( r1) + ( -1 ) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, s1, (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + do { word __d = ( r1) + ( 0 ) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, s1, (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( 0 ) - ( r1) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0); + recurse(SUB_CIO, n_values, (0x20 + 0) , s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + } + } + for (s1 = n_values - 1; s1 >= 0; s1--) + { + r1 = values[s1]; + + if (allowed_cost <= 1) + { + if (last_dest >= 0 && s1 != last_dest) + continue; + } + do { word __d = ( r1) + ( r1); ( co) = __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CO, n_values, s1, s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + + ((v) = ( r1) & ( 1 ), ( co) = ( ci)); + recurse(AND, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( r1) ^ ( 1 ), ( co) = ( ci)); + recurse(XOR, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( -1 ) - ( r1), ( co) = ( ci)); + recurse(SUB, n_values, (0x20 + -1) , s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + do { word __d = ( r1) + ( 1 ); ( co) = __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CO, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + ((v) = ( r1) + ( 1 ), ( co) = ( ci)); + recurse(ADD, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + do { word __d = ( r1) + ( -1 ); ( co) = __d < ( r1); (v) = __d; } while (0); + recurse(ADD_CO, n_values, s1, (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( r1) - ( 1 ); ( co) = __d > ( r1); (v) = __d; } while (0); + recurse(SUB_CO, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + do { word __d = ( 0 ) - ( r1); ( co) = __d > ( 0 ); (v) = __d; } while (0); + recurse(SUB_CO, n_values, (0x20 + 0) , s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET); + ((v) = ( 0 ) - ( r1), ( co) = ( ci)); + recurse(SUB, n_values, (0x20 + 0) , s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ((unsigned_word) ( r1) >> (( 1 ) & (32 - 1)) ), ( co) = ( ci)); + recurse(LSHIFTR, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ((signed_word) ( r1) >> (( 1 ) & (32 - 1)) ), ( co) = ( ci)); + recurse(ASHIFTR, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ((signed_word) ( r1) << (( 1 ) & (32 - 1)) ), ( co) = ( ci)); + recurse(SHIFTL, n_values, s1, (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ((unsigned_word) ( r1) >> (( 32 -1 ) & (32 - 1)) ), ( co) = ( ci)); + recurse(LSHIFTR, n_values, s1, (0x20 + 32 -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + ((v) = ((signed_word) ( r1) >> (( 32 -1 ) & (32 - 1)) ), ( co) = ( ci)); + recurse(ASHIFTR, n_values, s1, (0x20 + 32 -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + } + if (ci >= 0 && flag_use_carry + && (allowed_cost <= 1 ? ((prune_hint & CY_JUST_SET) != 0) : 1)) + { + do { word __d = ( 0 ) + ( 0 ) + (( ci)); ( co) = ( ci) ? __d <= ( 0 ) : __d < ( 0 ); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, (0x20 + 0) , (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET | CY_0); + do { word __d = ( 0 ) - ( 0 ) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0); + recurse(SUB_CIO, n_values, (0x20 + 0) , (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + do { word __d = ( 0 ) - ( -1 ) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0); + recurse(SUB_CIO, n_values, (0x20 + 0) , (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, CY_JUST_SET | CY_1); + do { word __d = ( 0 ) + ( -1 ) + (( ci)); ( co) = ( ci) ? __d <= ( 0 ) : __d < ( 0 ); (v) = __d; } while (0); + recurse(ADD_CIO, n_values, (0x20 + 0) , (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + } + + if (allowed_cost > 1) + { + ((v) = ( 0x80000000 ), ( co) = ( ci)); + recurse(COPY, n_values, (0x20 - 2) , 0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( -1 ), ( co) = ( ci)); + recurse(COPY, n_values, (0x20 + -1) , 0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + + ((v) = ( 1 ), ( co) = ( ci)); + recurse(COPY, n_values, (0x20 + 1) , 0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co, prune_hint & ~CY_JUST_SET); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920625-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920625-2.c new file mode 100755 index 0000000..1466285 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920625-2.c @@ -0,0 +1,103 @@ +typedef char * caddr_t; +typedef unsigned Cursor; +typedef char *String; +typedef struct _WidgetRec *Widget; +typedef char Boolean; +typedef unsigned int Cardinal; +typedef struct _XedwListReturnStruct { + String string; + int xedwList_index; + struct _XedwListReturnStruct *next; +} XedwListReturnStruct; +static XedwListReturnStruct *return_list; +static String srcdir, dstdir; +char *strcpy(); + extern void setCursor(Cursor); + extern void query_dialog(String, Boolean); + extern Boolean directoryManagerNewDirectory(String); +trashQueryResult(Widget w, Boolean delete, caddr_t call_data) +{ + int execute(String, String, String, Boolean); + extern void destroy_button_dialog(void); + extern void changestate(Boolean); + + extern Cursor busy, left_ptr; + extern String cwd; + static void freeReturnStruct(void); + String rmstring; + int status; + XedwListReturnStruct *tmp; + setCursor(busy); + destroy_button_dialog(); + if (delete == 1) { + rmstring = (("rm -fr") != ((void *)0) ? (strcpy((char*)XtMalloc((unsigned)strlen("rm -fr") + 1), "rm -fr")) : ((void *)0)); + tmp = return_list; + while (tmp != ((void *)0)) { + rmstring = (String) XtRealloc (rmstring, sizeof(char) * + (strlen(rmstring) + + strlen(tmp->string) + 5)); + sprintf(rmstring, "%s '%s'", rmstring, tmp->string); + tmp = tmp->next; + } + if ((status = execute(((void *)0), "rm", rmstring, 1)) != 0) { + XBell(XtDisplay(w), 100); + query_dialog("Can't remove file", 0); + } + XtFree(rmstring); + + directoryManagerNewDirectory(cwd); + } else { + changestate(1); + } + setCursor(left_ptr); + freeReturnStruct(); +} + +copyQueryResult(Widget w, Boolean copy, caddr_t call_data) +{ + extern void destroy_button_dialog(); + extern void changestate(Boolean); + extern Cursor busy, left_ptr; + static void freeReturnStruct(void); + int execute(String, String, String, Boolean); + extern String cwd; + String copystring; + int status; + Cardinal srclen, dstlen; + XedwListReturnStruct *tmp; + destroy_button_dialog(); + setCursor(busy); + if (copy == 1) { + srclen = strlen(srcdir); + dstlen = strlen(dstdir); + copystring = (("cp -r") != ((void *)0) ? (strcpy((char*)XtMalloc((unsigned)strlen("cp -r") + 1), "cp -r")) : ((void *)0)); + tmp = return_list; + while (tmp != ((void *)0)) { + copystring = (String) XtRealloc (copystring, sizeof(char) * + (strlen(copystring) + + strlen(tmp->string) + + srclen + 6)); + sprintf(copystring, "%s '%s/%s'", copystring, srcdir, tmp->string); + tmp = tmp->next; + } + copystring = (String) XtRealloc (copystring, sizeof(char) * + (strlen(copystring) + + dstlen + 5)); + sprintf(copystring, "%s '%s'", copystring, dstdir); + if ((status = execute(((void *)0), "cp", copystring, 1)) != 0) { + XBell(XtDisplay(w), 100); + query_dialog("Can't copy file!", 0); + } + XtFree(copystring); + + directoryManagerNewDirectory(cwd); + } else { + changestate(1); + } + XtFree(srcdir); + XtFree(dstdir); + setCursor(left_ptr); + freeReturnStruct(); +} + +freeReturnStruct(){} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920626-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920626-1.c new file mode 100755 index 0000000..5441986 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920626-1.c @@ -0,0 +1 @@ +f(x)unsigned x;{return x>>-5;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920701-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920701-1.c new file mode 100755 index 0000000..4302f9e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920701-1.c @@ -0,0 +1 @@ +f(char*c){extern char a[],b[];return a+(b-c);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920702-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920702-1.c new file mode 100755 index 0000000..23a5395 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920702-1.c @@ -0,0 +1,10 @@ +int somevar; +void +yylex () +{ + register int result = 0; + int num_bits = -1; + + if (((result >> -1) & 1)) + somevar = 99; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920706-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920706-1.c new file mode 100755 index 0000000..13b0ff1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920706-1.c @@ -0,0 +1 @@ +f(){float i[2],o[1];g(o);return*o;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920710-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920710-2.c new file mode 100755 index 0000000..dcaf1be --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920710-2.c @@ -0,0 +1,36 @@ +union u +{ + struct {unsigned h, l;} i; + double d; +}; + +foo (union u x) +{ + while (x.i.h++) + { + while (x.i.l-- > 0) + ; + while (x.d++ > 0) + ; + } +} + +union n +{ + long long unsigned i; + double d; +}; + +bar (union n x) +{ + int i; + for (i = 0; i < 100; i++) + { + while (--x.i > 0) + ; + while (++x.d > 0) + ; + } + return x.i; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920711-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920711-1.c new file mode 100755 index 0000000..a5aa7df --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920711-1.c @@ -0,0 +1 @@ +f(a){a=(1,1)/2;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920721-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920721-1.c new file mode 100755 index 0000000..7ced611 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920721-1.c @@ -0,0 +1,11 @@ +typedef struct{short ttype;float s;}T; +short t[8][8]; + +T f(T t2,T t1) +{ + T x; + if (t1.ttype == 1) + x.ttype = t[t2.ttype][t1.ttype], + x.s = 1; + return x; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920723-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920723-1.c new file mode 100755 index 0000000..af0cf76 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920723-1.c @@ -0,0 +1,23 @@ +typedef struct { + double x, y; +} vector_t; +double sqrt(); +f(int count,vector_t*pos,double r,double *rho) +{ + int i, j, miny, maxy, hy; + float help, d; + int gitt[150][150]; + int *data = (int *)malloc(count*sizeof(int)); + for (i = 0; i < count; i++) + rho[i] = 0; + for (i = 1; i < count; i++) + for (hy = miny; hy<= maxy; hy++) + while(j >=0) { + d = pos[i].y - pos[j].y; + if ( d <= r) { + d = sqrt(d); + rho[i] += help; + } + } +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920729-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920729-1.c new file mode 100755 index 0000000..96676e9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920729-1.c @@ -0,0 +1,2 @@ +extern int i;extern volatile int i; +f(){int j;for(;;)j = i;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920806-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920806-1.c new file mode 100755 index 0000000..0928fe8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920806-1.c @@ -0,0 +1 @@ +f(){short x=32000;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920808-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920808-1.c new file mode 100755 index 0000000..17510a9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920808-1.c @@ -0,0 +1 @@ +f(i){for(i=1;i<=2;({;}),i++){({;}),g();}} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920809-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920809-1.c new file mode 100755 index 0000000..ad35e12 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920809-1.c @@ -0,0 +1 @@ +f(x,y){memcpy (&x,&y,8192);} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920817-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920817-1.c new file mode 100755 index 0000000..31a5733 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920817-1.c @@ -0,0 +1 @@ +int v;static inline f(){return 0;}g(){return f();}void h(){return v++;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920820-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920820-1.c new file mode 100755 index 0000000..2bc0dbe --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920820-1.c @@ -0,0 +1 @@ +long long f(double y){return y;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920821-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920821-1.c new file mode 100755 index 0000000..40a8c17 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920821-1.c @@ -0,0 +1 @@ +/* empty */ diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920821-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920821-2.c new file mode 100755 index 0000000..a69c0a9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920821-2.c @@ -0,0 +1,4 @@ +typedef struct{int p[25];}t1; +struct{t1 x,y;}y; +t1 x[1]; +f(){y.x=*x;y.y=*x;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920825-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920825-1.c new file mode 100755 index 0000000..514d63f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920825-1.c @@ -0,0 +1,3 @@ +#pragma pack(1) +struct{unsigned short f1:5;unsigned short f2:6;}x; +f(){x.f2=1;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920825-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920825-2.c new file mode 100755 index 0000000..9834aac --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920825-2.c @@ -0,0 +1,3 @@ +f(double*a,int m){int j;for(j=0;j<m;j++)a[j]=1;} +g(double*a){int j;for(j=0;j<4;j++)a[j]=1;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920826-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920826-1.c new file mode 100755 index 0000000..d19eff2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920826-1.c @@ -0,0 +1 @@ +f(int*x){goto*(char)*x;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920828-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920828-1.c new file mode 100755 index 0000000..4893173 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920828-1.c @@ -0,0 +1 @@ +char a[]={4,5};f(n){return a[n<2?n:0];} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920829-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920829-1.c new file mode 100755 index 0000000..593400b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920829-1.c @@ -0,0 +1 @@ +f(double x){double y;y=x/0.5;if(y<0.1)y=1.0;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920831-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920831-1.c new file mode 100755 index 0000000..ff2fd63 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920831-1.c @@ -0,0 +1 @@ +f(x){goto*(char)x;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920902-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920902-1.c new file mode 100755 index 0000000..6f6dcd5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920902-1.c @@ -0,0 +1,2 @@ +void f(int); +void f(x)unsigned char x;{} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920909-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920909-1.c new file mode 100755 index 0000000..939aaf7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920909-1.c @@ -0,0 +1 @@ +long long f(long long a,long long b){return a<<b;} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920917-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920917-1.c new file mode 100755 index 0000000..ebe8200 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920917-1.c @@ -0,0 +1,2 @@ +inline f(x){switch(x){case 6:case 4:case 3:case 1:;}return x;} +g(){f(sizeof("xxxxxx"));} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-1.c new file mode 100755 index 0000000..137363d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-1.c @@ -0,0 +1,2 @@ +struct{int c;}v; +static long i=((char*)&(v.c)-(char*)&v); diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-2.c new file mode 100755 index 0000000..a0964f9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-2.c @@ -0,0 +1,19 @@ +typedef struct{struct{char*d;int b;}*i;}*t; +double f(); +g(p)t p; +{ + short x,y,delta,s,w,h,fx,fy,tx,ty; + int q1,q2,q3,q4; + h=f((ty-fy)/2.0+0.5); + s=(((int)((short)(tx-fx))<(int)((short)(ty-fy)))?((short)(tx-fx)):((short)(ty-fy)))%2; + delta=(((int)(w)<(int)(h))?(w):(h))-s; + for(x=0;x<=delta;x++) + for(y=1-s;y<=delta;y++){ + q1=((int)((*(p->i->d+(fx+w+x)/8+(fy+h+y)*p->i->b)&(1<<((fx+w+x)%8)))?1:0)); + q2=((int)((*(p->i->d+(fx+w+y)/8+(fy+h-s-x)*p->i->b)&(1<<((fx+w+y)%8)))?1:0)); + q3=((int)((*(p->i->d+(fx+w-s-x)/8+(fy+h-s-y)*p->i->b)&(1<<((fx+w-s-x)%8)))?1:0)); + q4=((int)((*(p->i->d+(fx+w-s-y)/8+(fy+h+x)*p->i->b)&(1<<((fx+w-s-y)%8)))?1:0)); + if(q4!=q1) + ff(p,fx+w-s-y,fy+h+x); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-3.c new file mode 100755 index 0000000..583dc69 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-3.c @@ -0,0 +1,19 @@ +f (int phaseone) +{ + typedef struct + { + unsigned char *p; + } + FILE; + FILE b[2]; + static unsigned char xchr[2]; + int j; + int for_end; + if (phaseone) + { + if (j <= for_end) + do + *(b[1].p) = xchr[j]; + while (j++ < 10); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-4.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-4.c new file mode 100755 index 0000000..348de65 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-4.c @@ -0,0 +1,113 @@ +typedef unsigned char unsigned8; +typedef unsigned short int unsigned16; +typedef unsigned long int unsigned32; +typedef char signed8; +typedef short int signed16; +typedef long int signed32; +typedef unsigned32 boolean32; +typedef unsigned long int error_status_t; +typedef struct { + unsigned32 time_low; + unsigned16 time_mid; + unsigned16 time_hi_and_version; + unsigned8 clock_seq_hi_and_reserved; + unsigned8 clock_seq_low; + unsigned char node[6]; +} uuid_t; + +typedef unsigned32 bitset; +typedef signed32 sec_timeval_sec_t; +typedef struct { + signed32 sec; + signed32 usec; +} sec_timeval_t; +typedef signed32 sec_timeval_period_t; +typedef signed32 sec_rgy_acct_key_t; + +typedef struct { + uuid_t source; + signed32 handle; + boolean32 valid; +} sec_rgy_cursor_t; +typedef unsigned char sec_rgy_pname_t[257]; +typedef unsigned char sec_rgy_name_t[1025]; + +typedef signed32 sec_rgy_override_t; +typedef signed32 sec_rgy_mode_resolve_t; +typedef unsigned char sec_rgy_unix_gecos_t[292]; +typedef unsigned char sec_rgy_unix_login_name_t[1025]; +typedef unsigned char sec_rgy_member_t[1025]; +typedef unsigned char sec_rgy_unix_passwd_buf_t[16]; +typedef struct sec_rgy_sid_t { + uuid_t person; + uuid_t group; + uuid_t org; +} sec_rgy_sid_t; +typedef struct { + signed32 person; + signed32 group; + signed32 org; +} sec_rgy_unix_sid_t; +typedef struct { + sec_rgy_unix_login_name_t name; + sec_rgy_unix_passwd_buf_t passwd; + signed32 uid; + signed32 gid; + signed32 oid; + sec_rgy_unix_gecos_t gecos; + sec_rgy_pname_t homedir; + sec_rgy_pname_t shell; +} sec_rgy_unix_passwd_t; +typedef unsigned char sec_rgy_member_buf_t[10250]; +typedef struct { + sec_rgy_name_t name; + signed32 gid; + sec_rgy_member_buf_t members; +} sec_rgy_unix_group_t; + +typedef struct { + uuid_t site_id; + sec_timeval_sec_t person_dtm; + sec_timeval_sec_t group_dtm; + sec_timeval_sec_t org_dtm; +} rs_cache_data_t; + +typedef enum { + rs_unix_query_name, + rs_unix_query_unix_num, + rs_unix_query_none +} rs_unix_query_t; + +typedef struct { + rs_unix_query_t query; + union { + struct { + long int name_len; + sec_rgy_name_t name; + } name; + long int unix_num; + } tagged_union; +} rs_unix_query_key_t; + +static unsigned long int IDL_offset_vec[] = +{ + 0, + sizeof(sec_rgy_unix_group_t), + (unsigned long int) ((unsigned char *) &((sec_rgy_unix_group_t *) 0)->name - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_unix_group_t *) 0)->gid - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_unix_group_t *) 0)->members - (unsigned char *) 0), + sizeof(rs_cache_data_t), + (unsigned long int) ((unsigned char *) &((rs_cache_data_t *) 0)->site_id.time_low - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((rs_cache_data_t *) 0)->site_id.time_mid - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((rs_cache_data_t *) 0)->site_id.time_hi_and_version - (unsigned char *) 0), + sizeof(sec_rgy_unix_passwd_t), + (unsigned long int) ((unsigned char *) &((sec_rgy_cursor_t *) 0)->source.clock_seq_hi_and_reserved - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_cursor_t *) 0)->source.clock_seq_low - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_cursor_t *) 0)->source.node - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_cursor_t *) 0)->handle - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((sec_rgy_cursor_t *) 0)->valid - (unsigned char *) 0), + sizeof(struct {long int name_len; sec_rgy_name_t name;}), + (unsigned long int) ((unsigned char *) &((struct {long int name_len; sec_rgy_name_t name;} *)0)->name_len + - (unsigned char *) 0), + (unsigned long int) ((unsigned char *) &((struct {long int name_len; sec_rgy_name_t name;} *)0)->name - (unsigned char *) 0), +}; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-5.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-5.c new file mode 100755 index 0000000..8c975f0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-5.c @@ -0,0 +1,7 @@ +/* REPRODUCED:CC1:SIGNAL MACHINE:m68k OPTIONS:-fpcc-struct-return */ +struct b{}; +f(struct b(*f)()) +{ +struct b d=f(); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/920928-6.c b/gcc_arm/testsuite/gcc.c-torture/compile/920928-6.c new file mode 100755 index 0000000..692191b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/920928-6.c @@ -0,0 +1,2 @@ +struct{int c;}v; +static short i=((char*)&(v.c)-(char*)&v); diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921004-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921004-1.c new file mode 100755 index 0000000..a947229 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921004-1.c @@ -0,0 +1,6 @@ +/* REPRODUCED:CC1:SIGNAL MACHINE:i386 OPTIONS: */ +long long f() +{ +long long*g,*s; +return*g+*s; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921011-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921011-1.c new file mode 100755 index 0000000..6cc707d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921011-1.c @@ -0,0 +1,27 @@ +void +fun (nb) + int nb; +{ + int th, h, em, nlwm, nlwS, nlw, sy; + + while (nb--) + while (h--) + { + nlw = nlwm; + while (nlw) + { + if (nlwS == 1) + { + } + else + if (nlwS == 1) + { + } + nlwS--; nlw--; + } + if (em) + nlwS--; + if (++sy == th) + sy = 0; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921011-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/921011-2.c new file mode 100755 index 0000000..bf11dad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921011-2.c @@ -0,0 +1,65 @@ +extern int foobar1 (); + +typedef struct + { + unsigned long colormap; + unsigned long red_max; + unsigned long red_mult; + unsigned long green_max; + unsigned long green_mult; + unsigned long blue_max; + unsigned long blue_mult; + unsigned long base_pixel; + unsigned long visualid; + unsigned long killid; + } +frotz; + +int +foobar (stdcmap, count) + frotz **stdcmap; + int *count; +{ + register int i; + frotz *data = ((void *) 0); + + unsigned long nitems; + int ncmaps; + int old_style = 0; + unsigned long def_visual = 0L; + frotz *cmaps; + + + if ( foobar1 (&data) != 0) + return 0; + if (nitems < 10) + { + ncmaps = 1; + if (nitems < 9) + { + } + } + else + ncmaps = (nitems / 10); + + { + register frotz *map; + register frotz *prop; + + for (i = ncmaps, map = cmaps, prop = data; i > 0; i--, map++, prop++) + { + map->colormap = prop->colormap; + map->red_max = prop->red_max; + map->red_mult = prop->red_mult; + map->green_max = prop->green_max; + map->green_mult = prop->green_mult; + map->blue_max = prop->blue_max; + map->blue_mult = prop->blue_mult; + map->base_pixel = prop->base_pixel; + map->visualid = (def_visual ? def_visual : prop->visualid); + map->killid = (old_style ? 0L : prop->killid); + } + } + *stdcmap = cmaps; + *count = ncmaps; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921012-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921012-1.c new file mode 100755 index 0000000..7b5cb6b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921012-1.c @@ -0,0 +1,4 @@ +f() +{ +g(({int x;0;})); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921012-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/921012-2.c new file mode 100755 index 0000000..6f4de77 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921012-2.c @@ -0,0 +1,7 @@ +struct foo { +int a,b,c; +}; +f(struct foo*a,struct foo*b) +{ +*a=*b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921013-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921013-1.c new file mode 100755 index 0000000..0d14cbc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921013-1.c @@ -0,0 +1,4 @@ +f(int x,short y) +{ +long z=y<0?x>0?x:0:y; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921019-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921019-1.c new file mode 100755 index 0000000..227bdc2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921019-1.c @@ -0,0 +1,9 @@ +struct +{ +int n:1,c:1; +}p; + +f() +{ +p.c=p.n=0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921021-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921021-1.c new file mode 100755 index 0000000..18dffeb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921021-1.c @@ -0,0 +1,12 @@ +void g(); + +f() +{ +int x=1; +while(x) +{ +x=h(); +if(x) +g(); +} +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921024-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921024-1.c new file mode 100755 index 0000000..e723246 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921024-1.c @@ -0,0 +1,9 @@ +long long f(s,r) +{ + return *(long long*)(s+r); +} + +g(s,r) +{ + *(long long*)(s+r)=0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921026-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921026-1.c new file mode 100755 index 0000000..18238de --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921026-1.c @@ -0,0 +1,4 @@ +f(unsigned short*a) +{ +a[0]=65535; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921103-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921103-1.c new file mode 100755 index 0000000..578e91a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921103-1.c @@ -0,0 +1,12 @@ +struct { + unsigned int f1, f2; +} s; + +f() +{ + unsigned x, y; + x = y = 0; + while (y % 4) + y++; + g(&s.f2, s.f1 + x, 4); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921109-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921109-1.c new file mode 100755 index 0000000..eda4345 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921109-1.c @@ -0,0 +1,28 @@ +typedef struct { double x, y; } p; +typedef struct { int s; float r; } t; +t *e, i; +int i1; + +f(t *op) +{ +int i2 = e->r; +p pt; +int c = g(); +t p; + +if (c) +{ +i = *e; +e -= 3; +return 8; +} +if (op > e) +return 1; +op->r = pt.x; +op->r = pt.y; +p = *e; +++e; +e->r = i1, e->s = i1; +*++e = p; +return 3; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921109-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/921109-3.c new file mode 100755 index 0000000..40e63f2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921109-3.c @@ -0,0 +1,46 @@ +/* EXTRA_OPTIONS: -fcaller-saves */ + +extern char *malloc(); + +main() +{ + char w[1000]; + int i, j, nres, t[1000]; + float dv, (**dmat)[4][4]; + short at1, at2; + + nres = 200; + + for (i = 0; i < nres; i++) + { + w[i] = rand() & 15; + t[i] = 0; + } + + dmat = (float (**)[4][4]) malloc(nres * sizeof(*dmat)); + if (!dmat) + return 1; + for (i = 0; i < nres; i++) + { + dmat[i] = (float (*)[4][4]) malloc(nres * sizeof(**dmat)); + if (!dmat[i]) + return 1; + } + + for (i = 0; i < nres; i++) + for (j = i; j < nres; j++) + for (at1 = 0; at1 <= 3; at1++) + for (at2 = 0; at2 <= 3; at2++) + if (i != j || at1 != at2) + if ((w[i] & (1 << at1)) && (w[j] & (1 << at2))) + { + dv = 20.0 * (rand() & 32767) / 32768.0; + dmat[i][j][at1][at2] = dmat[j][i][at2][at1] = dv; + } + else + dmat[i][j][at1][at2] = dmat[j][i][at2][at1] = 999.0; + else + dmat[i][j][at1][at2] = 0.0; + + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921111-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921111-1.c new file mode 100755 index 0000000..11b4674 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921111-1.c @@ -0,0 +1,40 @@ +int ps; +struct vp { + int wa; +}; +typedef struct vp *vpt; +typedef struct vc { + int o; + vpt py[8]; +} *vct; +struct n { + int a; +}; +struct nh { + int x; +}; +typedef struct np *npt; +struct np { + vct d; + int di; +}; +struct nh xhp; +struct n np[3]; + +f(dp) + npt dp; +{ + vpt *py; + int a, l, o = 0; + a = dp->d->o; + if (dp->di < 0) + l = ps; + + if ((int)o & 3) + g(); + + xhp.x = a; + py = &dp->d->py[dp->di]; + if (o + l > ps) + np[2].a = (int)(py[1])->wa; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921116-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/921116-2.c new file mode 100755 index 0000000..9eac91c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921116-2.c @@ -0,0 +1,9 @@ +typedef struct { + long l[5]; +} t; + +f(size) +{ + t event; + g(&(event.l[2 + size]), (3 - size) * 4); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921118-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921118-1.c new file mode 100755 index 0000000..857c74e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921118-1.c @@ -0,0 +1,8 @@ +inline f(i) +{ + h((long long) i * 2); +} +g() +{ + f(9); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921126-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921126-1.c new file mode 100755 index 0000000..a7b908b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921126-1.c @@ -0,0 +1,11 @@ +f() +{ + long long a0, a1, a0s, val; + int width; + float d; + if (d) + ; + if (a0s & (1LL << width)) + ; + return a0 / a1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921202-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921202-1.c new file mode 100755 index 0000000..1287edc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921202-1.c @@ -0,0 +1,22 @@ +f () +{ + long dx[2055]; + long dy[2055]; + long s1[2055]; + int x, y; + int i; + long s; + + for (;;) + { + s = 2055; + g (s1, s); + for (i = 0; i < 1; i++); + dy[s] = 0x12345; + for (i = 0; i < 1; i++); + if (x != y || h (dx, dy, s) || dx[s] != 0x12345) + { + j (y);k (dy); + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921202-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/921202-2.c new file mode 100755 index 0000000..97d482b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921202-2.c @@ -0,0 +1,8 @@ +f(x, c) +{ + for (;;) + { + if (x << c) break; + x++; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921203-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921203-1.c new file mode 100755 index 0000000..50fe3eb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921203-1.c @@ -0,0 +1,5 @@ +char dispstr[]; +f() +{ + strcpy(dispstr,"xxxxxxxxxxx"); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921203-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/921203-2.c new file mode 100755 index 0000000..929afb1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921203-2.c @@ -0,0 +1,13 @@ +typedef struct +{ + char x; +} s1; + +s1 f (int arg0,...) +{ + int args; + s1 back; + va_start (args, arg0); + va_end (args); + return back; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921206-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921206-1.c new file mode 100755 index 0000000..b18709d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921206-1.c @@ -0,0 +1,28 @@ +double sqrt(double),fabs(double),sin(double); +int sxs; +int sys; +f() +{ + int l; + int sm = -52, sx = 52; + char *smap; + for (l = 0; l < 9; l++) + { + double g; + int cx, cy, gx, gy, x, y; + gx = 2 > g / 3 ? 2 : g / 3; + gy = 2 > g / 3 ? 2 : g / 3; + for (y = 0 > cy - gy ? 0 : cy - gy; y <= (sys - 1 < cy + gy ? sys : cy + gy); y++) + { + int sx = 0 > cx - gx ? 0 : cx - gx; + short *ax = (short *) (y * sxs + sx); + + for (x = sx; x <= (sxs - 1 < cx + gx ? sxs - 1 : cx + gx); x++) + { + double c=2.25, z=sqrt(fabs(1-c)), cz=(c>1?0.0:-10)>z?c>1?0:1:z; + } + } + } + for (l = sm; l <= sx; l++) + smap[l] = l > 0 ? 1 + pow(sin(.1 * l / sx)) : 1 - pow(sin(.1 * l / sm)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/921227-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/921227-1.c new file mode 100755 index 0000000..a49750c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/921227-1.c @@ -0,0 +1,5 @@ +#define k(a) #a +char *s = k(k(1,2)); +char *t = k(#) k(#undef k) k(x); + +f(){} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930109-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930109-1.c new file mode 100755 index 0000000..dbd15a1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930109-1.c @@ -0,0 +1,12 @@ +f(x) + unsigned x; +{ + static short c; + return x>>c; +} +g(x) + unsigned x; +{ + static char c; + return x>>c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930109-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930109-2.c new file mode 100755 index 0000000..61e3a4d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930109-2.c @@ -0,0 +1,11 @@ +f(r) +{ + int i; + for (i = 0; i < 2; i++) + { + r+= (4 >> i*2); + r+= (2 >> i*2); + r+= (1 >> i*2); + } + return r; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930111-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930111-1.c new file mode 100755 index 0000000..2857419 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930111-1.c @@ -0,0 +1,10 @@ +/* 2.3.3 crashes on 386 with -traditional */ +f(a) + char *a; +{ + int d = strcmp(a,"-"); + + while (vfork() < 0) + ; + return d; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930117-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930117-1.c new file mode 100755 index 0000000..83317cd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930117-1.c @@ -0,0 +1,4 @@ +f(x) +{ + (*(void (*)())&x)(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930118-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930118-1.c new file mode 100755 index 0000000..b29543c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930118-1.c @@ -0,0 +1,6 @@ +f() +{ +__label__ l; +l:p(); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930120-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930120-1.c new file mode 100755 index 0000000..95ac43c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930120-1.c @@ -0,0 +1,138 @@ +union { + short I[2]; + long int L; + char C[4]; +} itolws; +char *errflg; +long int dot; +short dotinc; +long int expvf; + +char * +f(fcount,ifp,itype,ptype) + short fcount; + char *ifp; +{ + unsigned w; + long int savdot, wx; + char *fp; + char c, modifier, longpr; + union { + double dval; + struct { + int i1; + int i2; + } ival; + } dw; + union { + float fval; + int ival; + } fw; + int gotdot = 0; + while (fcount > 0) { + fp = ifp; + c = *fp; + longpr = ((c >= 'A') & (c <= 'Z') | (c == 'f') | (c == '4') | (c == 'p') | (c == 'i')); + if ((itype == 0) || (*fp == 'a')) { + wx = dot; + w = dot; + } else { + gotdot = 1; + wx = get((int)dot, itype); + if (!longpr) { + w = (itolws.L=(wx), itolws.I[((dot)&3)>>1]); + } + } + if (c == 'F') { + dw.ival.i1 = wx; + if (itype == 0) { + dw.ival.i2 = expvf; + } + } + + modifier = *fp++; + switch(modifier) { + case ' ' : + case '\t' : + break; + case 't': + case 'T': + printf("%T",fcount); + return(fp); + case 'r': + case 'R': + printf("%M",fcount); + return(fp); + case 'k': + printf("%k",w); + break; + case 'K': + printf("%K",wx); + break; + case 'a': + psymoff(dot,ptype,":%16t"); + dotinc = 0; + break; + case 'p': + psymoff(0,ptype,"%16t"); + break; + case 'u': + printf("%-8u",w); + break; + case 'U': + printf("%-16U",wx); break; + case 'c': + case 'C': + if (modifier == 'C') { + printesc((int)(itolws.L=(wx), itolws.C[(dot)&3])); + } else { + printc((char)(itolws.L=(wx), itolws.C[(dot)&3])); + } + dotinc = 1; + break; + case 'b': + printf("%-8x", (itolws.L=(wx), itolws.C[(dot)&3])); + dotinc = 1; + break; + case 'B': + printf("%-8o", (itolws.L=(wx), itolws.C[(dot)&3])); + dotinc = 1; + break; + case 's': + case 'S': + savdot = dot; + dotinc = 1; + while ((c = (itolws.L=(wx), itolws.C[(dot)&3])) && (errflg == 0)) { + dot = inkdot(1); + if (modifier == 'S') { + printesc(c); + } else { + printc(c); + } + endline(); + if (!(dot & 3)) + wx = get((int)dot, itype); + } + dotinc = dot - savdot + 1; + dot = savdot; + break; + case 'i': + if (gotdot) { + wx = get((int)(dot & ~3), itype); + } + iDasm((int)(wx), (unsigned int)0, (unsigned int)(dot&~3)); + printc('\n'); + break; + case 'f': + fw.ival = wx; + printf("%-16.9f", fw.fval); + dotinc = 4; + break; + case 'F': + printf("%-32.18F", dw.dval); + dotinc = 8; + break; + } + } + return(fp); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930126-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930126-1.c new file mode 100755 index 0000000..8313c5c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930126-1.c @@ -0,0 +1,74 @@ +typedef unsigned T; +typedef char Tchar; +T mt (long, char *); +T ms (long, char *); +T mv (long, T, char); +T cons (T, T); +T decl (T * (*) (T *), char *); + +T*L92(T*),*L15(T*),*L14(T*),*L13(T*),*L12(T*),*L11(T*),*L10(T*),*L9(T*),*L8(T*),*L7(T*),*L6(T*),*L5(T*),*L4(T*),*L3(T*),*L2(T*),*L1(T*); + +static T * +Ldata (T * my_pc) +{ +int cc = (((* ((T *) (my_pc))) >> 16) & 0xFF); +T B92, B91, B90, B15, B14, B13, B12, B11, B10, B9, B8, B7, B6, B5, B4, B3, B2, B1, tO7, tO6, tO5, tO4, tO3, tO2, tO1, tO0; +T object = mv (168, 0, ((Tchar) 1)); +T * cb = (T *) (((T) (object & 0x3FF)) | 0x400); +tO0 = mv (92, 0, ((Tchar) 1)); +B92 = decl (L92, ""); +B15 = decl (L15, ""); +B14 = decl (L14, ""); +B13 = decl (L13, ""); +B12 = decl (L12, ""); +B11 = decl (L11, ""); +B10 = decl (L10, ""); +B9 = decl (L9, ""); +B8 = decl (L8, ""); +B7 = decl (L7, ""); +B6 = decl (L6, ""); +B5 = decl (L5, ""); +B4 = decl (L4, ""); +B3 = decl (L3, ""); +B2 = decl (L2, ""); +B1 = decl (L1, ""); +cb[19] = ((((cc) & 0xFF) << 16) | (9 & 0xFF)); +cb[21] = ((((cc) & 0xFF) << 16) | ((10) & 0xFF)); +cb[23] = ((((cc) & 0xFF) << 16) | (11 & 0xFF)); +cb[25] = ((((cc) & 0xFF) << 16) | (12 & 0xFF)); +cb[27] = ((((cc) & 0xFF) << 16) | (13 & 0xFF)); +cb[29] = ((((cc) & 0xFF) << 16) | (14 & 0xFF)); +cb[31] = ((((cc) & 0xFF) << 16) | (15 & 0xFF)); +cb[35] = ((((cc) & 0xFF) << 16) | (17 & 0xFF)); +cb[36] = ((0x1A) << 26) | (((0x39) << 26) | 1) & 0x3FF; +cb[39] = ms (24, ((char *) "")); +cb[41] = ((0x1A) << 26) | (((0x39) << 26) | 1) & 0x3FF; +cb[44] = 3; +cb[46] = 2; +cb[48] = 3; +cb[50] = 6; +cb[52] = 4; +cb[146] = tO0; +((T *) (((tO0 & 0x3FF)) | 0x400))[92] = B1; +((T *) (((tO0 & 0x3FF)) | 0x400))[91] = B2; +((T *) (((tO0 & 0x3FF)) | 0x400))[2] = B90; +((T *) (((tO0 & 0x3FF)) | 0x400))[2] = B91; +((T *) (((tO0 & 0x3FF)) | 0x400))[1] = B92; +cb[58] = 0x2800 | (T) ((T *) ((B6 & 0x3FF) | 0x400) + 3); +cb[57] = 0x2800 | (T) ((T *) ((B7 & 0x3FF) | 0x400) + 3) & ~0xC00; +cb[56] = 0x2800 | (T) ((T *) ((B8 & 0x3FF) | 0x400) + 3) & ~0xC00; +cb[55] = 0x2800 | (T) ((T *) ((B9 & 0x3FF) | 0x400) + 3) & ~0xC00; +tO7 = mv (8, 0, ((Tchar) 1)); +tO4 = ms (9, ((char *) "")); +tO3 = mv (58, 0, ((Tchar) 1)); +tO6 = ms (4, ((char *) "")); +tO2 = mv (4, 0, ((Tchar) 1)); +tO5 = ms (4, ((char *) "")); +tO1 = mv (28, 0, ((Tchar) 1)); +cb[165] = tO1; +cb[163] = cons (((ms (10, ((char *) "")))), (cons (tO5, 0))); +cb[162] = cons (1, (cons (2, 0))); +cb[150] = cons (1, (cons (2, (cons (3, (cons (4, (cons (5, (cons (6, 0))))))))))); +cb[148] = tO7; +return cb; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930210-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930210-1.c new file mode 100755 index 0000000..47d2da2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930210-1.c @@ -0,0 +1,11 @@ +f() +{ + char c1, c2; + char *p1, *p2; + + do { + c1 = c2 = *p1++; + while (c1--) + *p2++ = *p1++; + } while (c2); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930217-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930217-1.c new file mode 100755 index 0000000..70f4a48 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930217-1.c @@ -0,0 +1,14 @@ +double g (); +typedef union { + struct { + unsigned s:1, e:8, f:23; + } u; + float f; +} s; + +f(x, n) + float x; +{ + ((s *)&x)->u.e -= n; + x = g((double)x, -n); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930222-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930222-1.c new file mode 100755 index 0000000..c6d6aa3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930222-1.c @@ -0,0 +1,16 @@ +typedef struct + { + long i; + double f; + } T; + +f (T *n1, T *n2) +{ + if (g (n2)) + return n1->i - n2->i; + else + { + double f = n1->f - n2->i; + return f == 0.0 ? 0 : (f > 0.0 ? 1 : -1); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930325-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930325-1.c new file mode 100755 index 0000000..24cea50 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930325-1.c @@ -0,0 +1,23 @@ +typedef unsigned uint; + +inline +g (uint *s, uint *d, uint c) +{ + while (c != 0) + { + *--d = *--s; + c--; + } +} + +f (uint *p1, uint c, uint *p2) +{ + while (c > 0 && *p1 == 0) + { + p1++; + c--; + } + if (c == 0) + return 1; + g (p2, p1, c); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.c new file mode 100755 index 0000000..97313d8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.c @@ -0,0 +1,6 @@ +struct +{ + char a, b, f[3]; +} s; + +long i = s.f-&s.b; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.x b/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.x new file mode 100755 index 0000000..6221456 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930326-1.x @@ -0,0 +1,7 @@ +# This doesn't work on mn10200 + +if { [istarget "mn10200*-*-*"] } { + set torture_compile_xfail "mn10200*-*-*" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930411-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930411-1.c new file mode 100755 index 0000000..bb03c13 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930411-1.c @@ -0,0 +1,36 @@ +int heap; + +g(){} + +f(int i1, int i2) +{ + i1 = *(int*)(i1 + 4); + if (i1 == 0) + goto L4; + else + goto L9; + L3: + i2 = heap - 8; + *(int*)i2 = 3; + *(int*)(i2 + 4) = i1; + heap -= 8; + return i2; + L4: + i1 = g(i2); + goto L5; + L5: + i1 = *(int*)(i1 + 4); + if (i1 == 0) + goto L7; + else + goto L8; + L7: + i1 = 0; + goto L3; + L8: + i1 = 1; + goto L3; + L9: + i1 = 1; + goto L3; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930421-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930421-1.c new file mode 100755 index 0000000..01b465f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930421-1.c @@ -0,0 +1,19 @@ +double q(double); + +f (int **x, int *r, int *s, int a, int b, int c, int d) +{ + int i, j, k, m, e, f, g, z[1024], y[2]; + + e = g = 0; + for (i = 0; i < a; i++) + for (j = 0; j < b; j++) + if (x[i][j]) + for (k = 0; k < c; k++) + { + f = q(1.5) + q(2.5); + if (g < y[f]) + g = e; + } + for (m = 0; m < 1; m++) + z[0] = m*2*d/3.0 - d; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930427-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930427-2.c new file mode 100755 index 0000000..53b6337 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930427-2.c @@ -0,0 +1,9 @@ +struct s { + int f; +}; + +f (w, v0, v1, v2, v3) + struct s *w; +{ + g (v0 ? 1 : w->f, v1 ? v3 : v2); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930503-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930503-1.c new file mode 100755 index 0000000..6889e8b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930503-1.c @@ -0,0 +1,8 @@ +f (const char *s, char *d, unsigned l) +{ + if (0) + while (1); + else + while (--l >= 0) + *d++ = *s++; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930503-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930503-2.c new file mode 100755 index 0000000..1b0ea34 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930503-2.c @@ -0,0 +1,5 @@ +f() +{ + struct { char x; } r; + g(r); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930506-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930506-1.c new file mode 100755 index 0000000..8c26ea3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930506-1.c @@ -0,0 +1,12 @@ +long long +f (a) + double a; +{ + double b; + unsigned long long v; + + b = a / 2.0; + v = (unsigned) b; + a -= (double) v; + return v; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930506-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930506-2.c new file mode 100755 index 0000000..e11e62f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930506-2.c @@ -0,0 +1,15 @@ +#ifndef NO_TRAMPOLINES +int f1() +{ + { int ___() { foo(1); } bar(___); } + return( { int ___() { foo(2); } bar(___);} ); +} + +int f2(int j) +{ + { int ___() { foo(j); } bar(___); } + return( { int ___() { foo(j); } bar(___);} ); +} +#else +int x; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930510-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930510-1.c new file mode 100755 index 0000000..8c46282 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930510-1.c @@ -0,0 +1,18 @@ +typedef long time_t; +static __const int mon_lengths[2][12] = { + 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, + 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 +}; +static time_t +f (janfirst, year, rulep, offset) + __const time_t janfirst; + __const int year; + register __const struct rule * __const rulep; + __const long offset; +{ + register int leapyear; + register time_t value; + register int i; + + value += mon_lengths[leapyear][i] * ((long) (60 * 60) * 24); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930513-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930513-1.c new file mode 100755 index 0000000..2e106ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930513-1.c @@ -0,0 +1,9 @@ +struct s { + int f1 : 26; + int f2 : 8; +}; + +f (struct s *x) +{ + return x->f2++ == 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930513-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930513-2.c new file mode 100755 index 0000000..a7f508c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930513-2.c @@ -0,0 +1,9 @@ +double g (); + +f (x) + double x; +{ + x = .85; + while (g () < x) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930513-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/930513-3.c new file mode 100755 index 0000000..f8d4e60 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930513-3.c @@ -0,0 +1,9 @@ +test () +{ + short *p, q[3]; + int x; + + p = q; + for (x = 0; x < 3; x++) + *p++ = 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930523-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930523-1.c new file mode 100755 index 0000000..5f2b5b5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930523-1.c @@ -0,0 +1,54 @@ +int v; + +f () +{ + unsigned long *a1, *a2; + int vertex2; + int c, x1, x2, dx1, dx2, dy1, dy2, e1, e2, s2; + unsigned long m, b; + int n; + unsigned long r; + int aba; + + do + { + if (dx2 >= dy2) + dx2 = dx2 % dy2; + + if (dx2 >= dy2) + { + s2 = - (dx2 / dy2); + dx2 = dx2 % dy2; + } + } + while (vertex2 / 65536); + + for (;;) + { + c = x2; + a2 = a1; + if (v) + a2 = 0; + + if (c + n) + { + m = b << (c * 8); + *a2 = (*a2 & ~m) | (r & m); + n += c; + + while (--n) + { + { + } + } + } + + a1 = 0; + x1 += 0; + if (e1 += dx1) + e1 -= dy1; + x2 += s2; + if (e2 += dx2) + e2 -= dy2; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930525-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930525-1.c new file mode 100755 index 0000000..00c2e26 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930525-1.c @@ -0,0 +1,7 @@ +typedef struct foo foo_t; +foo_t x; +struct foo { + int i; +}; + +foo_t x = { 10 }; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930527-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930527-1.c new file mode 100755 index 0000000..53e00e6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930527-1.c @@ -0,0 +1,16 @@ +enum {e0, e1}; + +int x[] = +{ + [e0] = 0 +}; + +f () +{ + switch (1) + { + case e0: + case e1: + break; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930529-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930529-1.c new file mode 100755 index 0000000..70b2cb8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930529-1.c @@ -0,0 +1,83 @@ +struct r +{ + int d1, d2; +}; + +struct km +{ + int d; +}; + +struct f1 +{ + char *fn; + char *fd; + char *fs; + char *ic; + void (*ff) (); +}; + +int g (); + +int y; +struct r *bs; +int bv; + +void b (); +char *w (); + +struct km **q; +char **mns; +int nm; +struct f1 **z; + +f (char *km, char *h) +{ + struct f1 *t; + int map = midn(km, strlen(km)); + int V; + int c; + struct r r; + struct f1 *cm; + + if (!g(&V, &cm, h, strlen(h))) + { + c = (cm - z[V]); + goto L; + } + + for (c = 0; c < nm; c++) + if (!strcmp (h, mns[c])) + { + V = -1; + goto L; + } + + for (c = 0; c < y; c++) + { + if (!memcmp (&bs[c], &r, 8)) + goto L; + } + + h = w (&r); + if (!bv) + { + bs = g (8); + t = (struct f1 *)g (20); + } + else + { + bs = g (bs, y * 8); + z[bv] = cr (z[bv], (1 + y) * 20); + t = &z[bv][y - 1]; + } + bs[y - 1] = r; + t->fs[0] = sp (y - 1); + t->fs[1] = 0; + t->ic = 0; + t->fd = 0; + t->fn = cs (h); + t->ff = b; + L: + g (q[map], V, c); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930530-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930530-1.c new file mode 100755 index 0000000..848e040 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930530-1.c @@ -0,0 +1,5 @@ +f () +{ + struct { char a, b; } x; + g (x, x, x, x); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930602-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930602-1.c new file mode 100755 index 0000000..5a0eb21 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930602-1.c @@ -0,0 +1,13 @@ +typedef struct { + int f[8]; +} T; + +f (w, l, r) + T *w; + unsigned short l, r; +{ + int i; + + for (i = l; i < r; i++) + g (w->f[i]); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930603-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930603-1.c new file mode 100755 index 0000000..643cc52 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930603-1.c @@ -0,0 +1,10 @@ +union u { union u *a; double d; }; +union u *s, g(); + +f() +{ + union u x = g(); + + s[0] = *x.a; + s[1] = g(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930607-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930607-1.c new file mode 100755 index 0000000..97c94b2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930607-1.c @@ -0,0 +1,9 @@ +typedef void f (); +typedef f *pf; +long long i; + +g () +{ + long long p = i; + ((pf) (long) p) (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930609-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930609-1.c new file mode 100755 index 0000000..d50d3c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930609-1.c @@ -0,0 +1,104 @@ +const int h (double value); +const double scalb (double x, int n); +const double logb (double x); +static const double a = 0; + +double f (y, x) + double y, x; +{ + static const double zero=0, one=1, small=1.0E-9, big=1.0E18; + double t,z,sy,sx,hi,lo; + int k,m; + + if (x!=x) + return x; + if (y!=y) + return y; + + sy = g (one); + sx = g (one); + + if (x==1) + { + y=g (y); + t=y; + if (h (t)) + goto begin; + } + + if (y==zero) + return (sx==one)?y:g (a); + + if (x==zero) + return g (a); + + if (!h (x)) + if (!h (y)) + return g ((sx==one)?a:3*a); + else + return g ((sx==one)?zero:a); + + if (!h (y)) + return g (a); + + x=g (x); + y=g (y); + if ((m=(k=logb (y))- logb (x)) > 60) + t=big+big; + else if (m < -80) + t=y/x; + else + { + t = y/x; + y = scalb (y,-k); + x=scalb (x,-k); + } + + begin: + if (t < 2.4375) + { + k = 4 * (t+0.0625); + switch (k) + { + case 0: + case 1: + if (t < small) + { + big + small; + return g ((sx>zero)?t:a-t); + } + hi = zero; lo = zero; break; + + case 2: + hi = a; lo = a; + z = x+x; + t = ((y+y) - x) / (z + y); break; + + case 3: + case 4: + hi = a; lo = zero; + t = (y - x) / (x + y); break; + + default: + hi = a; lo = a; + z = y-x; y=y+y+y; t = x+x; + t = ((z+z)-x) / (t + y); break; + } + } + else + { + hi = a; lo = zero; + + if (t <= big) + t = - x / y; + else + { + big+small; + t = zero; + } + } + + z = t*(z*(a+z*(a+z*(a+z*(a+z*(a+z*(a+z*(a+z*(a+z*(a+z*(a+z*a))))))))))); + + return g ((sx>zero)?z:a-z); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930611-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930611-1.c new file mode 100755 index 0000000..c216c09 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930611-1.c @@ -0,0 +1,7 @@ +float +f (float a1) +{ + union { float f; int l; } fl1; + fl1.f = a1; + return fl1.l ? 1.0 : a1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930618-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930618-1.c new file mode 100755 index 0000000..74c2157 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930618-1.c @@ -0,0 +1,8 @@ +f (s) +{ + int r; + + r = (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)) | (!g(s)); + + return r; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930621-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930621-1.c new file mode 100755 index 0000000..3679cf1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930621-1.c @@ -0,0 +1,30 @@ +int bytestart[5000 + 1]; +unsigned char modtext[400 + 1]; +unsigned char bytemem[2][45000L + 1]; + +long +modlookup (int l) +{ + signed char c; + long j; + long k; + signed char w; + long p; + while (p != 0) + { + while ((k < bytestart[p + 2]) && (j <= l) && (modtext[j] == bytemem[w][k])) + { + k = k + 1; + j = j + 1; + } + if (k == bytestart[p + 2]) + if (j > l) + c = 1; + else c = 4; + else if (j > l) + c = 3; + else if (modtext[j] < bytemem[w][k]) + c = 0; + else c = 2; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930623-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930623-1.c new file mode 100755 index 0000000..4b5b90b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930623-1.c @@ -0,0 +1,7 @@ +g (a, b) {} + +f (xx) + void* xx; +{ + __builtin_apply ((void*)g, xx, 200); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930623-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/930623-2.c new file mode 100755 index 0000000..8b61fc1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930623-2.c @@ -0,0 +1,91 @@ +extern unsigned short statesCount; +extern short cn_cadrstates[38][37]; +extern short coutstate[38][37][5]; +extern short ccostate[38][37][5]; +extern short cdel_E[38][37][5]; +extern short cn[38][37][5][3]; +extern short cd[38][37][5][3]; + +extern short c[4][37]; + +extern double vrandNext[64]; + +f (unsigned long long maddrOutState[37][8 * 8], + int maddrIndices[8 * 8], + int delta_E[8 * 8], + int after_x_hash[8 * 8], + int after_y_hash[8 * 8], + int after_z_hash[8 * 8], + int nActivePlane) +{ + int class[8 * 8]; + int ccoeff[8 * 8]; + int nx[8 * 8]; + int ny[8 * 8]; + int nz[8 * 8]; + int phat[8 * 8]; + int i; + int inState; + + for (inState = 0; inState < statesCount; inState++) { + long long Nf[8 * 8]; + long long Ns[8 * 8]; + long long Nb[8 * 8]; + int bbState[8 * 8]; + int not_flag_p[8 * 8]; + int j; + int max_cadrstates = 0; + + for (i = 0; i < nActivePlane; i++) { + int in = maddrIndices[i]; + int k = cn_cadrstates[class[in]][inState]; + + if (k > max_cadrstates) + max_cadrstates = k; + } + + for (j = 0; j < max_cadrstates; j++) { + int coState[8 * 8]; + int N_co[8 * 8]; + for (i = 0; i < nActivePlane; i++) { + int in = maddrIndices[i]; + int k = cn_cadrstates[class[in]][inState]; + + if (j < k-1) { + long long numer = (nx[in] * cn[class[in]][inState][j][0] + + ny[in] * cn[class[in]][inState][j][1] + + nz[in] * cn[class[in]][inState][j][2]); + long long denom = (nx[in] * cd[class[in]][inState][j][0] + + ny[in] * cd[class[in]][inState][j][1] + + nz[in] * cd[class[in]][inState][j][2]); + long long Nj = ((denom == 0) ? 0 : (((((long long)(const64(0,0x10000)) * numer * Ns[in]) / denom) + (long long)(((unsigned) vrandNext[in]) & 0xffff)) >> 16)); + int outState = coutstate[class[in]][inState][j]; + int this_coState = ccostate[class[in]][inState][j]; + int del_E = cdel_E[class[in]][inState][j]; + int old_Ns = Ns[in]; + + maddrOutState[outState][in] += Nj; + Ns[in] -= Nj; + delta_E[in] += Nj * del_E; + if (not_flag_p[in]) { + after_x_hash[in] += Nj * c[0][outState]; + after_y_hash[in] += Nj * c[1][outState]; + after_z_hash[in] += Nj * c[2][outState]; + } + coState[in] = this_coState; + N_co[in] = Nj; + } + else if (j == k-1) { + long long Nj = Ns[in]; + int outState = coutstate[class[in]][inState][j]; + int this_coState = ccostate[class[in]][inState][j]; + int del_E = cdel_E[class[in]][inState][j]; + maddrOutState[outState][in] += Nj; + delta_E[in] += Nj * del_E; + coState[in] = this_coState; + N_co[in] = Nj; + } + } + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930702-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930702-1.c new file mode 100755 index 0000000..9f51dd8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930702-1.c @@ -0,0 +1,5 @@ +f () +{ + {({});} + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930926-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930926-1.c new file mode 100755 index 0000000..fcfa4fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930926-1.c @@ -0,0 +1,7 @@ +int f () { return 0; } + +void +test () +{ + int j = { f() }; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/930927-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/930927-1.c new file mode 100755 index 0000000..81a4979 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/930927-1.c @@ -0,0 +1,3 @@ +#include <stddef.h> + +wchar_t s[5] = L"abcd"; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931003-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931003-1.c new file mode 100755 index 0000000..922b143 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931003-1.c @@ -0,0 +1,15 @@ +f (n, a) + int n; + double a[]; +{ + double b[51]; + int i, j; + + i = 0; + + for (j = n - 1; j > 0; j--) + b[i++] = 0; + + if (b[0] > b[i - 1]) + a[i] = b[i - 1]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931004-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931004-1.c new file mode 100755 index 0000000..0e741fd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931004-1.c @@ -0,0 +1,8 @@ +#define A "This is a long test that tests the structure initialization" +#define B A,A +#define C B,B,B,B +#define D C,C,C,C +int main() +{ + char *subs[]={ D, D, D, D, D, D, D, D, D, D, D, D, D, D, D}; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931013-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931013-1.c new file mode 100755 index 0000000..c237c0b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931013-1.c @@ -0,0 +1,10 @@ +g (); + +f () +{ + long ldata[2]; + int seed; + + seed = (ldata[0]) + (ldata[1] << 16); + g (seed); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931013-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/931013-2.c new file mode 100755 index 0000000..8fc0db4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931013-2.c @@ -0,0 +1,20 @@ +f (unsigned short Z[48]) +{ + int j; + unsigned short t1, t2, t3, T[48]; + unsigned short *p = T + 48; + + for (j = 1; j < 8; j++) + { + t1 = *Z++; + *--p = *Z++; + *--p = t1; + t1 = inv(*Z++); + t2 = -*Z++; + t3 = -*Z++; + *--p = inv(*Z++); + *--p = t2; + *--p = t3; + *--p = t1; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931013-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/931013-3.c new file mode 100755 index 0000000..e663b9a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931013-3.c @@ -0,0 +1,11 @@ +struct s +{ + int f; +}; + +struct s +f () +{ + int addr; + return *(struct s *) &addr; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931018-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931018-1.c new file mode 100755 index 0000000..7efe40e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931018-1.c @@ -0,0 +1,14 @@ +typedef struct +{ + int a, b; +} T; + +f (T *bs) +{ + long long x; + x = ({ + union { T s; long long l; } u; + u.s = *bs; + u.l; + }); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931031-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931031-1.c new file mode 100755 index 0000000..9015f54 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931031-1.c @@ -0,0 +1,9 @@ +struct s +{ + int pad:1, no:1; +}; + +f (struct s *b, int c) +{ + char d = b->no && c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931102-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931102-1.c new file mode 100755 index 0000000..a039c26 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931102-1.c @@ -0,0 +1,111 @@ +char *e (); + +#define SET \ + if (d > *b++) d |= a; \ + if (b) b = e(b); + +xxx() +{ + int a, d; + char *b, *c; + + while (1) { + while (1) { + while (1) { + if (a) { + switch (a) { + case 1: + while (1) { + SET + do { + SET + } while (1); + } + case 2: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + case 3: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + case 4: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + } + } + else { + switch (a) { + case 2: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + case 3: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + case 4: + while (1) { + if (d) { + do { + SET + } while (1); + } + else { + do { + SET + } while (1); + } + } + } + } + } + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931102-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/931102-2.c new file mode 100755 index 0000000..f39b271 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931102-2.c @@ -0,0 +1,21 @@ +typedef struct { + int a; +} VCR; + +typedef struct { + VCR vcr[8]; +} VCRC; + +typedef struct { + char vcr; +} OWN; + +OWN Own[16]; + +f (x, own) + VCRC *x; + OWN *own; +{ + x[own->vcr / 8].vcr[own->vcr % 8].a--; + x[own->vcr / 8].vcr[own->vcr % 8].a = x[own->vcr / 8].vcr[own->vcr % 8].a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/931203-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/931203-1.c new file mode 100755 index 0000000..3007ff5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/931203-1.c @@ -0,0 +1,5 @@ +v (a, i) + unsigned *a, i; +{ + a++[i] = 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/940611-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/940611-1.c new file mode 100755 index 0000000..90f7248 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/940611-1.c @@ -0,0 +1,10 @@ +f () +{ + do +L:; + while (0); + do + ; + while (0); + goto L; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/940712-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/940712-1.c new file mode 100755 index 0000000..10a6961 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/940712-1.c @@ -0,0 +1,4 @@ +f () +{ + return (*(volatile unsigned int *)8000) / 3; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/940718-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/940718-1.c new file mode 100755 index 0000000..505280f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/940718-1.c @@ -0,0 +1,7 @@ +extern double log (double) __attribute__ ((const)); + +f (double x) +{ + for (;;) + exp(log(x)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941014-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/941014-1.c new file mode 100755 index 0000000..d317015 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941014-1.c @@ -0,0 +1,11 @@ +f (to) + char *to; +{ + unsigned int wch; + register length; + unsigned char tmp; + unsigned int mult = 10; + + tmp = (wch>>(unsigned int)(length * mult)); + *to++ = (unsigned char)tmp; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941014-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/941014-2.c new file mode 100755 index 0000000..01e9a67 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941014-2.c @@ -0,0 +1,37 @@ +void +f (n, ppt, xrot) +{ + int tileWidth; + int nlwSrc; + int srcx; + int v3, v4; + register unsigned long ca1, cx1, ca2, cx2; + unsigned long *pSrcLine; + register unsigned long *pDst; + register unsigned long *pSrc; + register unsigned long b, tmp; + unsigned long tileEndMask; + int v1, v2; + int tileEndPart; + int needFirst; + tileEndPart = 0; + v1 = tileEndPart << 5; + v2 = 32 - v1; + while (n--) + { + if ((srcx = (ppt - xrot) % tileWidth) < 0) + if (needFirst) + if (nlwSrc == 1) + { + tmp = b; + if (tileEndPart) + b = (*pSrc & tileEndMask) | (*pSrcLine >> v1); + } + if (tileEndPart) + b = (tmp << v1) | (b >> v2); + if (v4 != 32) + *pDst = (*pDst & ((tmp << v3) | (b >> v4) & ca1 ^ cx1) + ^ (((tmp << v3) | (b >> v4)) & ca2 ^ cx2)); + *pDst = *pDst & tmp; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941014-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/941014-3.c new file mode 100755 index 0000000..6dcb893 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941014-3.c @@ -0,0 +1,72 @@ +typedef unsigned char byte; +typedef unsigned int uint; +typedef unsigned long ulong; +typedef ulong gs_char; +typedef struct gs_show_enum_s gs_show_enum; +typedef struct gs_font_s gs_font; +typedef struct gx_font_stack_item_s { + gs_font *font; +} gx_font_stack_item; +typedef struct gx_font_stack_s { + gx_font_stack_item items[1 + 5 ]; +} gx_font_stack; +struct gs_show_enum_s { + gx_font_stack fstack; +}; +typedef enum { + ft_composite = 0, +} font_type; +struct gs_font_s { + font_type FontType; +}; +typedef enum { + fmap_escape = 3, + fmap_shift = 8 + } fmap_type; +typedef struct gs_type0_data_s { + fmap_type FMapType; +} gs_type0_data; +gs_type0_next_char(register gs_show_enum *penum) +{ + const byte *p; + int fdepth; + gs_font *pfont; + gs_type0_data *pdata; + uint fidx; + gs_char chr; + for (; pfont->FontType == ft_composite; ) + { + fmap_type fmt; + switch ( fmt ) + { + do {} while (0); + rdown: + continue; + case fmap_shift: + p++; + do {} while (0); + goto rdown; + } + break; + } + up: + while ( fdepth > 0 ) + { + switch ( pdata->FMapType ) + { + default: + continue; + case fmap_escape: + fidx = *++p; + do {} while (0); + if ( fidx == chr && fdepth > 1 ) + goto up; + down: + fdepth--; + do {} while (0); + } + break; + } + while ( (pfont = penum->fstack.items[fdepth].font)->FontType == ft_composite ) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941014-4.c b/gcc_arm/testsuite/gcc.c-torture/compile/941014-4.c new file mode 100755 index 0000000..9e673f3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941014-4.c @@ -0,0 +1,16 @@ +#ifndef NO_LABEL_VALUES +f (int *re) +{ + int *loops = 0, *loope = 0; + unsigned dat0 = 0; + static void *debug = &&firstdebug; + + firstdebug: + g (loops, loope); + + if (dat0 & 1) + re[(dat0 >> 2) & 3] = 0; +} +#else +int x; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941019-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/941019-1.c new file mode 100755 index 0000000..257b594 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941019-1.c @@ -0,0 +1 @@ +__complex__ long double sub (__complex__ long double cld) { return cld; } diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941111-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/941111-1.c new file mode 100755 index 0000000..3f0c28b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941111-1.c @@ -0,0 +1,8 @@ +main () +{ + struct S { int i; char c; } obj1, obj2; + + foo (); + if (obj1.c != obj2.c) + bar (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/941113-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/941113-1.c new file mode 100755 index 0000000..5c2e0b6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/941113-1.c @@ -0,0 +1,12 @@ +typedef void foo (void); + +f (x) +{ + if (x) + { + const foo* v; + (*v)(); + } + else + g (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950122-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950122-1.c new file mode 100755 index 0000000..8dea790 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950122-1.c @@ -0,0 +1,5 @@ +int +foo (int i, unsigned short j) +{ + return j *= i; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950124-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950124-1.c new file mode 100755 index 0000000..e723954 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950124-1.c @@ -0,0 +1,15 @@ +f () +{ + if (g ()) + h (); + else + { + do + { + return 0; + break; + } + while (1); + } + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950221-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950221-1.c new file mode 100755 index 0000000..1414763 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950221-1.c @@ -0,0 +1,16 @@ +short v = -1; + +typedef struct +{ + short network; +} atype; + +void f () +{ + static atype config; + atype *cp; + short net; + cp = &config; + cp->network = (v == -1) ? 100 : v; + net = cp->network; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950329-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950329-1.c new file mode 100755 index 0000000..7c047f5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950329-1.c @@ -0,0 +1,19 @@ +f () +{ + int i; + for (i = 1;; i = 0) + { + if (h ()) + { + if (i) + g (); + g (h ()); + g (h ()); + } + else + { + g (); + break; + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950512-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950512-1.c new file mode 100755 index 0000000..e43ec48 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950512-1.c @@ -0,0 +1,6 @@ +typedef unsigned short uint16; +f (unsigned char *w) +{ + w[2] = (uint16) ((((g (0) % 10000 + 42) & 0xFF) << 8) | (((g (0) % 10000 + 42) >> 8) & 0xFF)) & 0xFF, + w[3] = (uint16) ((((g (0) % 10000 + 42) & 0xFF) << 8) | (((g (0) % 10000 + 42) >> 8) & 0xFF)) >> 8; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950530-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950530-1.c new file mode 100755 index 0000000..2b714e0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950530-1.c @@ -0,0 +1,4 @@ +f (int *s, int *t) +{ + return (t - s) / 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950607-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950607-1.c new file mode 100755 index 0000000..851defc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950607-1.c @@ -0,0 +1,38 @@ +typedef struct { + int component_id; + int component_index; + int h_samp_factor; + int v_samp_factor; +} jpeg_component_info; +struct jpeg_common_struct { + struct jpeg_error_mgr * err; +}; +typedef struct jpeg_common_struct * j_common_ptr; +typedef struct jpeg_compress_struct * j_compress_ptr; +struct jpeg_compress_struct { + struct jpeg_error_mgr * err; + int num_components; + jpeg_component_info * comp_info; + int max_h_samp_factor; + int max_v_samp_factor; +}; +struct jpeg_error_mgr { + int msg_code; +}; + +void +jinit_downsampler (j_compress_ptr cinfo) +{ + int ci; + jpeg_component_info * compptr; + + for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; + ci++, compptr++) { + if (compptr->h_samp_factor == cinfo->max_h_samp_factor && + compptr->v_samp_factor == cinfo->max_v_samp_factor) { + } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 && + (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) { + } else + cinfo->err->msg_code = 0; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950610-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950610-1.c new file mode 100755 index 0000000..16d0d0e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950610-1.c @@ -0,0 +1 @@ +f (int n, int a[2][n]) {} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950612-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950612-1.c new file mode 100755 index 0000000..cb3cb0a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950612-1.c @@ -0,0 +1,134 @@ +typedef enum +{ + LODI, + STO, + ADDI, + ADD, + SUBI, + SUB, + MULI, + MUL, + DIVI, + DIV, + INC, + DEC +} INSN; + +f (pc) + short *pc; +{ + long long stack[16], *sp = &stack[16], acc = 0; + + for (;;) + { + switch ((INSN)*pc++) + { + case LODI: + *--sp = acc; + acc = ((long long)*pc++) << 32; + break; + case STO: + return (acc >> 32) + (((((unsigned long long) acc) & 0xffffffff) & (1 << 31)) != 0); + break; + case ADDI: + acc += ((long long)*pc++) << 32; + break; + case ADD: + acc = *sp++ + acc; + break; + case SUBI: + acc -= ((long long)*pc++) << 32; + break; + case SUB: + acc = *sp++ - acc; + break; + case MULI: + acc *= *pc++; + break; + case MUL: + { + long long aux; + unsigned char minus; + + minus = 0; + aux = *sp++; + if (aux < 0) + { + minus = ~minus; + aux = -aux; + } + if (acc < 0) + { + minus = ~minus; + acc = -acc; + } + acc = ((((((unsigned long long) acc) & 0xffffffff) * (((unsigned long long) aux) & 0xffffffff)) >> 32) + + ((((unsigned long long) acc) >> 32) * (((unsigned long long) aux) & 0xffffffff) + (((unsigned long long) acc) & 0xffffffff) + (((unsigned long long) aux) >> 32)) + + (((((unsigned long long) acc) >> 32) * (((unsigned long long) aux) >> 32)) << 32)); + if (minus) + acc = -acc; + } + break; + case DIVI: + { + short aux; + + aux = *pc++; + acc = (acc + aux / 2) / aux; + } + break; + case DIV: + { + long long aux; + unsigned char minus; + + minus = 0; + aux = *sp++; + if (aux < 0) + { + minus = ~minus; + aux = -aux; + } + if (acc < 0) + { + minus = ~minus; + acc = -acc; + } + + if (((unsigned long long)acc) == 0) + acc = (unsigned long long)-1 / 2; + else if ((((unsigned long long) ((unsigned long long)acc)) & 0xffffffff) == 0) + acc = ((unsigned long long)aux) / (((unsigned long long) ((unsigned long long)acc)) >> 32); + else if ((((unsigned long long) ((unsigned long long)acc)) >> 32) == 0) + acc = ((((unsigned long long)aux) / ((unsigned long long)acc)) << 32) + + ((((unsigned long long)aux) % ((unsigned long long)acc)) << 32) / ((unsigned long long)acc); + else + { + unsigned char shift; + unsigned long hi; + + shift = 32; + hi = (((unsigned long long) ((unsigned long long)acc)) >> 32); + do { + if (hi & ((unsigned long)1 << (shift - 1))) + break; + } while (--shift != 0); + printf("shift = %d\n", shift); + acc = ((((unsigned long long)aux) / ((unsigned long long)acc)) << 32) + + (((((unsigned long long)aux) % ((unsigned long long)acc)) << (32 - shift)) + ((((unsigned long long)acc) >> shift) / 2)) / (((unsigned long long)acc) >> shift); + } + + if (minus) + acc = -acc; + } + break; + case INC: + acc += 1; + break; + case DEC: + acc -= 1; + break; + } + printf("%08lx.%08lx\n", (long)(((unsigned long long) acc) >> 32) , (long)(((unsigned long long) acc) & 0xffffffff)); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950613-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950613-1.c new file mode 100755 index 0000000..8aa757f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950613-1.c @@ -0,0 +1,31 @@ +#ifndef NO_LABEL_VALUES +f () +{ + long *sp; + long *pc; + + static void *dummy[] = + { + &&L1, + &&L2, + }; + + L1: + { + float val; + val = *(float *) sp; + val = -val; + *(float *) sp = val; + goto *pc++; + } + + L2: + { + float from; + *(long long *) sp = from; + goto *pc++; + } +} +#else +int x; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950618-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950618-1.c new file mode 100755 index 0000000..4229da4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950618-1.c @@ -0,0 +1,2 @@ +static __inline__ int f () { return g (); } +int g () { return f (); } diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950719-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950719-1.c new file mode 100755 index 0000000..d3277fa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950719-1.c @@ -0,0 +1,11 @@ +typedef struct +{ + int Header; + char data[4092]; +} t_node; + +f (unsigned short rid, unsigned short record_length) +{ + t_node tnode; + g (rid, tnode.data + rid * record_length); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950729-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950729-1.c new file mode 100755 index 0000000..cfdbad9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950729-1.c @@ -0,0 +1,39 @@ +static const char * const lcset = "0123456789abcdef"; +static const char * const ucset = "0123456789ABCDEF"; + +char * +f (char *buffer, long long value, char type) +{ + int base, i; + + i = 128 - 1; + buffer[i--] = '\0'; + + switch (type) + { + case 'u': + case 'o': + case 'x': + case 'X': + if (type == 'u') + base = 10; + else if (type == 'o') + base = 8; + else + base = 16; + + while (i >= 0) + { + if (type == 'X') + buffer[i--] = ucset[((unsigned long long) value) % base]; + else + buffer[i--] = lcset[((unsigned long long) value) % base]; + + if ((value = ((unsigned long long) value) / base) == 0) + break; + } + break; + } + + return &buffer[++i]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950816-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950816-1.c new file mode 100755 index 0000000..da849bb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950816-1.c @@ -0,0 +1,7 @@ +f () +{ + unsigned char b[2]; + float f; + b[0] = (unsigned char) f / 256; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950816-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/950816-2.c new file mode 100755 index 0000000..41e770d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950816-2.c @@ -0,0 +1,8 @@ +f () +{ + int i; + float a,b,c; + unsigned char val[2]; + i = func (&c); + val[0] = c < a ? a : c >= 1.0 ? b : c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950816-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/950816-3.c new file mode 100755 index 0000000..b3cb0fc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950816-3.c @@ -0,0 +1,8 @@ +f () +{ + int i; + short x, z; + for (i = 0; i <= 1; i++) + x = i; + return x + z; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950910-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950910-1.c new file mode 100755 index 0000000..1be2aa5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950910-1.c @@ -0,0 +1,22 @@ +f (char *p) +{ + char c; + + c = *++p; + if (c != ' ') + return 0; + for (;;) + { + c = *p; + if (g (c)) + p++; + else + { + if (c == ' ') + break; + else + return 0; + } + } + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950919-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950919-1.c new file mode 100755 index 0000000..8320f6d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950919-1.c @@ -0,0 +1,5 @@ +#define empty +#if empty#cpu(m68k) +#endif + +f (){} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950921-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950921-1.c new file mode 100755 index 0000000..371c7d5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950921-1.c @@ -0,0 +1,12 @@ +f () +{ + union + { + signed char c; + double d; + } u; + + u.c = 1; + u.c = 1; + return u.c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/950922-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/950922-1.c new file mode 100755 index 0000000..73574f3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/950922-1.c @@ -0,0 +1,68 @@ +struct sw { + const void *x; + int r; +}; +struct sq { + struct sw *q_w; + int t; + int z; +}; + +int +f (int ch, char *fp, char *ap) +{ + register int n; + register char *cp; + register struct sw *p; + register int f; + int prec; + double _double; + int expt; + int ndig; + char expstr[7]; + unsigned long long _uquad; + struct sq q; + struct sw w[8]; + static char zeroes[16]; + + for (;;) { + switch (ch) { + case 'd': + _double = (double) (ap += 8, *((double *) (ap - 8))); + break; + case 'o': + goto nosign; + case 'u': + _uquad = (f & 0x020 ? (ap += 8, *((long long *) (ap - 8))) : f & 0x010 ? (ap += 4, *((long *) (ap - 4))) : f & 0x040 ? (long)(short)(ap += 4, *((int *) (ap - 4))) : (long)(ap += 4, *((int *) (ap - 4)))); + goto nosign; + case 'x': + _uquad = (f & 0x020 ? (ap += 8, *((long long *) (ap - 8))) : f & 0x010 ? (ap += 4, *((long *) (ap - 4))) : f & 0x040 ? (long)(unsigned short)(ap += 4, *((int *) (ap - 4))) : (long)(ap += 4, *((int *) (ap - 4)))); + nosign: + if (_uquad != 0 || prec != 0); + break; + default: + } + if ((f & 0x100) == 0) { + } else { + if (ch >= 'f') { + if (_double == 0) { + if (expt < ndig || (f & 0x001) != 0) { + { if ((n = (ndig - 1)) > 0) { while (n > 16) {{ p->x = (zeroes); p->r = 16; q.z += 16; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} n -= 16; }{ p->x = (zeroes); p->r = n; q.z += n; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }}}} + } + } else if (expt <= 0) { + { p->x = ("0"); p->r = 1; q.z += 1; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + { p->x = 0; p->r = 1; q.z += 1; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + { if ((n = (-expt)) > 0) { while (n > 16) {{ p->x = (zeroes); p->r = 16; q.z += 16; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} n -= 16; }{ p->x = (zeroes); p->r = n; q.z += n; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} }} + { p->x = cp; p->r = ndig; q.z += ndig; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + } else { + { p->x = cp; p->r = expt; q.z += expt; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + cp += expt; + { p->x = ("."); p->r = 1; q.z += 1; p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + { p->x = cp; p->r = (ndig-expt); q.z += (ndig-expt); p++; if (++q.t >= 8) { if (g(fp, &q)) goto error; p = w; }} + } + } + } + } + + error: +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951004-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951004-1.c new file mode 100755 index 0000000..1ca6081 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951004-1.c @@ -0,0 +1,23 @@ +typedef struct +{ + short v, h; +} S; + +S a; + +f (S pnt) +{ + S mpnt, mtp; + + (&pnt)->v -= 1; + mpnt = pnt; + mtp = a; + if (mtp.v != mpnt.v) + { + S tpnt; + + tpnt = mtp; + mtp = mpnt; + mpnt = tpnt; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951106-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951106-1.c new file mode 100755 index 0000000..09cba20 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951106-1.c @@ -0,0 +1,4 @@ +f (double a, double b) +{ + g (a, 0, b); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951116-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951116-1.c new file mode 100755 index 0000000..100d690 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951116-1.c @@ -0,0 +1,9 @@ +f () +{ + long long i; + int j; + long long k = i = j; + + int inner () {return j + i;} + return k; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951128-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951128-1.c new file mode 100755 index 0000000..5e4dc70 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951128-1.c @@ -0,0 +1,5 @@ +char a[]; +f (const int i) +{ + a[i] = 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951220-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951220-1.c new file mode 100755 index 0000000..33e98f6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951220-1.c @@ -0,0 +1,4 @@ +f (char *x) +{ + return (*x & 2) || (*x & 3); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/951222-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/951222-1.c new file mode 100755 index 0000000..b8246f5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/951222-1.c @@ -0,0 +1,15 @@ +extern long long foo (); + +long long +sub1 () +{ + char junk[10000]; + register long long a, b, c; + + b = foo (); + + setjmp (); + a = foo (); + c = a - b; + return c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960106-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960106-1.c new file mode 100755 index 0000000..c8228aa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960106-1.c @@ -0,0 +1,4 @@ +f (a) +{ + return (a & 1) && !(a & 2 & 4); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960130-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960130-1.c new file mode 100755 index 0000000..ed8dab4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960130-1.c @@ -0,0 +1,8 @@ +int a[1]; + +int +main() +{ + extern int a[]; + return *a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960201-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960201-1.c new file mode 100755 index 0000000..adc4623 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960201-1.c @@ -0,0 +1,5 @@ +union foo +{ + char a; + int x[2]; +} __attribute__ ((transparent_union)); diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960218-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960218-1.c new file mode 100755 index 0000000..46fbf77 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960218-1.c @@ -0,0 +1,2 @@ +#define X(x) x +int main() { return X(0/* *//* */); } diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960220-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960220-1.c new file mode 100755 index 0000000..766a066 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960220-1.c @@ -0,0 +1,6 @@ +f () +{ + unsigned long long int a = 0, b; + while (b > a) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960221-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960221-1.c new file mode 100755 index 0000000..0e02496 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960221-1.c @@ -0,0 +1,11 @@ +struct s1 { int f1; }; + +struct s2 { + struct s1 a; + int f2; +}; + +foo (struct s2 *ptr) +{ + *ptr = (struct s2) {{}, 0}; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960319-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960319-1.c new file mode 100755 index 0000000..f3d95ab --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960319-1.c @@ -0,0 +1,10 @@ +static void +f() +{ + long long a[2]; + int i; + if (g()) + if (h()) + ; + *a |= (long long)i << 65 ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960514-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960514-1.c new file mode 100755 index 0000000..1d38cfd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960514-1.c @@ -0,0 +1,12 @@ +struct s { + unsigned long long t[5]; +}; + +void +f (struct s *d, unsigned long long *l) +{ + int i; + + for (i = 0; i < 5; i++) + d->t[i] += l[i]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960704-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960704-1.c new file mode 100755 index 0000000..5a9d35c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960704-1.c @@ -0,0 +1,10 @@ +struct A { + double d; +}; + +struct A f (); + +main () +{ + struct A a = f(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/960829-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/960829-1.c new file mode 100755 index 0000000..8c6163d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/960829-1.c @@ -0,0 +1,4 @@ +f () +{ + g (0, 0.0, 0.0, 0.0, 0.0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961004-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961004-1.c new file mode 100755 index 0000000..6407b62 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961004-1.c @@ -0,0 +1,37 @@ +void +f1 (o1, o2, o3, i, j, k) + long long *o1, *o2, *o3; + int i, j, k; +{ + while (--i) + o1[i] = o2[j >>= 1] + o3[k >>= 1]; +} + +void +f2 (o1, o2, o3, i, j, k) + long long *o1, *o2, *o3; + int i, j, k; +{ + while (--i) + o1[i] = o2[j >>= 1] - o3[k >>= 1]; +} + +void +f3 (o1, o2, o3, i, j, k) + long long *o1, *o3; + unsigned *o2; + int i, j, k; +{ + while (--i) + o1[i] = o2[j >>= 1] + o3[k >>= 1]; +} + +void +f4 (o1, o2, o3, i, j, k) + long long *o1, *o2; + unsigned *o3; + int i, j, k; +{ + while (--i) + o1[i] = o2[j >>= 1] - o3[k >>= 1]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961010-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961010-1.c new file mode 100755 index 0000000..d6145bc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961010-1.c @@ -0,0 +1 @@ +double f (double x) { return x == 0 ? x : 0.0; } diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961019-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961019-1.c new file mode 100755 index 0000000..0ea6ec6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961019-1.c @@ -0,0 +1,11 @@ +char _hex_value[256]; + +void +hex_init () +{ + int i; + for (i = 0; i < 256; i++) + _hex_value[i] = 99; + for (i = 0; i < 10; i++) + _hex_value['0' + i] = i; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961031-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961031-1.c new file mode 100755 index 0000000..ea8718f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961031-1.c @@ -0,0 +1,16 @@ +struct s { + double d; +} sd; + +struct s g () __attribute__ ((const)); + +struct s +g () +{ + return sd; +} + +f () +{ + g (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961126-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961126-1.c new file mode 100755 index 0000000..f3b6af5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961126-1.c @@ -0,0 +1,107 @@ +int *p; + +main() +{ + int i = sub (); + + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + i = -i; + if (*p != i) + goto quit; + + i = -i; +quit: + sub2 (i); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.c new file mode 100755 index 0000000..0f066ac --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.c @@ -0,0 +1,14 @@ +struct s { + char a[0x32100000]; + int x:30, y:30; +}; + +int +main () +{ + struct s* p; + + p = (struct s*) 0; + if (p->x == p->y) + exit (1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.x b/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.x new file mode 100755 index 0000000..dad1a21 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/961203-1.x @@ -0,0 +1,7 @@ +# This doesn't work on any host with 32 bit int or smaller. + +# Because this test tends to consume lots of system resources and doesn't +# currently work, don't actually run it. Just report a failure. +setup_xfail "*-*-*" +fail "gcc.c-torture/compile/961203-1.c" +return 1 ;# `1' says we handled the testcase ourselves diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/970206-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/970206-1.c new file mode 100755 index 0000000..95196cd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/970206-1.c @@ -0,0 +1,13 @@ +struct Rect +{ + int iA; + int iB; + int iC; + int iD; +}; + +void +f (int * const this, struct Rect arect) +{ + g (*this, arect); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/970214-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/970214-1.c new file mode 100755 index 0000000..508ea9e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/970214-1.c @@ -0,0 +1,3 @@ +#include <stddef.h> +#define L 264 +wchar_t c = L'X'; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980329-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980329-1.c new file mode 100755 index 0000000..d11b49b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980329-1.c @@ -0,0 +1,72 @@ +typedef unsigned long int size_t; +struct re_pattern_buffer + { + unsigned char *buffer; + unsigned long int used; + }; +struct re_registers + { + int *start; + }; + +static const char **regstart, **regend; +static const char **old_regend; + +static int +re_match_2_internal (struct re_pattern_buffer *bufp, + struct re_registers *regs) +{ + unsigned char *p = bufp->buffer; + unsigned char *pend = p + bufp->used; + + for (;;) + { + int highest_active_reg = 1; + if (bufp) + { + int i; + for (i = 1;; i++) + regs->start[i] = 0; + } + + switch ((unsigned int) *p++) + { + case 1: + { + unsigned char r = *p; + if (r) + highest_active_reg = r; + } + if (p + 2 == pend) + { + char is_a_jump_n = 0; + int mcnt = 0; + unsigned char *p1; + + p1 = p + 2; + switch (*p1++) + { + case 2: + is_a_jump_n = 1; + case 1: + do { do { mcnt = *p1; } while (0); p1 += 2; } while (0); + if (is_a_jump_n) + p1 = 0; + } + + if (mcnt && *p1 == 0) + { + unsigned r; + for (r = 0; r < (unsigned) *p + (unsigned) *(p + 1); r++) + { + if (regend[0] >= regstart[r]) + regend[r] = old_regend[r]; + } + do { while (0 < highest_active_reg + 1) { } } while (0); + } + } + } + } + + return -1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980408-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980408-1.c new file mode 100755 index 0000000..09bf430 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980408-1.c @@ -0,0 +1,129 @@ +typedef struct _RunlengthPacket +{ + unsigned short + red, + green, + blue, + length; + unsigned short + index; +} RunlengthPacket; +typedef struct _Image +{ + int + status, + temporary; + char + filename[1664 ]; + long int + filesize; + int + pipe; + char + magick[1664 ], + *comments, + *label, + *text; + unsigned int + matte; + unsigned int + columns, + rows, + depth; + unsigned int + scene, + number_scenes; + char + *montage, + *directory; + unsigned int + colors; + double + gamma; + float + x_resolution, + y_resolution; + unsigned int + mean_error_per_pixel; + double + normalized_mean_error, + normalized_maximum_error; + unsigned long + total_colors; + char + *signature; + unsigned int + packets, + runlength, + packet_size; + unsigned char + *packed_pixels; + long int + magick_time; + char + magick_filename[1664 ]; + unsigned int + magick_columns, + magick_rows; + char + *geometry, + *page; + unsigned int + dispose, + delay, + iterations; + unsigned int + orphan; + struct _Image + *previous, + *list, + *next; +} Image; + Image *MinifyImage(Image *image) +{ + Image + *minified_image; + register RunlengthPacket + *q, + *s, + *s0, + *s1, + *s2, + *s3; + register unsigned int + x; + unsigned int + blue, + green, + red; + unsigned long + total_matte, + total_blue, + total_green, + total_red; + unsigned short + index; + for (x=0; x < (image->columns-1); x+=2) + { + total_red=0; + total_green=0; + total_blue=0; + total_matte=0; + s=s0; + total_red+=( 3 )*(s->red); total_green+=( 3 )*(s->green); total_blue+=( 3 )*(s->blue); total_matte+=( 3 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 3 )*(s->red); total_green+=( 3 )*(s->green); total_blue+=( 3 )*(s->blue); total_matte+=( 3 )*(s->index); s++; ; + s=s1; + total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 15 )*(s->red); total_green+=( 15 )*(s->green); total_blue+=( 15 )*(s->blue); total_matte+=( 15 )*(s->index); s++; ; total_red+=( 15 )*(s->red); total_green+=( 15 )*(s->green); total_blue+=( 15 )*(s->blue); total_matte+=( 15 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; + s=s2; + total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 15 )*(s->red); total_green+=( 15 )*(s->green); total_blue+=( 15 )*(s->blue); total_matte+=( 15 )*(s->index); s++; ; total_red+=( 15 )*(s->red); total_green+=( 15 )*(s->green); total_blue+=( 15 )*(s->blue); total_matte+=( 15 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; + s=s3; + total_red+=( 3 )*(s->red); total_green+=( 3 )*(s->green); total_blue+=( 3 )*(s->blue); total_matte+=( 3 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 7 )*(s->red); total_green+=( 7 )*(s->green); total_blue+=( 7 )*(s->blue); total_matte+=( 7 )*(s->index); s++; ; total_red+=( 3 )*(s->red); total_green+=( 3 )*(s->green); total_blue+=( 3 )*(s->blue); total_matte+=( 3 )*(s->index); s++; ; + red=(unsigned short) ((total_red+63) >> 7); + green=(unsigned short) ((total_green+63) >> 7); + blue=(unsigned short) ((total_blue+63) >> 7); + index=(unsigned short) ((total_matte+63) >> 7); + if ((red == q->red) && (green == q->green) && (blue == q->blue) && + (index == q->index) && ((int) q->length < 65535L )) + q->length++; + } + return(minified_image); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980504-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980504-1.c new file mode 100755 index 0000000..7b757cc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980504-1.c @@ -0,0 +1,28 @@ +typedef struct _geom_elem { + double coeffs[6]; +} pGeomDefRec, *pGeomDefPtr; +typedef struct _mpgeombanddef { + int yOut; + int in_width; +} mpGeometryBandRec, *mpGeometryBandPtr; +typedef void *pointer; +typedef unsigned char CARD8; +typedef CARD8 BytePixel; +void BiGL_B (OUTP,srcimg,width,sline,pedpvt,pvtband) pointer OUTP; +pointer *srcimg; +register int width; +int sline; +pGeomDefPtr pedpvt; mpGeometryBandPtr pvtband; +{ + register float s, t, st; + register int isrcline,isrcpix; + register int srcwidth = pvtband->in_width - 1; + register BytePixel val; + register BytePixel *ptrIn, *ptrJn; + register double a = pedpvt->coeffs[0]; + register double c = pedpvt->coeffs[2]; + register double srcpix = a * ((double)(0.0000)) + pedpvt->coeffs[1] * (pvtband->yOut + ((double)(0.0000)) ) + pedpvt->coeffs[4]; + register double srcline = c * ((double)(0.0000)) + pedpvt->coeffs[3] * (pvtband->yOut + ((double)(0.0000)) ) + pedpvt->coeffs[5]; + if ( (isrcpix >= 0) && (isrcpix < srcwidth) ) + val = ptrIn[isrcpix] * ((float)1. - s - t + st) + ptrIn[isrcpix+1] * (s - st) + ptrJn[isrcpix] * (t - st) + ptrJn[isrcpix+1] * (st) + (float)0.5 ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980506-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980506-1.c new file mode 100755 index 0000000..6ef7796 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980506-1.c @@ -0,0 +1,63 @@ +unsigned char TIFFFax2DMode[20][256]; +unsigned char TIFFFax2DNextState[20][256]; +unsigned char TIFFFaxUncompAction[20][256]; +unsigned char TIFFFaxUncompNextState[20][256]; +unsigned char TIFFFax1DAction[230][256]; +unsigned char TIFFFax1DNextState[230][256]; + +typedef struct tableentry { + unsigned short length; + unsigned short code; + short runlen; +} tableentry; + +extern tableentry TIFFFaxWhiteCodes[]; +extern tableentry TIFFFaxBlackCodes[]; + +static short sp_data, sp_bit; + +static unsigned char +fetchByte (inbuf) + +unsigned char **inbuf; + +{ + unsigned char byte = **inbuf; + (*inbuf)++; + return (byte); +} + +static int +decode_white_run (inbuf) + +unsigned char **inbuf; + +{ + short state = sp_bit; + short action; + int runlen = 0; + + for (;;) + { + if (sp_bit == 0) + { + nextbyte: + sp_data = fetchByte (inbuf); + } + + action = TIFFFax1DAction[state][sp_data]; + state = TIFFFax1DNextState[state][sp_data]; + if (action == 0 ) + goto nextbyte; + if (action == 1 ) + return (-1 ); + if (action == 210 ) + return (-3 ); + sp_bit = state; + action = (TIFFFaxWhiteCodes[ action - 2 ].runlen) ; + runlen += action; + if (action < 64) + return (runlen); + } +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980506-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/980506-2.c new file mode 100755 index 0000000..6f6fe19 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980506-2.c @@ -0,0 +1,89 @@ +/* + * inspired by glibc-2.0.6/sysdeps/libm-ieee754/s_nextafterf.c + * + * gcc -O2 -S -DOP=+ gives faddp %st(1),%st + * gcc -O2 -S -DOP=* gives fmulp %st(1),%st + * gcc -O2 -S -DOP=- gives fsubrp %st(1),%st + * gcc -O2 -S -DOP=/ gives fdivrp %st(1),%st + */ + +#ifndef OP +#define OP * +#endif + +typedef int int32_t __attribute__ ((__mode__ ( __SI__ ))) ; +typedef unsigned int u_int32_t __attribute__ ((__mode__ ( __SI__ ))) ; + +typedef union +{ + float value; + u_int32_t word; +} ieee_float_shape_type; + +float __nextafterf(float x, float y) +{ + int32_t hx,hy,ix,iy; + + { + ieee_float_shape_type gf_u; + gf_u.value = x; + hx = gf_u.word; + } + { + ieee_float_shape_type gf_u; + gf_u.value = y; + hy = gf_u.word; + } + ix = hx&0x7fffffff; + iy = hy&0x7fffffff; + + if ( ix > 0x7f800000 || iy > 0x7f800000 ) + return x+y; + if (x == y) return x; + if (ix == 0) + { + { + ieee_float_shape_type sf_u; + sf_u.word = (hy&0x80000000) | 1; + x = sf_u.value; + } + y = x*x; + if (y == x) return y; else return x; + } + if (hx >= 0) + { + if (hx > hy) + hx -= 1; + else + hx += 1; + } + else + { + if (hy >= 0 || hx > hy) + hx -= 1; + else + hx += 1; + } + hy = hx & 0x7f800000; + if (hy >= 0x7f800000) + return x+x; + if (hy < 0x00800000) + { + y = x OP x; + if (y != x) + { + ieee_float_shape_type sf_u; + sf_u.word = hx; + y = sf_u.value; + return y; + } + } + { + ieee_float_shape_type sf_u; + sf_u.word = hx; + x = sf_u.value; + } + return x; +} + + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980511-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980511-1.c new file mode 100755 index 0000000..f1bac0c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980511-1.c @@ -0,0 +1,20 @@ +typedef unsigned int __kernel_dev_t; +typedef __kernel_dev_t dev_t; +struct ustat { +}; +typedef unsigned int kdev_t; +static inline kdev_t to_kdev_t(int dev) +{ + int major, minor; + major = (dev >> 8); + minor = (dev & 0xff); + return ((( major ) << 22 ) | ( minor )) ; +} +struct super_block { +}; +struct super_block * get_super (kdev_t dev); +int sys_ustat(dev_t dev, struct ustat * ubuf) +{ + struct super_block *s; + s = get_super(to_kdev_t(dev)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980701-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980701-1.c new file mode 100755 index 0000000..82dd16d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980701-1.c @@ -0,0 +1,9 @@ + +short +func(void) +{ + unsigned char x, y; + + return y | x << 8; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980706-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980706-1.c new file mode 100755 index 0000000..214f36d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980706-1.c @@ -0,0 +1,10 @@ +void g(long long); + +long long f(long long v1, long long v2, long long v3, long long v4) +{ + g(v1); + g(v2); + g(v3); + g(v4); + return v1 && v2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980726-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980726-1.c new file mode 100755 index 0000000..3d4daa2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980726-1.c @@ -0,0 +1,10 @@ +static __inline__ unsigned char BCD(unsigned char binval) +{ + if (binval > 99) return 0x99; + return (((binval/10) << 4) | (binval%10)); +} + +void int1a(unsigned char i) +{ + (*((unsigned char *)1)) = BCD(i); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980729-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980729-1.c new file mode 100755 index 0000000..973372b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980729-1.c @@ -0,0 +1,14 @@ +static int +regex_compile () +{ + int c, c1; + char str[6 + 1]; + c1 = 0; + for (;;) + { + do { } while (0) ; + if (c1 == 6 ) + break; + str[c1++] = c; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980816-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980816-1.c new file mode 100755 index 0000000..c56b6c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980816-1.c @@ -0,0 +1,51 @@ +typedef unsigned int size_t; +typedef void *XtPointer; + +typedef struct _WidgetRec *Widget; +typedef struct _WidgetClassRec *WidgetClass; + +extern WidgetClass commandWidgetClass; + +typedef void (*XtCallbackProc)( + Widget , + XtPointer , + XtPointer +); + +extern const char XtStrings[]; + + +typedef struct +{ + char *Name, + *Label; + XtCallbackProc Callback; + XtPointer ClientData; + Widget W; +} DialogButtonType, *DialogButtonTypePtr; + + +Widget AddButtons(Widget Parent, Widget Top, + DialogButtonTypePtr Buttons, size_t Count) +{ + int i; + + for (i = 0; i < Count; i++) + { + if (!Buttons[i].Label) + continue; + Buttons[i].W = XtVaCreateManagedWidget(Buttons[i].Name, + commandWidgetClass, + Parent, + ((char*)&XtStrings[429]) , Buttons[i].Label, + "fromHoriz" , i ? Buttons[i-1].W : ((void *)0) , + "fromVert" , Top, + "resizable" , 1 , + ((void *)0) ); + + XtAddCallback(((char*)&XtStrings[136]), + Buttons[i].Callback, Buttons[i].ClientData); + } + return(Buttons[Count-1].W); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980821-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980821-1.c new file mode 100755 index 0000000..9eb1ac4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980821-1.c @@ -0,0 +1,15 @@ +typedef int __int32_t; +int __kernel_rem_pio2(int prec) +{ + __int32_t i, jz; + double fw, fq[20]; + switch(prec) { + case 2: + fw = 0.0; + case 3: + for (i=jz;i>0;i--) { + fw = fq[i-1] +fq[i]; + fq[i-1] = fw; + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/980825-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/980825-1.c new file mode 100755 index 0000000..34e35bf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/980825-1.c @@ -0,0 +1,30 @@ +typedef enum { FALSE, TRUE } boolean; +enum _errorTypes { FATAL = 1, WARNING = 2, PERROR = 4 }; +typedef struct _optionValues { + struct _include { + boolean classNames; + boolean defines; + boolean enumerators; + } include; +} optionValues; +extern optionValues Option; +static void applyTagInclusionList( list ) + const char *const list; +{ + boolean mode = TRUE; + const char *p; + for (p = list ; *p != '\0' ; ++p) + switch (*p) + { + case '=': + clearTagList(); + mode = TRUE; + break; + case '+': mode = TRUE; break; + case '-': mode = FALSE; break; + case 'c': Option.include.classNames = mode; break; + case 'd': Option.include.defines = mode; break; + case 'e': Option.include.enumerators = mode; break; + default: error(FATAL, "-i: Invalid tag option '%c'", *p); break; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981001-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981001-1.c new file mode 100755 index 0000000..d7cf0dc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981001-1.c @@ -0,0 +1,18 @@ +unsigned short code = 0x0000; +unsigned short low = 0x4000; +unsigned short high = 0xb000; + +int main (void) +{ + if ( + (high & 0x8000) != (low & 0x8000) + && ( low & 0x4000) == 0x4000 + && (high & 0x4000) == 0 + ) + { + code ^= 0x4000; + low |= 0x4000; + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981001-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/981001-2.c new file mode 100755 index 0000000..9ade1d9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981001-2.c @@ -0,0 +1,12 @@ +#define weak_alias(func, aliasname) \ + extern __typeof (func) aliasname __attribute__ ((weak, alias (#func))); + +#define add3(d, m, c) ((d) + (m) + (c)) + +int +__add3(int d, int m, int c) +{ + return d + m + c; +} + +weak_alias (__add3, add3) diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981001-3.c b/gcc_arm/testsuite/gcc.c-torture/compile/981001-3.c new file mode 100755 index 0000000..5f64587 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981001-3.c @@ -0,0 +1,14 @@ +#define P(a, b) P1(a,b) +#define P1(a,b) a##b + +#define FLT_MIN_EXP (-125) +#define DBL_MIN_EXP (-1021) + +#define MIN_EXP P(FLT,_MIN_EXP) + +#define FLT FLT +int f1 = MIN_EXP; + +#undef FLT +#define FLT DBL +int f2 = MIN_EXP; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981001-4.c b/gcc_arm/testsuite/gcc.c-torture/compile/981001-4.c new file mode 100755 index 0000000..dd3df9c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981001-4.c @@ -0,0 +1,14 @@ +#define P(a,b) P1(a,b) +#define P1(a,b) a##b + +#define ONCE(x, y) (x ?: (x = y())) +#define PREFIX + +extern int P(PREFIX, init) (void); + +int +fun(void) +{ + static int memo; + return ONCE(memo, P(PREFIX, init)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981007-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981007-1.c new file mode 100755 index 0000000..d41400b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981007-1.c @@ -0,0 +1,21 @@ +extern double fabs (double); +extern double sqrt (double); + +typedef struct complexm { + double re,im; +} complex; + +static complex +setCom (double r, double i) +{ + complex ct; + ct.re=fabs(r)<1E-300?0.0:r; + ct.im=fabs(i)<1E-300?0.0:i; + return ct; +} + +static complex +csqrt_crash (double x) +{ + return (x>=0) ? setCom(sqrt(x),0) : setCom(0,sqrt(-x)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.c new file mode 100755 index 0000000..6256673 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.c @@ -0,0 +1,9 @@ +/* This tests a combination of two gcc extensions. Omitting the middle + operand of ?: and using ?: as an lvalue. */ +int x, y; + +int main () +{ + (x ?: y) = 0; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.x b/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.x new file mode 100755 index 0000000..f41cdc2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981022-1.x @@ -0,0 +1,2 @@ +set torture_compile_xfail "*-*-*" +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981107-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981107-1.c new file mode 100755 index 0000000..987ec18 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981107-1.c @@ -0,0 +1,9 @@ +unsigned long seed(void) +{ + unsigned long u; + + call(); + + u = 26107 * (unsigned long)&u; + return u; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981211-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981211-1.c new file mode 100755 index 0000000..92c9cfb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981211-1.c @@ -0,0 +1,43 @@ +/* Basic tests of the #assert preprocessor extension. */ + +#define fail int fail + +#assert abc (def) +#assert abc (ghi) +#assert abc (jkl) +#assert space ( s p a c e ) + +/* Basic: */ +#if !#abc (def) || !#abc (ghi) || !#abc (jkl) +fail +#endif + +/* any answer for #abc */ +#if !#abc +fail +#endif + +/* internal whitespace is collapsed, + external whitespace is deleted */ +#if !#space (s p a c e) || !#space ( s p a c e ) || #space (space) +fail +#endif + +/* removing assertions */ +#unassert abc (jkl) +#if !#abc || !#abc (def) || !#abc (ghi) || #abc (jkl) +fail +#endif + +#unassert abc +#if #abc || #abc (def) || #abc (ghi) || #abc (jkl) +fail +#endif + +int gobble + +/* make sure it can succeed too. + also check space before open paren isn't significant */ +#if #space(s p a c e) +; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/981223-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/981223-1.c new file mode 100755 index 0000000..d207ff1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/981223-1.c @@ -0,0 +1,8 @@ +__complex__ float +func (__complex__ float x) +{ + if (__real__ x == 0.0) + return 1.0; + else + return 0.0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/990107-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/990107-1.c new file mode 100755 index 0000000..a123ce9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/990107-1.c @@ -0,0 +1,7 @@ +static int +java_double_finite (d) + double d; +{ + long long *ip = (long long *) &d; + return (*ip & 0x7ff0000000000000LL ) != 0x7ff0000000000000LL ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/compile/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/calls.c b/gcc_arm/testsuite/gcc.c-torture/compile/calls.c new file mode 100755 index 0000000..1582c0e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/calls.c @@ -0,0 +1,22 @@ +typedef void *(*T)(void); +f1 () +{ + ((T) 0)(); +} +f2 () +{ + ((T) 1000)(); +} +f3 () +{ + ((T) 10000000)(); +} +f4 (r) +{ + ((T) r)(); +} +f5 () +{ + int (*r)() = f3; + ((T) r)(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/cmpdi-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/cmpdi-1.c new file mode 100755 index 0000000..9e1b659 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/cmpdi-1.c @@ -0,0 +1,15 @@ +f (long long d) +{ + int i = 0; + if (d == 1) + i = 1; + return i; +} + +g (long long d) +{ + int i = 0; + if (d <= 0) + i = 1; + return i; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/combine-hang.c b/gcc_arm/testsuite/gcc.c-torture/compile/combine-hang.c new file mode 100755 index 0000000..7cc57af --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/combine-hang.c @@ -0,0 +1,26 @@ +typedef union +{ + double value; + struct + { + unsigned long msw; + unsigned long lsw; + } parts; +} ieee_double_shape_type; + +double f (int iy) +{ + double z, t; + ieee_double_shape_type u, v; + + if (iy == 1) + return 0; + + u.parts.msw = iy; + u.parts.lsw = 0; + z = u.value; + v.parts.msw = iy; + v.parts.lsw = 0; + t = v.value; + return 1.0+z+t+t; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/compile.exp b/gcc_arm/testsuite/gcc.c-torture/compile/compile.exp new file mode 100755 index 0000000..f96f023 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/compile.exp @@ -0,0 +1,35 @@ +# Expect driver script for GCC Regression Tests +# Copyright (C) 1993, 1995, 1997 Free Software Foundation +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +# These tests come from Torbjorn Granlund's (tege@cygnus.com) +# C torture test suite, and other contributors. + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +foreach testcase [glob -nocomplain $srcdir/$subdir/*.c] { + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $testcase] then { + continue + } + + c-torture $testcase +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/configure.in b/gcc_arm/testsuite/gcc.c-torture/compile/configure.in new file mode 100755 index 0000000..e4cc69d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=compile.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/funcptr-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/funcptr-1.c new file mode 100755 index 0000000..79687c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/funcptr-1.c @@ -0,0 +1,19 @@ +extern int (*gp)(const char*); + +int +g (const char* d) +{ + printf ("g"); + return 0; +} + +f () +{ + int errcnt=0; + + if (gp != g) + { + printf ("f"); + errcnt++; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/goto-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/goto-1.c new file mode 100755 index 0000000..caeed3a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/goto-1.c @@ -0,0 +1,16 @@ +f () +{ + do + { + if (0) + { + L1:; + } + else + goto L2; + L2:; + } + while (0); + + goto L1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/init-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/init-1.c new file mode 100755 index 0000000..38db9ad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/init-1.c @@ -0,0 +1,19 @@ +typedef struct +{ + char *key; + char *value; +} T1; + +typedef struct +{ + long type; + char *value; +} T3; + +T1 a[] = +{ + { + "", + ((char *)&((T3) {1, (char *) 1})) + } +}; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/init-2.c b/gcc_arm/testsuite/gcc.c-torture/compile/init-2.c new file mode 100755 index 0000000..63a7f58 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/init-2.c @@ -0,0 +1,4 @@ +struct +{ + int e1, e2; +} v = { e2: 0 }; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/labels-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/labels-1.c new file mode 100755 index 0000000..fae6ab8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/labels-1.c @@ -0,0 +1,13 @@ +#ifndef NO_LABEL_VALUES +f () +{ + void *x = &&L2; + if (&&L3 - &&L1 > 1) + abort(); + L1: return 1; + L2: abort (); + L3:; +} +#else +int x; +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/packed-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/packed-1.c new file mode 100755 index 0000000..709fc3c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/packed-1.c @@ -0,0 +1,14 @@ +struct s +{ + int e; +} x; + +struct rbuf +{ + struct s *p __attribute__ ((packed)); +} *b; + +f () +{ + b->p = &x; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/widechar-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/widechar-1.c new file mode 100755 index 0000000..5d89f33 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/widechar-1.c @@ -0,0 +1 @@ +char *s = L"a" "b"; diff --git a/gcc_arm/testsuite/gcc.c-torture/compile/zero-strct-1.c b/gcc_arm/testsuite/gcc.c-torture/compile/zero-strct-1.c new file mode 100755 index 0000000..d3db812 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/compile/zero-strct-1.c @@ -0,0 +1,7 @@ +typedef struct { } empty_t; + +f () +{ + empty_t i; + bar (i); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/900409-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/900409-1.c new file mode 100755 index 0000000..3112eff --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/900409-1.c @@ -0,0 +1,20 @@ +long f1(long a){return a&0xff000000L;} +long f2 (long a){return a&~0xff000000L;} +long f3(long a){return a&0x000000ffL;} +long f4(long a){return a&~0x000000ffL;} +long f5(long a){return a&0x0000ffffL;} +long f6(long a){return a&~0x0000ffffL;} + +main () +{ + long a = 0x89ABCDEF; + + if (f1(a)!=0x89000000L|| + f2(a)!=0x00ABCDEFL|| + f3(a)!=0x000000EFL|| + f4(a)!=0x89ABCD00L|| + f5(a)!=0x0000CDEFL|| + f6(a)!=0x89AB0000L) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920202-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920202-1.c new file mode 100755 index 0000000..e30ce2f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920202-1.c @@ -0,0 +1,18 @@ +static int rule_text_needs_stack_pop = 0; +static int input_stack_pos = 1; + +f (void) +{ + rule_text_needs_stack_pop = 1; + + if (input_stack_pos <= 0) + return 1; + else + return 0; +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920302-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920302-1.c new file mode 100755 index 0000000..5fbfd9d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920302-1.c @@ -0,0 +1,42 @@ +short optab[5]; +char buf[10]; +execute (ip) + register unsigned short *ip; +{ +#ifndef NO_LABEL_VALUES + register void *base = &&x; + char *bp = buf; + static void *tab[] = {&&x, &&y, &&z}; + if (ip == 0) + { + int i; + for (i = 0; i < 3; ++i) + optab[i] = (short)(tab[i] - base); + return; + } +x: *bp++='x'; + goto *(base + *ip++); +y: *bp++='y'; + goto *(base + *ip++); +z: *bp++='z'; + *bp=0; + return; +#else + strcpy (buf, "xyxyz"); +#endif +} + +short p[5]; + +main () +{ + execute (0); + p[0] = optab[1]; + p[1] = optab[0]; + p[2] = optab[1]; + p[3] = optab[2]; + execute (&p); + if (strcmp (buf, "xyxyz")) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920409-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920409-1.c new file mode 100755 index 0000000..938ce7d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920409-1.c @@ -0,0 +1 @@ +x(){signed char c=-1;return c<0;}main(){if(x()!=1)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920410-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920410-1.c new file mode 100755 index 0000000..f5180f0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920410-1.c @@ -0,0 +1,6 @@ +#define STACK_REQUIREMENT (40000 * 4 + 256) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else +main(){int d[40000];d[0]=0;exit(0);} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920411-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920411-1.c new file mode 100755 index 0000000..e3e9810 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920411-1.c @@ -0,0 +1,24 @@ +long f (w) + char *w; +{ + long k, i, c = 0, x; + char *p = (char*) &x; + for (i = 0; i < 1; i++) + { + for (k = 0; k < sizeof (long); k++) + p[k] = w[k]; + c += x; + } + return c; +} + +main () +{ + int i; + char a[sizeof (long)]; + + for (i = sizeof (long); --i >= 0;) a[i] = ' '; + if (f (a) != ~0UL / (unsigned char) ~0 * ' ') + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920415-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920415-1.c new file mode 100755 index 0000000..25100ad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920415-1.c @@ -0,0 +1,7 @@ +/* CYGNUS LOCAL -- meissner/no label values */ +#ifndef NO_LABEL_VALUES +main(){__label__ l;void*x(){return&&l;}goto*x();abort();return;l:exit(0);} +#else +main(){ exit (0); } +#endif +/* END CYGNUS LOCAL -- meissner/no label values */ diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920428-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920428-1.c new file mode 100755 index 0000000..154af76 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920428-1.c @@ -0,0 +1,2 @@ +x(const char*s){char a[1];const char*ss=s;a[*s++]|=1;return(int)ss+1==(int)s;} +main(){if(x("")!=1)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.c new file mode 100755 index 0000000..118ba96 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.c @@ -0,0 +1,7 @@ +#ifndef NO_LABEL_VALUES +s(i){if(i>0){__label__ l1;int f(int i){if(i==2)goto l1;return 0;}return f(i);l1:;}return 1;} +x(){return s(0)==1&&s(1)==0&&s(2)==1;} +main(){if(x()!=1)abort();exit(0);} +#else +main(){ exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.x b/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.x new file mode 100755 index 0000000..c7d9f03 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920428-2.x @@ -0,0 +1,6 @@ +# This doesn't work on sparc's with -mflat. + +if { [istarget "sparc-*-*"] && [string match "*mflat*" $CFLAGS] } { + set torture_execute_xfail "sparc-*-*" +} +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920429-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920429-1.c new file mode 100755 index 0000000..f37bf68 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920429-1.c @@ -0,0 +1,3 @@ +typedef unsigned char t;int i,j; +t*f(t*p){t c;c=*p++;i=((c&2)?1:0);j=(c&7)+1;return p;} +main(){t*p0="ab",*p1;p1=f(p0);if(p0+1!=p1)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-1.c new file mode 100755 index 0000000..6f757ca --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-1.c @@ -0,0 +1,3 @@ +int s[2]; +x(){if(!s[0]){s[1+s[1]]=s[1];return 1;}} +main(){s[0]=s[1]=0;if(x(0)!=1)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-2.c new file mode 100755 index 0000000..d99eef2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-2.c @@ -0,0 +1,114 @@ +unsigned long +gcd_ll (unsigned long long x, unsigned long long y) +{ + for (;;) + { + if (y == 0) + return (unsigned long) x; + x = x % y; + if (x == 0) + return (unsigned long) y; + y = y % x; + } +} + +unsigned long long +powmod_ll (unsigned long long b, unsigned e, unsigned long long m) +{ + unsigned t; + unsigned long long pow; + int i; + + if (e == 0) + return 1; + + /* Find the most significant bit in E. */ + t = e; + for (i = 0; t != 0; i++) + t >>= 1; + + /* The most sign bit in E is handled outside of the loop, by beginning + with B in POW, and decrementing I. */ + pow = b; + i -= 2; + + for (; i >= 0; i--) + { + pow = pow * pow % m; + if ((1 << i) & e) + pow = pow * b % m; + } + + return pow; +} + +unsigned long factab[10]; + +void +facts (t, a_int, x0, p) + unsigned long long t; + int a_int; + int x0; + unsigned p; +{ + unsigned long *xp = factab; + unsigned long long x, y; + unsigned long q = 1; + unsigned long long a = a_int; + int i; + unsigned long d; + int j = 1; + unsigned long tmp; + int jj = 0; + + x = x0; + y = x0; + + for (i = 1; i < 10000; i++) + { + x = powmod_ll (x, p, t) + a; + y = powmod_ll (y, p, t) + a; + y = powmod_ll (y, p, t) + a; + + if (x > y) + tmp = x - y; + else + tmp = y - x; + q = (unsigned long long) q * tmp % t; + + if (i == j) + { + jj += 1; + j += jj; + d = gcd_ll (q, t); + if (d != 1) + { + *xp++ = d; + t /= d; + if (t == 1) + { + return; + *xp = 0; + } + } + } + } +} + +main () +{ + unsigned long long t; + unsigned x0, a; + unsigned p; + + p = 27; + t = (1ULL << p) - 1; + + a = -1; + x0 = 3; + + facts (t, a, x0, p); + if (factab[0] != 7 || factab[1] != 73 || factab[2] != 262657) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-3.c new file mode 100755 index 0000000..1031d73 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-3.c @@ -0,0 +1,35 @@ +int tab[9]; +execute(oip, ip) + unsigned short *oip, *ip; +{ +#ifndef NO_LABEL_VALUES + int x = 0; + int *xp = tab; +base: + x++; + if (x == 4) + { + *xp = 0; + return; + } + *xp++ = ip - oip; + goto *(&&base + *ip++); +#else + tab[0] = 0; + tab[1] = 1; + tab[2] = 2; + tab[3] = 0; +#endif +} + +main() +{ + unsigned short ip[10]; + int i; + for (i = 0; i < 10; i++) + ip[i] = 0; + execute(ip, ip); + if (tab[0] != 0 || tab[1] != 1 || tab[2] != 2 || tab[3] != 0) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-4.c new file mode 100755 index 0000000..3524dd5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-4.c @@ -0,0 +1,27 @@ +#ifndef NO_LABEL_VALUES +int +x (int i) +{ + static const void *j[] = {&& x, && y, && z}; + + goto *j[i]; + + x: return 2; + y: return 3; + z: return 5; +} + +int +main (void) +{ + if ( x (0) != 2 + || x (1) != 3 + || x (2) != 5) + abort (); + + exit (0); +} +#else +int +main (void) { exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-5.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-5.c new file mode 100755 index 0000000..0974074 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-5.c @@ -0,0 +1,19 @@ +#ifndef NO_LABEL_VALUES +x (int i) +{ + void *j[] = {&&x, &&y, &&z}; + goto *j[i]; + x:return 2; + y:return 3; + z:return 5; + +} +main () +{ + if (x (0) != 2 || x (1) != 3 | x (2) != 5) + abort(); + exit(0); +} +#else +main(){ exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-6.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-6.c new file mode 100755 index 0000000..833624f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-6.c @@ -0,0 +1,91 @@ +#include <stdio.h> + +/* Convert a decimal string to a long long unsigned. No error check is + performed. */ + +long long unsigned +str2llu (str) + char *str; +{ + long long unsigned acc; + int d; + acc = *str++ - '0'; + for (;;) + { + d = *str++; + if (d == '\0') + break; + d -= '0'; + acc = acc * 10 + d; + } + + return acc; +} + +/* isqrt(t) - computes the square root of t. (tege 86-10-27) */ + +long unsigned +sqrtllu (long long unsigned t) +{ + long long unsigned s; + long long unsigned b; + + for (b = 0, s = t; b++, (s >>= 1) != 0; ) + ; + + s = 1LL << (b >> 1); + + if (b & 1) + s += s >> 1; + + do + { + b = t / s; + s = (s + b) >> 1; + } + while (b < s); + + return s; +} + + +int plist (p0, p1, tab) + long long unsigned p0, p1; + long long unsigned *tab; +{ + long long unsigned p; + long unsigned d; + long unsigned s; + long long unsigned *xp = tab; + + for (p = p0; p <= p1; p += 2) + { + s = sqrtllu (p); + + for (d = 3; d <= s; d += 2) + { + long long unsigned q = p % d; + if (q == 0) + goto not_prime; + } + + *xp++ = p; + not_prime:; + } + *xp = 0; + return xp - tab; +} + +main (argc, argv) + int argc; + char *argv[]; +{ + long long tab[10]; + int nprimes; + nprimes = plist (str2llu ("1234111111"), str2llu ("1234111127"), tab); + + if(tab[0]!=1234111117LL||tab[1]!=1234111121LL||tab[2]!=1234111127LL||tab[3]!=0) + abort(); + + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.c new file mode 100755 index 0000000..f032bd8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.c @@ -0,0 +1,34 @@ +/* CYGNUS LOCAL -- meissner/no label values */ +#ifdef STACK_SIZE +#define DEPTH ((STACK_SIZE) / 512 + 1) +#else +#define DEPTH 1000 +#endif + +#ifndef NO_LABEL_VALUES +x(a) +{ + __label__ xlab; + void y(a) + { + if (a==0) + goto xlab; + y (a-1); + } + y (a); + xlab:; + return a; +} +#endif + +main () +{ +#ifndef __I960__ +#ifndef NO_LABEL_VALUES + if (x (DEPTH) != DEPTH) + abort (); +#endif +#endif + exit (0); +} +/* END CYGNUS LOCAL -- meissner/no label values */ diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.x b/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.x new file mode 100755 index 0000000..c7d9f03 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-7.x @@ -0,0 +1,6 @@ +# This doesn't work on sparc's with -mflat. + +if { [istarget "sparc-*-*"] && [string match "*mflat*" $CFLAGS] } { + set torture_execute_xfail "sparc-*-*" +} +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-8.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-8.c new file mode 100755 index 0000000..62780a0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-8.c @@ -0,0 +1,38 @@ +#include <stdio.h> +#include <stdarg.h> + +char buf[50]; +int +va (int a, double b, int c, ...) +{ + va_list ap; + int d, e, f, g, h, i, j, k, l, m, n, o, p; + va_start (ap, c); + + d = va_arg (ap, int); + e = va_arg (ap, int); + f = va_arg (ap, int); + g = va_arg (ap, int); + h = va_arg (ap, int); + i = va_arg (ap, int); + j = va_arg (ap, int); + k = va_arg (ap, int); + l = va_arg (ap, int); + m = va_arg (ap, int); + n = va_arg (ap, int); + o = va_arg (ap, int); + p = va_arg (ap, int); + + sprintf (buf, + "%d,%f,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", + a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); + va_end (ap); +} + +main() +{ + 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)) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920501-9.c b/gcc_arm/testsuite/gcc.c-torture/execute/920501-9.c new file mode 100755 index 0000000..f585ac6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920501-9.c @@ -0,0 +1,27 @@ +#include <stdio.h> + +long long proc1(){return 1LL;} +long long proc2(){return 0x12345678LL;} +long long proc3(){return 0xaabbccdd12345678LL;} +long long proc4(){return -1LL;} +long long proc5(){return 0xaabbccddLL;} + +print_longlong(x,buf) + long long x; + char *buf; +{ + unsigned long l; + l= (x >> 32) & 0xffffffff; + if (l != 0) + sprintf(buf,"%lx%08.lx",l,((unsigned long)x & 0xffffffff)); + else + sprintf(buf,"%lx",((unsigned long)x & 0xffffffff)); +} + +main(){char buf[100]; +print_longlong(proc1(),buf);if(strcmp("1",buf))abort(); +print_longlong(proc2(),buf);if(strcmp("12345678",buf))abort(); +print_longlong(proc3(),buf);if(strcmp("aabbccdd12345678",buf))abort(); +print_longlong(proc4(),buf);if(strcmp("ffffffffffffffff",buf))abort(); +print_longlong(proc5(),buf);if(strcmp("aabbccdd",buf))abort(); +exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920506-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920506-1.c new file mode 100755 index 0000000..9a646a3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920506-1.c @@ -0,0 +1,2 @@ +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();} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920520-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920520-1.c new file mode 100755 index 0000000..068a12e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920520-1.c @@ -0,0 +1,36 @@ +foo(int *bar) +{ + *bar = 8; +} + +bugger() +{ + int oldDepth, newDepth; + + foo(&oldDepth); + + switch (oldDepth) + { + case 8: + case 500: + newDepth = 8; + break; + + case 5000: + newDepth = 500; + break; + + default: + newDepth = 17; + break; + } + + return newDepth - oldDepth; +} + +main() +{ + if (bugger() != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920603-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920603-1.c new file mode 100755 index 0000000..bd27ca6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920603-1.c @@ -0,0 +1,2 @@ +f(got){if(got!=0xffff)abort();} +main(){signed char c=-1;unsigned u=(unsigned short)c;f(u);exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920604-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920604-1.c new file mode 100755 index 0000000..d7d9be1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920604-1.c @@ -0,0 +1,13 @@ +long long +mod (a, b) + long long a, b; +{ + return a % b; +} + +int +main () +{ + mod (1LL, 2LL); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920612-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920612-1.c new file mode 100755 index 0000000..a70c0d2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920612-1.c @@ -0,0 +1,2 @@ +f(j)int j;{return++j>0;} +main(){if(f((~0U)>>1))abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920612-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/920612-2.c new file mode 100755 index 0000000..2667093 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920612-2.c @@ -0,0 +1,12 @@ +main () +{ + int i = 0; + int a (int x) + { + while (x) + i++, x--; + return x; + } + a (2); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920618-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920618-1.c new file mode 100755 index 0000000..224f720 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920618-1.c @@ -0,0 +1 @@ +main(){if(1.17549435e-38F<=1.1)exit(0);abort();} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920625-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920625-1.c new file mode 100755 index 0000000..ae2f415 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920625-1.c @@ -0,0 +1,38 @@ +#include <stdarg.h> + +typedef struct{double x,y;}point; +point pts[]={{1.0,2.0},{3.0,4.0},{5.0,6.0},{7.0,8.0}}; +static int va1(int nargs,...) +{ + va_list args; + int i; + point pi; + va_start(args,nargs); + for(i=0;i<nargs;i++){ + pi=va_arg(args,point); + if(pts[i].x!=pi.x||pts[i].y!=pi.y)abort(); + } + va_end(args); +} + +typedef struct{int x,y;}ipoint; +ipoint ipts[]={{1,2},{3,4},{5,6},{7,8}}; +static int va2(int nargs,...) +{ + va_list args; + int i; + ipoint pi; + va_start(args,nargs); + for(i=0;i<nargs;i++){ + pi=va_arg(args,ipoint); + if(ipts[i].x!=pi.x||ipts[i].y!=pi.y)abort(); + } + va_end(args); +} + +main() +{ +va1(4,pts[0],pts[1],pts[2],pts[3]); +va2(4,ipts[0],ipts[1],ipts[2],ipts[3]); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920710-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920710-1.c new file mode 100755 index 0000000..7c6f871 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920710-1.c @@ -0,0 +1,11 @@ +main() +{ + if ((double) 18446744073709551615ULL < 1.84467440737095e+19 || + (double) 18446744073709551615ULL > 1.84467440737096e+19) + abort(); + + if (16777217L != (float)16777217e0) + abort(); + + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920711-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920711-1.c new file mode 100755 index 0000000..aa83452 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920711-1.c @@ -0,0 +1,2 @@ +f(long a){return (--a > 0);} +main(){if(f(0x80000000L)==0)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.c new file mode 100755 index 0000000..8b0f54b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.c @@ -0,0 +1,67 @@ +double ran(int *idum); +main () +{ + double vp = 0.0048; + double vx; + double vy; + double vz; + + /* CYGNUS LOCAL -- meissner/32bit doubles */ + /* This test requires double precision, so for hosts that don't offer + that much precision, just ignore this test. */ + if (sizeof (double) < 8) + exit (0); + /* END CYGNUS LOCAL -- meissner/32bit doubles */ + + maxbol(vp, &vx , &vy , &vz ); + if (vx < 0.001316505673 || vx > 0.001316505674) + abort(); + if (vy < 0.002731492112 || vy > 0.002731492113) + abort(); + if (vz < 0.001561454099 || vz > 0.001561454100) + abort(); + exit(0); +} +maxbol(double vp , double *vx , double *vy , double *vz) +{ + int idum=0; + int i; + double temp; + + *vx=vp*ran( &idum ); + *vy=vp*ran( &idum ); + *vz=vp*ran( &idum ); +} + +double ran(int *idum) +{ + static long ix1,ix2,ix3; + static double r[97]; + double temp; + static int iff=0; + int j; + + if(*idum<0 || iff==0){ + iff=1; + ix1=(54773-(*idum))%259200; + ix1=(7141*ix1+54773)%259200; + ix2=ix1 %134456; + ix1=(7141*ix1+54773)%259200; + ix3=ix1 %243000; + for(j=0; j<97; j++){ + ix1=(7141*ix1+54773)%259200; + ix2=(8121*ix2+28411)%134456; + r[j]=(ix1+ix2*(1.0/134456))*(1.0/259200); + } + *idum=1; + } + ix1=(7141*ix1+54773)%259200; + ix2=(8121*ix2+28411)%134456; + ix3=(4561*ix3+51349)%243000; + j=((97*ix3)/243000); + if(j >= 97 && j < 0) + abort(); + temp=r[j]; + r[j]=(ix1+ix2*(1.0/134456))*(1.0/259200); + return temp; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.x new file mode 100755 index 0000000..e6ecdff --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920715-1.x @@ -0,0 +1,7 @@ +# It doesn't work on d10v if doubles are not 64 bits + +if { [istarget "d10v-*-*"] && ! [string-match "*-mdouble64*" $CFLAGS] } { + set torture_execute_xfail "d10v-*-*" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920721-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920721-1.c new file mode 100755 index 0000000..086b546 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920721-1.c @@ -0,0 +1,2 @@ +long f(short a,short b){return (long)a/b;} +main(){if(f(-32768,-1)!=32768L)abort();else exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920721-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/920721-2.c new file mode 100755 index 0000000..ed4e0bf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920721-2.c @@ -0,0 +1,2 @@ +f(){} +main(){int n=2;double x[n];f();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920721-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/920721-3.c new file mode 100755 index 0000000..61f605d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920721-3.c @@ -0,0 +1,26 @@ +static inline fu (unsigned short data) +{ + return data; +} +ru(i) +{ + if(fu(i++)!=5)abort(); + if(fu(++i)!=7)abort(); +} +static inline fs (signed short data) +{ + return data; +} +rs(i) +{ + if(fs(i++)!=5)abort(); + if(fs(++i)!=7)abort(); +} + + +main() +{ + ru(5); + rs(5); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920721-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/920721-4.c new file mode 100755 index 0000000..3cccc5b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920721-4.c @@ -0,0 +1,60 @@ +#ifndef NO_LABEL_VALUES +int try (int num) { + __label__ lab1, lab2, lab3, lab4, lab5, lab6, default_lab; + + void *do_switch (int num) { + switch(num) { + case 1: + return &&lab1; + case 2: + return &&lab2; + case 3: + return &&lab3; + case 4: + return &&lab4; + case 5: + return &&lab5; + case 6: + return &&lab6; + default: + return &&default_lab; + } + } + + goto *do_switch (num); + + lab1: + return 1; + + lab2: + return 2; + + lab3: + return 3; + + lab4: + return 4; + + lab5: + return 5; + + lab6: + return 6; + + default_lab: + return -1; +} + +main() +{ + int i; + for (i = 1; i <= 6; i++) + { + if (try (i) != i) + abort(); + } + exit(0); +} +#else +main(){ exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920726-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920726-1.c new file mode 100755 index 0000000..d6042c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920726-1.c @@ -0,0 +1,63 @@ +#include <stdio.h> +#include <stdarg.h> + +struct spurious +{ + int anumber; +}; + +int first(char *buf, char *fmt, ...) +{ + int pos, number; + va_list args; + int dummy; + char *bp = buf; + + va_start(args, fmt); + for (pos = 0; fmt[pos]; pos++) + if (fmt[pos] == 'i') + { + number = va_arg(args, int); + sprintf(bp, "%d", number); + bp += strlen(bp); + } + else + *bp++ = fmt[pos]; + + va_end(args); + *bp = 0; + return dummy; +} + +struct spurious second(char *buf,char *fmt, ...) +{ + int pos, number; + va_list args; + struct spurious dummy; + char *bp = buf; + + va_start(args, fmt); + for (pos = 0; fmt[pos]; pos++) + if (fmt[pos] == 'i') + { + number = va_arg(args, int); + sprintf(bp, "%d", number); + bp += strlen(bp); + } + else + *bp++ = fmt[pos]; + + va_end(args); + *bp = 0; + return dummy; +} + +main() +{ + 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)) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920728-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920728-1.c new file mode 100755 index 0000000..7a2968b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920728-1.c @@ -0,0 +1,24 @@ +typedef struct {int dims[0]; } *A; + +f(unsigned long obj) +{ + unsigned char y = obj >> 24; + y &= ~4; + + if ((y==0)||(y!=251 )) + abort(); + + if(((int)obj&7)!=7)return; + + REST_OF_CODE_JUST_HERE_TO_TRIGGER_THE_BUG: + + { + unsigned char t = obj >> 24; + if (!(t==0)&&(t<=0x03)) + return 0; + return ((A)(obj&0x00FFFFFFL))->dims[1]; + } +} + +long g(){return 0xff000000L;} +main (){int x;f(g());exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920731-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920731-1.c new file mode 100755 index 0000000..de0fb58 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920731-1.c @@ -0,0 +1,2 @@ +f(x){int i;for(i=0;i<8&&(x&1)==0;x>>=1,i++);return i;} +main(){if(f(4)!=2)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920810-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920810-1.c new file mode 100755 index 0000000..9565bfc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920810-1.c @@ -0,0 +1,23 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +typedef struct{void*super;int name;int size;}t; +t*f(t*clas,int size) +{ + t*child=(t*)malloc(size); + memcpy(child,clas,clas->size); + child->super=clas; + child->name=0; + child->size=size; + return child; +} +main() +{ + t foo,*bar; + memset(&foo,37,sizeof(t)); + foo.size=sizeof(t); + bar=f(&foo,sizeof(t)); + if(bar->super!=&foo||bar->name!=0||bar->size!=sizeof(t))abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920812-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920812-1.c new file mode 100755 index 0000000..b49ab42 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920812-1.c @@ -0,0 +1,3 @@ +typedef int t; +f(t y){switch(y){case 1:return 1;}return 0;} +main(){if(f((t)1)!=1)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920829-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920829-1.c new file mode 100755 index 0000000..ed2c227 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920829-1.c @@ -0,0 +1,2 @@ +long long c=2863311530LL,c3=2863311530LL*3; +main(){if(c*3!=c3)abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920908-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920908-1.c new file mode 100755 index 0000000..98fbb5e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920908-1.c @@ -0,0 +1,28 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:mips OPTIONS: */ + +#include <stdarg.h> + +typedef struct{int A;}T; + +T f(int x,...) +{ +va_list ap; +T X; +va_start(ap,x); +X=va_arg(ap,T); +if(X.A!=10)abort(); +X=va_arg(ap,T); +if(X.A!=20)abort(); +va_end(ap); +return X; +} + +main() +{ +T X,Y; +int i; +X.A=10; +Y.A=20; +f(2,X,Y); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920908-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/920908-2.c new file mode 100755 index 0000000..66a6d86 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920908-2.c @@ -0,0 +1,23 @@ +/* +CONF:m68k-sun-sunos4.1.1 +OPTIONS:-O +*/ +struct T +{ +unsigned i:8; +unsigned c:24; +}; +f(struct T t) +{ +struct T s[1]; +s[0]=t; +return(char)s->c; +} +main() +{ +struct T t; +t.i=0xff; +t.c=0xffff11; +if(f(t)!=0x11)abort(); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920909-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920909-1.c new file mode 100755 index 0000000..c888034 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920909-1.c @@ -0,0 +1,2 @@ +f(a){switch(a){case 0x402:return a+1;case 0x403:return a+2;case 0x404:return a+3;case 0x405:return a+4;case 0x406:return 1;case 0x407:return 4;}return 0;} +main(){if(f(1))abort();exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920922-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920922-1.c new file mode 100755 index 0000000..4fae192 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920922-1.c @@ -0,0 +1,14 @@ +unsigned long* +f(p)unsigned long*p; +{ + unsigned long a = (*p++) >> 24; + return p + a; +} + +main () +{ + unsigned long x = 0x80000000UL; + if (f(&x) != &x + 0x81) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/920929-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/920929-1.c new file mode 100755 index 0000000..e43444e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/920929-1.c @@ -0,0 +1,13 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:sparc OPTIONS: */ +f(int n) +{ +int i; +double v[n]; +for(i=0;i<n;i++) +v[i]=0; +} +main() +{ +f(100); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921006-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921006-1.c new file mode 100755 index 0000000..50fbdb7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921006-1.c @@ -0,0 +1,6 @@ +/* REPRODUCED:RUN:SIGNAL MACHINE:i386 OPTIONS:-O */ +main() +{ +if(strcmp("X","")<0)abort(); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921007-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921007-1.c new file mode 100755 index 0000000..23ab52e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921007-1.c @@ -0,0 +1,7 @@ +static int strcmp(){return-1;} +#define strcmp __builtin_strcmp +main() +{ +if(strcmp("X","X\376")>=0)abort(); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921013-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921013-1.c new file mode 100755 index 0000000..d041beb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921013-1.c @@ -0,0 +1,20 @@ +f(d,x,y,n) +int*d; +float*x,*y; +int n; +{ + while(n--){*d++=*x++==*y++;} +} + +main() +{ + int r[4]; + float a[]={5,1,3,5}; + float b[]={2,4,3,0}; + int i; + f(r,a,b,4); + for(i=0;i<4;i++) + if((a[i]==b[i])!=r[i]) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921016-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921016-1.c new file mode 100755 index 0000000..46f8a83 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921016-1.c @@ -0,0 +1,10 @@ +main() +{ +int j=1081; +struct +{ +signed int m:11; +}l; +if((l.m=j)==j)abort(); +exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921017-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921017-1.c new file mode 100755 index 0000000..3a0db5c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921017-1.c @@ -0,0 +1,15 @@ +f(n) +{ + int a[n]; + int g(i) + { + return a[i]; + } + a[1]=4711; + return g(1); +} +main() +{ + if(f(2)!=4711)abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921019-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921019-1.c new file mode 100755 index 0000000..f48613a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921019-1.c @@ -0,0 +1,8 @@ +void *foo[]={(void *)&("X"[0])}; + +main () +{ + if (((char*)foo[0])[0] != 'X') + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921019-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/921019-2.c new file mode 100755 index 0000000..9003e7b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921019-2.c @@ -0,0 +1,8 @@ +main() +{ + double x,y=0.5; + x=y/0.2; + if(x!=x) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921029-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921029-1.c new file mode 100755 index 0000000..76fc974 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921029-1.c @@ -0,0 +1,42 @@ +typedef unsigned long long ULL; +ULL back; +ULL hpart, lpart; +ULL +build(long h, long l) +{ + hpart = h; + hpart <<= 32; + lpart = l; + lpart &= 0xFFFFFFFFLL; + back = hpart | lpart; + return back; +} + +main() +{ + if (build(0, 1) != 0x0000000000000001LL) + abort(); + if (build(0, 0) != 0x0000000000000000LL) + abort(); + if (build(0, 0xFFFFFFFF) != 0x00000000FFFFFFFFLL) + abort(); + if (build(0, 0xFFFFFFFE) != 0x00000000FFFFFFFELL) + abort(); + if (build(1, 1) != 0x0000000100000001LL) + abort(); + if (build(1, 0) != 0x0000000100000000LL) + abort(); + if (build(1, 0xFFFFFFFF) != 0x00000001FFFFFFFFLL) + abort(); + if (build(1, 0xFFFFFFFE) != 0x00000001FFFFFFFELL) + abort(); + if (build(0xFFFFFFFF, 1) != 0xFFFFFFFF00000001LL) + abort(); + if (build(0xFFFFFFFF, 0) != 0xFFFFFFFF00000000LL) + abort(); + if (build(0xFFFFFFFF, 0xFFFFFFFF) != 0xFFFFFFFFFFFFFFFFLL) + abort(); + if (build(0xFFFFFFFF, 0xFFFFFFFE) != 0xFFFFFFFFFFFFFFFELL) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921104-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921104-1.c new file mode 100755 index 0000000..4b6f4bc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921104-1.c @@ -0,0 +1,8 @@ +main () +{ + unsigned long val = 1; + + if (val > (unsigned long) ~0) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921110-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921110-1.c new file mode 100755 index 0000000..27ff96f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921110-1.c @@ -0,0 +1,7 @@ +extern int abort(); +typedef int (*frob)(); +frob f[] = {abort}; +main() +{ + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921112-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921112-1.c new file mode 100755 index 0000000..5946398 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921112-1.c @@ -0,0 +1,21 @@ +union u { + struct { int i1, i2; } t; + double d; +} x[2], v; + +f (x, v) + union u *x, v; +{ + *++x = v; +} + +main() +{ + x[1].t.i1 = x[1].t.i2 = 0; + v.t.i1 = 1; + v.t.i2 = 2; + f (x, v); + if (x[1].t.i1 != 1 || x[1].t.i2 != 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921113-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921113-1.c new file mode 100755 index 0000000..78972bc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921113-1.c @@ -0,0 +1,63 @@ +#define STACK_REQUIREMENT (128 * 128 * 4 + 1024) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else + +typedef struct { + float wsx; +} struct_list; + +typedef struct_list *list_t; + +typedef struct { + float x, y; +} vector_t; + +w(float x, float y) {} + +f1(float x, float y) +{ + if (x != 0 || y != 0) + abort(); +} +f2(float x, float y) +{ + if (x != 1 || y != 1) + abort(); +} + +gitter(int count, vector_t pos[], list_t list, int *nww, vector_t limit[2], float r) +{ + float d; + int gitt[128][128]; + + f1(limit[0].x, limit[0].y); + f2(limit[1].x, limit[1].y); + + *nww = 0; + + d = pos[0].x; + if (d <= 0.) + { + w(d, r); + if (d <= r * 0.5) + { + w(d, r); + list[0].wsx = 1; + } + } +} + +vector_t pos[1] = {{0., 0.}}; +vector_t limit[2] = {{0.,0.},{1.,1.}}; + +main() +{ + int nww; + struct_list list; + + gitter(1, pos, &list, &nww, limit, 1.); + exit(0); +} + +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921117-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921117-1.c new file mode 100755 index 0000000..2ed30fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921117-1.c @@ -0,0 +1,22 @@ +struct s { + char text[11]; + int flag; +} cell; + +int +check (struct s p) +{ + if (p.flag != 99) + return 1; + return strcmp (p.text, "0123456789"); +} + +main () +{ + cell.flag = 99; + strcpy (cell.text, "0123456789"); + + if (check (cell)) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921123-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921123-1.c new file mode 100755 index 0000000..d3daf12 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921123-1.c @@ -0,0 +1,13 @@ +f(short *p) +{ + short x = *p; + return (--x < 0); +} + +main() +{ + short x = -10; + if (!f(&x)) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921123-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/921123-2.c new file mode 100755 index 0000000..3028717 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921123-2.c @@ -0,0 +1,24 @@ +typedef struct +{ + unsigned short b0, b1, b2, b3; +} four_quarters; + +four_quarters x; +int a, b; + +void f (four_quarters j) +{ + b = j.b2; + a = j.b3; +} + +main () +{ + four_quarters x; + x.b0 = x.b1 = x.b2 = 0; + x.b3 = 38; + f(x); + if (a != 38) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921124-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921124-1.c new file mode 100755 index 0000000..51b090b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921124-1.c @@ -0,0 +1,19 @@ +f(x, d1, d2, d3) + double d1, d2, d3; +{ + return x; +} + +g(b,s,x,y,i,j) + char *b,*s; + double x,y; +{ + if (x != 1.0 || y != 2.0 || i != 3 || j != 4) + abort(); +} + +main() +{ + g("","", 1.0, 2.0, f(3, 0.0, 0.0, 0.0), f(4, 0.0, 0.0, 0.0)); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921202-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921202-1.c new file mode 100755 index 0000000..d42fc74 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921202-1.c @@ -0,0 +1,36 @@ +main () +{ + long dx[2055]; + long dy[2055]; + long s1[2055]; + int cyx, cyy; + int i; + long size; + + for (;;) + { + size = 2055; + mpn_random2 (s1, size); + + for (i = 0; i < 1; i++) + ; + + dy[size] = 0x12345678; + + for (i = 0; i < 1; i++) + cyy = mpn_mul_1 (dy, s1, size); + + if (cyx != cyy || mpn_cmp (dx, dy, size + 1) != 0 || dx[size] != 0x12345678) + { + foo ("", 8, cyy); mpn_print (dy, size); + } + exxit(); + } +} + +foo (){} +mpn_mul_1(){} +mpn_print (){} +mpn_random2(){} +mpn_cmp(){} +exxit(){exit(0);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921202-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/921202-2.c new file mode 100755 index 0000000..48d4a41 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921202-2.c @@ -0,0 +1,13 @@ +int +f(long long x) +{ + x >>= 8; + return x & 0xff; +} + +main() +{ + if (f(0x0123456789ABCDEFLL) != 0xCD) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921204-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921204-1.c new file mode 100755 index 0000000..9e4f4a6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921204-1.c @@ -0,0 +1,36 @@ +typedef struct { + unsigned b0:1, f1:17, b18:1, b19:1, b20:1, f2:11; +} bf; + +typedef union { + bf b; + unsigned w; +} bu; + +bu +f(bu i) +{ + bu o = i; + + if (o.b.b0) + o.b.b18 = 1, + o.b.b20 = 1; + else + o.b.b18 = 0, + o.b.b20 = 0; + + return o; +} + +main() +{ + bu a; + bu r; + + a.w = 0x4000000; + a.b.b0 = 0; + r = f(a); + if (a.w != r.w) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921207-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921207-1.c new file mode 100755 index 0000000..5ee9d27 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921207-1.c @@ -0,0 +1,15 @@ +f() +{ + unsigned b = 0; + + if (b > ~0U) + b = ~0U; + + return b; +} +main() +{ + if (f()!=0) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921208-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921208-1.c new file mode 100755 index 0000000..143ef63 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921208-1.c @@ -0,0 +1,18 @@ +double +f(double x) +{ + return x*x; +} + +double +Int(double (*f)(double), double a) +{ + return (*f)(a); +} + +main() +{ + if (Int(&f,2.0) != 4.0) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921208-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/921208-2.c new file mode 100755 index 0000000..d5edcf9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921208-2.c @@ -0,0 +1,26 @@ +#define STACK_REQUIREMENT (100000 * 4 + 1024) +#if defined (STACK_SIZE) && STACK_SIZE < STACK_REQUIREMENT +main () { exit (0); } +#else + +g(){} + +f() +{ + int i; + float a[100000]; + + for (i = 0; i < 1; i++) + { + g(1.0, 1.0 + i / 2.0 * 3.0); + g(2.0, 1.0 + i / 2.0 * 3.0); + } +} + +main () +{ + f(); + exit(0); +} + +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921215-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921215-1.c new file mode 100755 index 0000000..4fa3b7d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921215-1.c @@ -0,0 +1,24 @@ +main() +{ +#ifndef NO_TRAMPOLINES + void p(void ((*f) (void ()))) + { + void r() + { + foo (); + } + + f(r); + } + + void q(void ((*f)())) + { + f(); + } + + p(q); +#endif + exit(0); +} + +foo(){} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921218-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/921218-1.c new file mode 100755 index 0000000..ab7bc19 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921218-1.c @@ -0,0 +1,11 @@ +f() +{ + return (unsigned char)("\377"[0]); +} + +main() +{ + if (f() != (unsigned char)(0377)) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/921218-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/921218-2.c new file mode 100755 index 0000000..b5d57e9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/921218-2.c @@ -0,0 +1,17 @@ +f() +{ + long l2; + unsigned short us; + unsigned long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} + +main() +{ + if (f()!=(unsigned short)-1) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930106-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930106-1.c new file mode 100755 index 0000000..8081f92 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930106-1.c @@ -0,0 +1,27 @@ +#if defined (STACK_SIZE) +#define DUMMY_SIZE 9 +#else +#define DUMMY_SIZE 399999 +#endif + +double g() +{ + return 1.0; +} + +f() +{ + char dummy[DUMMY_SIZE]; + double f1, f2, f3; + f1 = g(); + f2 = g(); + f3 = g(); + return f1 + f2 + f3; +} + +main() +{ + if (f() != 3.0) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930111-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930111-1.c new file mode 100755 index 0000000..e908f14 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930111-1.c @@ -0,0 +1,22 @@ +main() +{ + if (wwrite((long long) 0) != 123) + abort(); + exit(0); +} + +int +wwrite(long long i) +{ + switch(i) + { + case 3: + case 10: + case 23: + case 28: + case 47: + return 0; + default: + return 123; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930123-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930123-1.c new file mode 100755 index 0000000..7365bae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930123-1.c @@ -0,0 +1,16 @@ +f(int *x) +{ + *x = 0; +} + +main() +{ + int s, c, x; + char a[] = "c"; + + f(&s); + a[c = 0] = s == 0 ? (x=1, 'a') : (x=2, 'b'); + if (a[c] != 'a') + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930126-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930126-1.c new file mode 100755 index 0000000..ff08e7d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930126-1.c @@ -0,0 +1,20 @@ +struct s { + unsigned long long a:8, b:32; +}; + +struct s +f(struct s x) +{ + x.b = 0xcdef1234; + return x; +} + +main() +{ + static struct s i; + i.a = 12; + i = f(i); + if (i.a != 12 || i.b != 0xcdef1234) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930208-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930208-1.c new file mode 100755 index 0000000..464b69d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930208-1.c @@ -0,0 +1,23 @@ +typedef union { + long l; + struct { char b3, b2, b1, b0; } c; +} T; + +f (T u) +{ + ++u.c.b0; + ++u.c.b3; + return (u.c.b1 != 2 || u.c.b2 != 2); +} + +main () +{ + T u; + u.c.b1 = 2; + u.c.b2 = 2; + u.c.b0 = ~0; + u.c.b3 = ~0; + if (f (u)) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930406-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930406-1.c new file mode 100755 index 0000000..1546f51 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930406-1.c @@ -0,0 +1,19 @@ +f() +{ + int x = 1; + char big[0x1000]; + + ({ + __label__ mylabel; + mylabel: + x++; + if (x != 3) + goto mylabel; + }); + exit(0); +} + +main() +{ + f(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930408-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930408-1.c new file mode 100755 index 0000000..42ffc09 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930408-1.c @@ -0,0 +1,27 @@ +typedef enum foo E; +enum foo { e0, e1 }; + +struct { + E eval; +} s; + +p() +{ + abort(); +} + +f() +{ + switch (s.eval) + { + case e0: + p(); + } +} + +main() +{ + s.eval = e1; + f(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930429-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930429-1.c new file mode 100755 index 0000000..656d928 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930429-1.c @@ -0,0 +1,14 @@ +char * +f (char *p) +{ + short x = *p++ << 16; + return p; +} + +main () +{ + char *p = ""; + if (f (p) != p + 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930429-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930429-2.c new file mode 100755 index 0000000..e52c8b4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930429-2.c @@ -0,0 +1,14 @@ +int +f (b) +{ + return (b >> 1) > 0; +} + +main () +{ + if (!f (9)) + abort (); + if (f (-9)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930513-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930513-1.c new file mode 100755 index 0000000..4544471 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930513-1.c @@ -0,0 +1,16 @@ +#include <stdio.h> +char buf[2]; + +f (fp) + int (*fp)(char *, const char *, ...); +{ + (*fp)(buf, "%.0f", 5.0); +} + +main () +{ + f (&sprintf); + if (buf[0] != '5' || buf[1] != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930513-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930513-2.c new file mode 100755 index 0000000..3731f62 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930513-2.c @@ -0,0 +1,27 @@ +sub3 (i) + const int *i; +{ +} + +eq (a, b) +{ + static int i = 0; + if (a != i) + abort (); + i++; +} + +main () +{ + int i; + + for (i = 0; i < 4; i++) + { + const int j = i; + int k; + sub3 (&j); + k = j; + eq (k, k); + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930518-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930518-1.c new file mode 100755 index 0000000..44bdf96 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930518-1.c @@ -0,0 +1,24 @@ +int bar = 0; + +f (p) + int *p; +{ + int foo = 2; + + while (foo > bar) + { + foo -= bar; + *p++ = foo; + bar = 1; + } +} + +main () +{ + int tab[2]; + tab[0] = tab[1] = 0; + f (tab); + if (tab[0] != 2 || tab[1] != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930526-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930526-1.c new file mode 100755 index 0000000..bbf63c6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930526-1.c @@ -0,0 +1,18 @@ +inline +f (x) +{ + int *(p[25]); + int m[25*7]; + int i; + + for (i = 0; i < 25; i++) + p[i] = m + x*i; + + p[1][0] = 0; +} + +main () +{ + f (7); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930527-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930527-1.c new file mode 100755 index 0000000..fef34bf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930527-1.c @@ -0,0 +1,11 @@ +f (unsigned char x) +{ + return (0x50 | (x >> 4)) ^ 0xff; +} + +main () +{ + if (f (0) != 0xaf) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930529-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930529-1.c new file mode 100755 index 0000000..906338e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930529-1.c @@ -0,0 +1,45 @@ +dd (x,d) { return x / d; } + +main () +{ + int i; + for (i = -3; i <= 3; i++) + { + if (dd (i, 1) != i / 1) + abort (); + if (dd (i, 2) != i / 2) + abort (); + if (dd (i, 3) != i / 3) + abort (); + if (dd (i, 4) != i / 4) + abort (); + if (dd (i, 5) != i / 5) + abort (); + if (dd (i, 6) != i / 6) + abort (); + if (dd (i, 7) != i / 7) + abort (); + if (dd (i, 8) != i / 8) + abort (); + } + for (i = ((unsigned) ~0 >> 1) - 3; i <= ((unsigned) ~0 >> 1) + 3; i++) + { + if (dd (i, 1) != i / 1) + abort (); + if (dd (i, 2) != i / 2) + abort (); + if (dd (i, 3) != i / 3) + abort (); + if (dd (i, 4) != i / 4) + abort (); + if (dd (i, 5) != i / 5) + abort (); + if (dd (i, 6) != i / 6) + abort (); + if (dd (i, 7) != i / 7) + abort (); + if (dd (i, 8) != i / 8) + abort (); + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930603-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930603-1.c new file mode 100755 index 0000000..6a84de0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930603-1.c @@ -0,0 +1,22 @@ +float fx (x) + float x; +{ + return 1.0 + 3.0 / (2.302585093 * x); +} + +main () +{ + float fx (), inita (), initc (), a, b, c; + a = inita (); + c = initc (); + f (); + b = fx (c) + a; + f (); + if (a != 3.0 || b < 4.3257 || b > 4.3258 || c != 4.0) + abort (); + exit (0); +} + +float inita () { return 3.0; } +float initc () { return 4.0; } +f () {} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930603-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930603-2.c new file mode 100755 index 0000000..8cf06a2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930603-2.c @@ -0,0 +1,19 @@ +int w[2][2]; + +f () +{ + int i, j; + + for (i = 0; i < 2; i++) + for (j = 0; j < 2; j++) + if (i == j) + w[i][j] = 1; +} + +main () +{ + f (); + if (w[0][0] != 1 || w[1][1] != 1 || w[1][0] != 0 || w[0][1] != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930603-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/930603-3.c new file mode 100755 index 0000000..22e5aed --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930603-3.c @@ -0,0 +1,30 @@ +f (b, c) + unsigned char *b; + int c; +{ + unsigned long v = 0; + switch (c) + { + case 'd': + v = ((unsigned long)b[0] << 8) + b[1]; + v >>= 9; + break; + + case 'k': + v = b[3] >> 4; + break; + + default: + abort (); + } + + return v; +} +main () +{ + char buf[4]; + buf[0] = 170; buf[1] = 5; + if (f (buf, 'd') != 85) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930608-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930608-1.c new file mode 100755 index 0000000..004a440 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930608-1.c @@ -0,0 +1,11 @@ +double f (double a) {} +double (* const a[]) (double) = {&f}; + +main () +{ + double (*p) (); + p = &f; + if (p != a[0]) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930614-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930614-1.c new file mode 100755 index 0000000..7b20634 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930614-1.c @@ -0,0 +1,19 @@ +f (double *ty) +{ + *ty = -1.0; +} + +main () +{ + double foo[6]; + double tx = 0.0, ty, d; + + f (&ty); + + if (ty < 0) + ty = -ty; + d = (tx > ty) ? tx : ty; + if (ty != d) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930614-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930614-2.c new file mode 100755 index 0000000..ab83a7e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930614-2.c @@ -0,0 +1,20 @@ +main () +{ + int i, j, k, l; + float x[8][2][8][2]; + + for (i = 0; i < 8; i++) + for (j = i; j < 8; j++) + for (k = 0; k < 2; k++) + for (l = 0; l < 2; l++) + { + if ((i == j) && (k == l)) + x[i][k][j][l] = 0.8; + else + x[i][k][j][l] = 0.8; + if (x[i][k][j][l] < 0.0) + abort (); + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930621-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930621-1.c new file mode 100755 index 0000000..6131301 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930621-1.c @@ -0,0 +1,19 @@ +f () +{ + struct { + int x : 18; + int y : 14; + } foo; + + foo.x = 10; + foo.y = 20; + + return foo.y; +} + +main () +{ + if (f () != 20) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930622-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930622-1.c new file mode 100755 index 0000000..d733e13 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930622-1.c @@ -0,0 +1,22 @@ +int a = 1, b; + +g () { return 0; } +h (x) {} + +f () +{ + if (g () == -1) + return 0; + a = g (); + if (b >= 1) + h (a); + return 0; +} + +main () +{ + f (); + if (a != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930622-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930622-2.c new file mode 100755 index 0000000..d049b00 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930622-2.c @@ -0,0 +1,24 @@ +long double +ll_to_ld (long long n) +{ + return n; +} + +long long +ld_to_ll (long double n) +{ + return n; +} + +main () +{ + long long n; + + if (ll_to_ld (10LL) != 10.0) + abort (); + + if (ld_to_ll (10.0) != 10) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930628-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930628-1.c new file mode 100755 index 0000000..58c612d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930628-1.c @@ -0,0 +1,27 @@ +f (double x[2], double y[2]) +{ + if (x == y) + abort (); +} + +main () +{ + struct { int f[3]; double x[1][2]; } tp[4][2]; + int i, j, ki, kj, mi, mj; + float bdm[4][2][4][2]; + + for (i = 0; i < 4; i++) + for (j = i; j < 4; j++) + for (ki = 0; ki < 2; ki++) + for (kj = 0; kj < 2; kj++) + if ((j == i) && (ki == kj)) + bdm[i][ki][j][kj] = 1000.0; + else + { + for (mi = 0; mi < 1; mi++) + for (mj = 0; mj < 1; mj++) + f (tp[i][ki].x[mi], tp[j][kj].x[mj]); + bdm[i][ki][j][kj] = 1000.0; + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930630-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930630-1.c new file mode 100755 index 0000000..4befa83 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930630-1.c @@ -0,0 +1,19 @@ +main () +{ + struct + { + signed int bf0:17; + signed int bf1:7; + } bf; + + bf.bf1 = 7; + f (bf.bf1); + exit (0); +} + +f (x) + int x; +{ + if (x != 7) + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930702-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930702-1.c new file mode 100755 index 0000000..8828a70 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930702-1.c @@ -0,0 +1,14 @@ +fp (double a, int b) +{ + if (a != 33 || b != 11) + abort (); +} + +main () +{ + int (*f) (double, int) = fp; + + fp (33, 11); + f (33, 11); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930713-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930713-1.c new file mode 100755 index 0000000..6b4d5ab --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930713-1.c @@ -0,0 +1,23 @@ +typedef struct +{ + char x; +} T; + +T +f (s1) + T s1; +{ + T s1a; + s1a.x = 17; + return s1a; +} + +main () +{ + T s1a, s1b; + s1a.x = 13; + s1b = f (s1a); + if (s1a.x != 13 || s1b.x != 17) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930718-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930718-1.c new file mode 100755 index 0000000..a8eacc2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930718-1.c @@ -0,0 +1,34 @@ +typedef struct rtx_def +{ + int f1 :1; + int f2 :1; +} *rtx; + +static rtx +f (orig) + register rtx orig; +{ + if (orig->f1 || orig->f2) + return orig; + orig->f2 = 1; + return orig; +} + +void +f2 () +{ + abort (); +} + +main () +{ + struct rtx_def foo; + rtx bar; + + foo.f1 = 1; + foo.f2 = 0; + bar = f (&foo); + if (bar != &foo || bar->f2 != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930719-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930719-1.c new file mode 100755 index 0000000..c6557ef --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930719-1.c @@ -0,0 +1,23 @@ +int +f (foo, bar, com) +{ + unsigned align; + if (foo) + return 0; + while (1) + { + switch (bar) + { + case 1: + if (com != 0) + return align; + *(char *) 0 = 0; + } + } +} + +main () +{ + f (0, 1, 1); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930725-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930725-1.c new file mode 100755 index 0000000..3bd738c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930725-1.c @@ -0,0 +1,21 @@ +int v; + +char * +g () +{ + return ""; +} + +char * +f () +{ + return (v == 0 ? g () : "abc"); +} + +main () +{ + v = 1; + if (!strcmp (f (), "abc")) + exit (0); + abort(); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930818-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930818-1.c new file mode 100755 index 0000000..710e3ce --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930818-1.c @@ -0,0 +1,15 @@ +static double one = 1.0; + +f() +{ + int colinear; + colinear = (one == 0.0); + if (colinear) + abort (); + return colinear; +} +main() +{ + if (f()) abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930916-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930916-1.c new file mode 100755 index 0000000..6302614 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930916-1.c @@ -0,0 +1,13 @@ +f (n) + unsigned n; +{ + if ((int) n >= 0) + abort (); +} + +main () +{ + unsigned x = ~0; + f (x); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930921-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930921-1.c new file mode 100755 index 0000000..12e04e3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930921-1.c @@ -0,0 +1,15 @@ +f (x) + unsigned x; +{ + return (unsigned) (((unsigned long long) x * 0xAAAAAAAB) >> 32) >> 1; +} + +main () +{ + unsigned i; + + for (i = 0; i < 10000; i++) + if (f (i) != i / 3) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930929-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930929-1.c new file mode 100755 index 0000000..31f6954 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930929-1.c @@ -0,0 +1,36 @@ +sub1 (i) + int i; +{ + return i - (5 - i); +} + +sub2 (i) + int i; +{ + return i + (5 + i); +} + +sub3 (i) + int i; +{ + return i - (5 + i); +} + +sub4 (i) + int i; +{ + return i + (5 - i); +} + +main() +{ + if (sub1 (20) != 35) + abort (); + if (sub2 (20) != 45) + abort (); + if (sub3 (20) != -5) + abort (); + if (sub4 (20) != 5) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930930-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/930930-1.c new file mode 100755 index 0000000..68fdbbf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930930-1.c @@ -0,0 +1,35 @@ +long *wm_TR; +long *wm_HB; +long *wm_SPB; + +long mem[100]; + +f (mr_TR, mr_SPB, mr_HB, reg1, reg2) + long *mr_TR; + long *mr_SPB; + long *mr_HB; + long *reg1; + long *reg2; +{ + long *x = mr_TR; + + for (;;) + { + if (reg1 < reg2) + goto out; + if ((long *) *reg1 < mr_HB && (long *) *reg1 >= mr_SPB) + *--mr_TR = *reg1; + reg1--; + } + out: + + if (x != mr_TR) + abort (); +} + +main () +{ + mem[99] = (long) mem; + f (mem + 100, mem + 6, mem + 8, mem + 99, mem + 99); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/930930-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/930930-2.c new file mode 100755 index 0000000..eb34d11 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/930930-2.c @@ -0,0 +1,30 @@ +int +test_endianness() +{ + union doubleword + { + double d; + unsigned long u[2]; + } dw; + dw.d = 10; + return dw.u[0] != 0 ? 1 : 0; +} + +int +test_endianness_vol() +{ + union doubleword + { + volatile double d; + volatile long u[2]; + } dw; + dw.d = 10; + return dw.u[0] != 0 ? 1 : 0; +} + +main () +{ + if (test_endianness () != test_endianness_vol ()) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931002-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931002-1.c new file mode 100755 index 0000000..6a02b23 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931002-1.c @@ -0,0 +1,28 @@ +f (void (*func) ()) +{ + func (); +} + +main () +{ +#ifndef NO_TRAMPOLINES + void t0 () + { + } + + void t1 () + { + f (t0); + } + + void t2 () + { + t1 (); + } + + t1 (); + t1 (); + t2 (); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-1.c new file mode 100755 index 0000000..9c89afd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-1.c @@ -0,0 +1,30 @@ +struct tiny +{ + int c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-10.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-10.c new file mode 100755 index 0000000..cf0125d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-10.c @@ -0,0 +1,44 @@ +#include <stdarg.h> + +struct tiny +{ + char c; + char d; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-11.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-11.c new file mode 100755 index 0000000..b604702 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-11.c @@ -0,0 +1,50 @@ +struct tiny +{ + char c; + char d; + char e; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + if (x.e != 30) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + if (y.e != 31) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + if (z.e != 32) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-12.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-12.c new file mode 100755 index 0000000..d3fc71e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-12.c @@ -0,0 +1,50 @@ +#include <stdarg.h> + +struct tiny +{ + char c; + char d; + char e; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-13.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-13.c new file mode 100755 index 0000000..60422af --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-13.c @@ -0,0 +1,60 @@ +struct tiny +{ + char c; + char d; + char e; + char f; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + if (x.e != 30) + abort(); + if (x.f != 40) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + if (y.e != 31) + abort(); + if (y.f != 41) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + if (z.e != 32) + abort(); + if (z.f != 42) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-14.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-14.c new file mode 100755 index 0000000..55c71bb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-14.c @@ -0,0 +1,56 @@ +#include <stdarg.h> + +struct tiny +{ + char c; + char d; + char e; + char f; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + if (x.f != i + 40) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-2.c new file mode 100755 index 0000000..83bdea6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-2.c @@ -0,0 +1,38 @@ +#include <stdarg.h> + +struct tiny +{ + int c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-3.c new file mode 100755 index 0000000..1e7a0fd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-3.c @@ -0,0 +1,30 @@ +struct tiny +{ + short c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-4.c new file mode 100755 index 0000000..f0d2331 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-4.c @@ -0,0 +1,38 @@ +#include <stdarg.h> + +struct tiny +{ + short c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-5.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-5.c new file mode 100755 index 0000000..9bef779 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-5.c @@ -0,0 +1,40 @@ +struct tiny +{ + short c; + short d; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-6.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-6.c new file mode 100755 index 0000000..6dca48f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-6.c @@ -0,0 +1,44 @@ +#include <stdarg.h> + +struct tiny +{ + short c; + short d; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-7.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-7.c new file mode 100755 index 0000000..8ab2fcb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-7.c @@ -0,0 +1,30 @@ +struct tiny +{ + char c; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + + if (y.c != 11) + abort(); + + if (z.c != 12) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-8.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-8.c new file mode 100755 index 0000000..5fb97f6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-8.c @@ -0,0 +1,38 @@ +#include <stdarg.h> + +struct tiny +{ + char c; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931004-9.c b/gcc_arm/testsuite/gcc.c-torture/execute/931004-9.c new file mode 100755 index 0000000..07247f7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931004-9.c @@ -0,0 +1,40 @@ +struct tiny +{ + char c; + char d; +}; + +f (int n, struct tiny x, struct tiny y, struct tiny z, long l) +{ + if (x.c != 10) + abort(); + if (x.d != 20) + abort(); + + if (y.c != 11) + abort(); + if (y.d != 21) + abort(); + + if (z.c != 12) + abort(); + if (z.d != 22) + abort(); + + if (l != 123) + abort (); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931005-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931005-1.c new file mode 100755 index 0000000..5a7e031 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931005-1.c @@ -0,0 +1,23 @@ +typedef struct +{ + char x; +} T; + +T +f (s1) + T s1; +{ + T s1a; + s1a.x = s1.x; + return s1a; +} + +main () +{ + T s1a, s1b; + s1a.x = 100; + s1b = f (s1a); + if (s1b.x != 100) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931009-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931009-1.c new file mode 100755 index 0000000..2922280 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931009-1.c @@ -0,0 +1,26 @@ +main () +{ + f (); + exit (0); +} + +static +g (out, size, lo, hi) + int *out, size, lo, hi; +{ + int j; + + for (j = 0; j < size; j++) + out[j] = j * (hi - lo); +} + + +f () +{ + int a[2]; + + g (a, 2, 0, 1); + + if (a[0] != 0 || a[1] != 1) + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931012-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931012-1.c new file mode 100755 index 0000000..d9c958d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931012-1.c @@ -0,0 +1,13 @@ +f (int b, int c) +{ + if (b != 0 && b != 1 && c != 0) + b = 0; + return b; +} + +main () +{ + if (!f (1, 2)) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931017-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931017-1.c new file mode 100755 index 0000000..5917bd9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931017-1.c @@ -0,0 +1,54 @@ +int v; + +main () +{ + f (); + exit (0); +} + +h1 () +{ + return 0; +} + +h2 (e) + int *e; +{ + if (e != &v) + abort (); + return 0; +} + +g (c) + char *c; +{ + int i; + int b; + + do + { + i = h1 (); + if (i == -1) + return 0; + else if (i == 1) + h1 (); + } + while (i == 1); + + do + b = h2 (&v); + while (i == 5); + + if (i != 2) + return b; + *c = 'a'; + + return 0; +} + + +f () +{ + char c; + g (&c); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931018-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931018-1.c new file mode 100755 index 0000000..d3814e6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931018-1.c @@ -0,0 +1,18 @@ +unsigned int a[0x1000]; +extern unsigned long v; + +main () +{ + f (v); + f (v); + exit (0); +} + +f (a) + unsigned long a; +{ + if (a != 0xdeadbeefL) + abort(); +} + +const unsigned long v = 0xdeadbeefL; diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931031-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931031-1.c new file mode 100755 index 0000000..7619890 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931031-1.c @@ -0,0 +1,24 @@ +struct foo +{ + unsigned y:1; + unsigned x:32; +}; + +int +f (x) + struct foo x; +{ + int t = x.x; + if (t < 0) + return 1; + return t+1; +} + +main () +{ + struct foo x; + x.x = -1; + if (f (x) == 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931102-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931102-1.c new file mode 100755 index 0000000..489e7eb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931102-1.c @@ -0,0 +1,30 @@ +typedef union +{ + struct + { + char h, l; + } b; +} T; + +f (x) + int x; +{ + int num = 0; + T reg; + + reg.b.l = x; + while ((reg.b.l & 1) == 0) + { + num++; + reg.b.l >>= 1; + } + return num; +} + +main () +{ + if (f (2) != 1) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931102-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/931102-2.c new file mode 100755 index 0000000..6fc735c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931102-2.c @@ -0,0 +1,31 @@ +typedef union +{ + long align; + struct + { + short h, l; + } b; +} T; + +f (x) + int x; +{ + int num = 0; + T reg; + + reg.b.l = x; + while ((reg.b.l & 1) == 0) + { + num++; + reg.b.l >>= 1; + } + return num; +} + +main () +{ + if (f (2) != 1) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931110-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931110-1.c new file mode 100755 index 0000000..5b33b26 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931110-1.c @@ -0,0 +1,18 @@ +typedef struct +{ + short f:3, g:3, h:10; +} small; + +struct +{ + int i; + small s[10]; +} x; + +main () +{ + int i; + for (i = 0; i < 10; i++) + x.s[i].f = 0; + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931110-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/931110-2.c new file mode 100755 index 0000000..586615b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931110-2.c @@ -0,0 +1,12 @@ +main () +{ + static int a[] = {3, 4}; + register int *b; + int c; + + b = a; + c = *b++ % 8; + if (c != 3) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931208-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931208-1.c new file mode 100755 index 0000000..ee2bc9f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931208-1.c @@ -0,0 +1,14 @@ +f () +{ + unsigned long x, y = 1; + + x = ((y * 8192) - 216) / 16; + return x; +} + +main () +{ + if (f () != 498) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/931228-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/931228-1.c new file mode 100755 index 0000000..dcd3b65 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/931228-1.c @@ -0,0 +1,15 @@ +f (x) +{ + x &= 010000; + x &= 007777; + x ^= 017777; + x &= 017770; + return x; +} + +main () +{ + if (f (-1) != 017770) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/940115-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/940115-1.c new file mode 100755 index 0000000..d0fac90 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/940115-1.c @@ -0,0 +1,13 @@ +f (cp, end) + char *cp; + char *end; +{ + return (cp < end); +} + +main () +{ + if (! f ((char *) 0, (char *) 1)) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/940122-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/940122-1.c new file mode 100755 index 0000000..9dbf6ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/940122-1.c @@ -0,0 +1,21 @@ +char *a = 0; +char *b = 0; + +g (x) + int x; +{ + if ((!!a) != (!!b)) + abort (); +} + +f (x) + int x; +{ + g (x * x); +} + +main () +{ + f (100); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.c new file mode 100755 index 0000000..98db917 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.c @@ -0,0 +1,15 @@ +int f (int a, int b) { } + +main () +{ + unsigned long addr1; + unsigned long addr2; + + addr1 = (unsigned long) &f; + addr1 += 5; + addr2 = 5 + (unsigned long) &f; + + if (addr1 != addr2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.x new file mode 100755 index 0000000..9077584 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941014-1.x @@ -0,0 +1,6 @@ +# This doesn't work for thumb-elf + +if { [istarget "thumb-*-elf"] } { + set torture_execute_xfail "thumb-*-elf" +} +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941014-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/941014-2.c new file mode 100755 index 0000000..3932a34 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941014-2.c @@ -0,0 +1,33 @@ +#include <stdio.h> +#include <stdlib.h> + +typedef struct { + unsigned short a; + unsigned short b; +} foo_t; + +void a1 (unsigned long offset) {} + +volatile foo_t * +f () +{ + volatile foo_t *foo_p = (volatile foo_t *)malloc (sizeof (foo_t)); + + a1((unsigned long)foo_p-30); + if (foo_p->a & 0xf000) + printf("%d\n", foo_p->a); + foo_p->b = 0x0100; + a1 ((unsigned long)foo_p + 2); + a1 ((unsigned long)foo_p - 30); + return foo_p; +} + +main () +{ + volatile foo_t *foo_p; + + foo_p = f (); + if (foo_p->b != 0x0100) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941015-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941015-1.c new file mode 100755 index 0000000..38d4796 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941015-1.c @@ -0,0 +1,35 @@ +int +foo1 (value) + long long value; +{ + register const long long constant = 0xc000000080000000LL; + + if (value < constant) + return 1; + else + return 2; +} + +int +foo2 (value) + unsigned long long value; +{ + register const unsigned long long constant = 0xc000000080000000LL; + + if (value < constant) + return 1; + else + return 2; +} + +main () +{ + unsigned long long value = 0xc000000000000001LL; + int x, y; + + x = foo1 (value); + y = foo2 (value); + if (x != y || x != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941021-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941021-1.c new file mode 100755 index 0000000..9fc1cfa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941021-1.c @@ -0,0 +1,20 @@ +double glob_dbl; + +f (pdbl, value) + double *pdbl; + double value; +{ + if (pdbl == 0) + pdbl = &glob_dbl; + + *pdbl = value; +} + +main () +{ + f ((void *) 0, 55.1); + + if (glob_dbl != 55.1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941025-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941025-1.c new file mode 100755 index 0000000..2daf0ad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941025-1.c @@ -0,0 +1,12 @@ +long f (x, y) + long x,y; +{ + return (x > 1) ? y : (y & 1); +} + +main () +{ + if (f (2L, 0xdecadeL) != 0xdecadeL) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941031-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941031-1.c new file mode 100755 index 0000000..134f966 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941031-1.c @@ -0,0 +1,27 @@ +typedef long mpt; + +int +f (mpt us, mpt vs) +{ + long aus; + long avs; + + aus = us >= 0 ? us : -us; + avs = vs >= 0 ? vs : -vs; + + if (aus < avs) + { + long t = aus; + aus = avs; + avs = aus; + } + + return avs; +} + +main () +{ + if (f ((mpt) 3, (mpt) 17) != 17) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941101-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941101-1.c new file mode 100755 index 0000000..66b5f38 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941101-1.c @@ -0,0 +1,15 @@ +f () +{ + int var = 7; + + if ((var/7) == 1) + return var/7; + return 0; +} + +main () +{ + if (f () != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941110-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941110-1.c new file mode 100755 index 0000000..b78256d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941110-1.c @@ -0,0 +1,16 @@ +f (const int x) +{ + int y = 0; + y = x ? y : -y; + { + const int *p = &x; + } + return y; +} + +main () +{ + if (f (0)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/941202-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/941202-1.c new file mode 100755 index 0000000..72d0b33 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/941202-1.c @@ -0,0 +1,21 @@ +g (x, y) +{ + if (x != 3) + abort (); +} + +static inline +f (int i) +{ + int *tmp; + + tmp = (int *) alloca (sizeof (i)); + *tmp = i; + g (*tmp, 0); +} + +main () +{ + f (3); + exit (0); +}; diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950221-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950221-1.c new file mode 100755 index 0000000..d67da5b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950221-1.c @@ -0,0 +1,55 @@ +struct parsefile +{ + long fd; + char *buf; +}; +struct parsefile basepf; +struct parsefile *parsefile = &basepf; +#ifdef STACK_SIZE +int filler[STACK_SIZE / (2*sizeof(int))]; +#else +int filler[0x3000]; +#endif +int el; + +char * +g1 (a, b) + int a; + int *b; +{ +} + +g2 (a) + long a; +{ + if (a != 0xdeadbeefL) + abort (); + exit (0); +} + +f () +{ + register char *p, *q; + register int i; + register int something; + + if (parsefile->fd == 0L && el) + { + const char *rl_cp; + int len; + rl_cp = g1 (el, &len); + strcpy (p, rl_cp); + } + else + { + alabel: + i = g2 (parsefile->fd); + } +} + +main () +{ + el = 0; + parsefile->fd = 0xdeadbeefL; + f (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950322-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950322-1.c new file mode 100755 index 0000000..28a1469 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950322-1.c @@ -0,0 +1,30 @@ +f (unsigned char *a) +{ + int i, j; + int x, y; + + j = a[1]; + i = a[0] - j; + if (i < 0) + { + x = 1; + y = -i; + } + else + { + x = 0; + y = i; + } + return x + y; +} + + +main () +{ + unsigned char a[2]; + a[0] = 8; + a[1] = 9; + if (f (a) != 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950426-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950426-1.c new file mode 100755 index 0000000..076032c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950426-1.c @@ -0,0 +1,32 @@ + +struct tag { + int m1; + char *m2[5]; +} s1, *p1; + +int i; + +main() +{ + s1.m1 = -1; + p1 = &s1; + + if ( func1( &p1->m1 ) == -1 ) + foo ("ok"); + else + abort (); + + i = 3; + s1.m2[3]= "123"; + + if ( strlen( (p1->m2[i])++ ) == 3 ) + foo ("ok"); + else + abort (); + + exit (0); +} + +func1(int *p) { return(*p); } + +foo (char *s) {} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950426-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/950426-2.c new file mode 100755 index 0000000..a1a6904 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950426-2.c @@ -0,0 +1,13 @@ +main() +{ + long int i = -2147483647L - 1L; /* 0x80000000 */ + char ca = 1; + + if (i >> ca != -1073741824L) + abort (); + + if (i >> i / -2000000000L != -1073741824L) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950503-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950503-1.c new file mode 100755 index 0000000..1c95b36 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950503-1.c @@ -0,0 +1,15 @@ +main () +{ + int tmp; + unsigned long long utmp1, utmp2; + + tmp = 16; + + utmp1 = (~((unsigned long long) 0)) >> tmp; + utmp2 = (~((unsigned long long) 0)) >> 16; + + if (utmp1 != utmp2) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950511-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950511-1.c new file mode 100755 index 0000000..6584b0c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950511-1.c @@ -0,0 +1,11 @@ +main () +{ + unsigned long long xx; + unsigned long long *x = (unsigned long long *) &xx; + + *x = -3; + *x = *x * *x; + if (*x != 9) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950512-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950512-1.c new file mode 100755 index 0000000..8aa116d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950512-1.c @@ -0,0 +1,24 @@ +unsigned +f1 (x) +{ + return ((unsigned) (x != 0) - 3) / 2; +} + +unsigned long long +f2 (x) +{ + return ((unsigned long long) (x != 0) - 3) / 2; +} + +main () +{ + if (f1 (1) != (~(unsigned) 0) >> 1) + abort (); + if (f1 (0) != ((~(unsigned) 0) >> 1) - 1) + abort (); + if (f2 (1) != (~(unsigned long long) 0) >> 1) + abort (); + if (f2 (0) != ((~(unsigned long long) 0) >> 1) - 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950605-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950605-1.c new file mode 100755 index 0000000..d89a42e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950605-1.c @@ -0,0 +1,12 @@ +f (c) + unsigned char c; +{ + if (c != 0xFF) + abort (); +} + +main () +{ + f (-1); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950607-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950607-1.c new file mode 100755 index 0000000..7b1503a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950607-1.c @@ -0,0 +1,9 @@ +main () +{ + struct { long status; } h; + + h.status = 0; + if (((h.status & 128) == 1) && ((h.status & 32) == 0)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950607-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/950607-2.c new file mode 100755 index 0000000..da18f73 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950607-2.c @@ -0,0 +1,41 @@ +typedef struct { + long int p_x, p_y; +} Point; + +int +f (Point basePt, Point pt1, Point pt2) +{ + long long vector; + + vector = + (long long) (pt1.p_x - basePt.p_x) * (long long) (pt2.p_y - basePt.p_y) - + (long long) (pt1.p_y - basePt.p_y) * (long long) (pt2.p_x - basePt.p_x); + + if (vector > (long long) 0) + return 0; + else if (vector < (long long) 0) + return 1; + else + return 2; +} + +main () +{ + Point b, p1, p2; + int answer; + + b.p_x = -23250; + b.p_y = 23250; + + p1.p_x = 23250; + p1.p_y = -23250; + + p2.p_x = -23250; + p2.p_y = -23250; + + answer = f (b, p1, p2); + + if (answer != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950612-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950612-1.c new file mode 100755 index 0000000..f988527 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950612-1.c @@ -0,0 +1,48 @@ +unsigned int +f1 (int diff) +{ + return ((unsigned int) (diff < 0 ? -diff : diff)); +} + +unsigned int +f2 (unsigned int diff) +{ + return ((unsigned int) ((signed int) diff < 0 ? -diff : diff)); +} + +unsigned long long +f3 (long long diff) +{ + return ((unsigned long long) (diff < 0 ? -diff : diff)); +} + +unsigned long long +f4 (unsigned long long diff) +{ + return ((unsigned long long) ((signed long long) diff < 0 ? -diff : diff)); +} + +main () +{ + int i; + for (i = 0; i <= 10; i++) + { + if (f1 (i) != i) + abort (); + if (f1 (-i) != i) + abort (); + if (f2 (i) != i) + abort (); + if (f2 (-i) != i) + abort (); + if (f3 ((long long) i) != i) + abort (); + if (f3 ((long long) -i) != i) + abort (); + if (f4 ((long long) i) != i) + abort (); + if (f4 ((long long) -i) != i) + abort (); + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950621-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950621-1.c new file mode 100755 index 0000000..5fc5a90 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950621-1.c @@ -0,0 +1,20 @@ +struct s +{ + int a; + int b; + struct s *dummy; +}; + +f (struct s *sp) +{ + return sp && sp->a == -1 && sp->b == -1; +} + +main () +{ + struct s x; + x.a = x.b = -1; + if (f (&x) == 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950628-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950628-1.c new file mode 100755 index 0000000..e330ff5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950628-1.c @@ -0,0 +1,31 @@ +typedef struct +{ + char hours, day, month; + short year; +} T; + +T g (void) +{ + T now; + + now.hours = 1; + now.day = 2; + now.month = 3; + now.year = 4; + return now; +} + +T f (void) +{ + T virk; + + virk = g (); + return virk; +} + +main () +{ + if (f ().hours != 1 || f ().day != 2 || f ().month != 3 || f ().year != 4) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950704-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950704-1.c new file mode 100755 index 0000000..f11aff8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950704-1.c @@ -0,0 +1,59 @@ +int errflag; + +long long +f (long long x, long long y) +{ + long long r; + + errflag = 0; + r = x + y; + if (x >= 0) + { + if ((y < 0) || (r >= 0)) + return r; + } + else + { + if ((y > 0) || (r < 0)) + return r; + } + errflag = 1; + return 0; +} + +main () +{ + f (0, 0); + if (errflag) + abort (); + + f (1, -1); + if (errflag) + abort (); + + f (-1, 1); + if (errflag) + abort (); + + f (0x8000000000000000LL, 0x8000000000000000LL); + if (!errflag) + abort (); + + f (0x8000000000000000LL, -1LL); + if (!errflag) + abort (); + + f (0x7fffffffffffffffLL, 0x7fffffffffffffffLL); + if (!errflag) + abort (); + + f (0x7fffffffffffffffLL, 1LL); + if (!errflag) + abort (); + + f (0x7fffffffffffffffLL, 0x8000000000000000LL); + if (errflag) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950706-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950706-1.c new file mode 100755 index 0000000..2db1915 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950706-1.c @@ -0,0 +1,16 @@ +int +f (int n) +{ + return (n > 0) - (n < 0); +} + +main () +{ + if (f (-1) != -1) + abort (); + if (f (1) != 1) + abort (); + if (f (0) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950710-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950710-1.c new file mode 100755 index 0000000..26ff9b2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950710-1.c @@ -0,0 +1,54 @@ +struct twelve +{ + int a; + int b; + int c; +}; + +struct pair +{ + int first; + int second; +}; + +struct pair +g () +{ + struct pair p; + return p; +} + +static void +f () +{ + int i; + for (i = 0; i < 1; i++) + { + int j; + for (j = 0; j < 1; j++) + { + if (0) + { + int k; + for (k = 0; k < 1; k++) + { + struct pair e = g (); + } + } + else + { + struct twelve a, b; + if ((((char *) &b - (char *) &a) < 0 + ? (-((char *) &b - (char *) &a)) + : ((char *) &b - (char *) &a)) < sizeof (a)) + abort (); + } + } + } +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950714-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950714-1.c new file mode 100755 index 0000000..5dc44a9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950714-1.c @@ -0,0 +1,17 @@ +int array[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; + +main () +{ + int i, j; + int *p; + + for (i = 0; i < 10; i++) + for (p = &array[0]; p != &array[9]; p++) + if (*p == i) + goto label; + + label: + if (i != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950809-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950809-1.c new file mode 100755 index 0000000..a33d42b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950809-1.c @@ -0,0 +1,33 @@ +struct S +{ + int *sp, fc, *sc, a[2]; +}; + +f (struct S *x) +{ + int *t = x->sc; + int t1 = t[0]; + int t2 = t[1]; + int t3 = t[2]; + int a0 = x->a[0]; + int a1 = x->a[1]; + t[2] = t1; + t[0] = a1; + x->a[1] = a0; + x->a[0] = t3; + x->fc = t2; + x->sp = t; +} + +main () +{ + struct S s; + static int sc[3] = {2, 3, 4}; + s.sc = sc; + s.a[0] = 10; + s.a[1] = 11; + f (&s); + if (s.sp[2] != 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950906-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950906-1.c new file mode 100755 index 0000000..31997d5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950906-1.c @@ -0,0 +1,16 @@ +g (int i) +{ +} + +f (int i) +{ + g (0); + while ( ({ i--; }) ) + g (0); +} + +main () +{ + f (10); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950915-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950915-1.c new file mode 100755 index 0000000..cfa0447 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950915-1.c @@ -0,0 +1,15 @@ +long int a = 100000; +long int b = 21475; + +long +f () +{ + return ((long long) a * (long long) b) >> 16; +} + +main () +{ + if (f () < 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/950929-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/950929-1.c new file mode 100755 index 0000000..a35cd6a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/950929-1.c @@ -0,0 +1,21 @@ +int f (char *p) { } + +main () +{ + char c; + char c2; + int i = 0; + char *pc = &c; + char *pc2 = &c2; + int *pi = &i; + + *pc2 = 1; + *pi = 1; + *pc2 &= *pi; + f (pc2); + *pc2 = 1; + *pc2 &= *pi; + if (*pc2 != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/951003-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/951003-1.c new file mode 100755 index 0000000..269bf13 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/951003-1.c @@ -0,0 +1,21 @@ +int f (i) { return 12; } +int g () { return 0; } + +main () +{ + int i, s; + + for (i = 0; i < 32; i++) + { + s = f (i); + + if (i == g ()) + s = 42; + if (i == 0 || s == 12) + ; + else + abort (); + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/951115-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/951115-1.c new file mode 100755 index 0000000..03520c9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/951115-1.c @@ -0,0 +1,24 @@ +int var = 0; + +g () +{ + var = 1; +} + +f () +{ + int f2 = 0; + + if (f2 == 0) + ; + + g (); +} + +main () +{ + f (); + if (var != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/951204-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/951204-1.c new file mode 100755 index 0000000..c4d585b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/951204-1.c @@ -0,0 +1,18 @@ +f (char *x) +{ + *x = 'x'; +} + +main () +{ + int i; + char x = '\0'; + + for (i = 0; i < 100; ++i) + { + f (&x); + if (*(const char *) &x != 'x') + abort (); + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960116-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960116-1.c new file mode 100755 index 0000000..6d7624c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960116-1.c @@ -0,0 +1,20 @@ +static inline +p (int *p) +{ + return !((long) p & 1); +} + +int +f (int *q) +{ + if (p (q) && *q) + return 1; + return 0; +} + +main () +{ + if (f ((int*) 0xffffffff) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960117-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960117-1.c new file mode 100755 index 0000000..741455b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960117-1.c @@ -0,0 +1,46 @@ +static char id_space[2] [32 +1]; +typedef short COUNT; + +typedef char TEXT; + +union T_VALS +{ + TEXT *id __attribute__ ((aligned (2), packed)) ; +}; +typedef union T_VALS VALS; + +struct T_VAL +{ + COUNT pos __attribute__ ((aligned (2), packed)) ; + VALS vals __attribute__ ((aligned (2), packed)) ; +}; +typedef struct T_VAL VAL; + +VAL curval = {0}; + +static short idc = 0; +static int cur_line; +static int char_pos; + +typedef unsigned short WORD; + +WORD +get_id (char c) +{ + curval.vals.id[0] = c; +} + +WORD +get_tok () +{ + char c = 'c'; + curval.vals.id = id_space[idc]; + curval.pos = (cur_line << 10) | char_pos; + return get_id (c); +} + +main () +{ + get_tok (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960209-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960209-1.c new file mode 100755 index 0000000..decd2af --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960209-1.c @@ -0,0 +1,43 @@ +struct a_struct +{ + unsigned char a_character; +}; + +struct a_struct an_array[5]; +struct a_struct *a_ptr; +int yabba = 1; + +int +f (a, b) + unsigned char a; + unsigned long b; +{ + long i, j, p, q, r, s; + + if (b != (unsigned long) 0) + { + if (yabba) + return -1; + s = 4000000 / b; + for (i = 0; i < 11; i++) + { + for (j = 0; j < 256; j++) + { + if (((p - s < 0) ? -s : 0) < (( q - s < 0) ? -s : q)) + r = i; + } + } + } + + if (yabba) + return 0; + a_ptr = &an_array[a]; + a_ptr->a_character = (unsigned char) r; +} + +main () +{ + if (f (1, 0UL) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960215-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960215-1.c new file mode 100755 index 0000000..9502b4b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960215-1.c @@ -0,0 +1,25 @@ +long double C = 2; +long double U = 1; +long double Y2 = 3; +long double Y1 = 1; +long double X, Y, Z, T, R, S; +main () +{ + X = (C + U) * Y2; + Y = C - U - U; + Z = C + U + U; + T = (C - U) * Y1; + X = X - (Z + U); + R = Y * Y1; + S = Z * Y2; + T = T - Y; + Y = (U - Y) + R; + Z = S - (Z + U + U); + R = (Y2 + U) * Y1; + Y1 = Y2 * Y1; + R = R - Y2; + Y1 = Y1 - 0.5L; + if (Z != 6) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960218-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960218-1.c new file mode 100755 index 0000000..7301a17 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960218-1.c @@ -0,0 +1,22 @@ +int glob; + +g (x) +{ + glob = x; + return 0; +} + +f (x) +{ + int a = ~x; + while (a) + a = g (a); +} + +main () +{ + f (3); + if (glob != -4) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960219-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960219-1.c new file mode 100755 index 0000000..d21bcfc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960219-1.c @@ -0,0 +1,11 @@ +f (int i) +{ + if (((1 << i) & 1) == 0) + abort (); +} + +main () +{ + f (0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960301-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960301-1.c new file mode 100755 index 0000000..d75efea --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960301-1.c @@ -0,0 +1,22 @@ +struct foo { + unsigned : 12; + unsigned field : 4; +} foo; +unsigned oldfoo; + +int +bar (unsigned k) +{ + oldfoo = foo.field; + foo.field = k; + if (k) + return 1; + return 2; +} + +main () +{ + if (bar (1U) != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960302-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960302-1.c new file mode 100755 index 0000000..7a9426a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960302-1.c @@ -0,0 +1,21 @@ +long a = 1; + +foo () +{ + switch (a % 2 % 2 % 2 % 2 % 2 % 2 % 2 % 2) + { + case 0: + return 0; + case 1: + return 1; + default: + return -1; + } +} + +main () +{ + if (foo () != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960311-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960311-1.c new file mode 100755 index 0000000..16579d0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960311-1.c @@ -0,0 +1,69 @@ +#include <stdio.h> + +#ifdef DEBUG +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned char data) +{ + if (data & 0x80) a1(); + data <<= 1; + + if (data & 0x80) a1(); + data <<= 1; + + if (data & 0x80) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x80); + if (count != 1) + abort (); + + count = 0; + b (0x40); + if (count != 1) + abort (); + + count = 0; + b (0x20); + if (count != 1) + abort (); + + count = 0; + b (0xc0); + if (count != 2) + abort (); + + count = 0; + b (0xa0); + if (count != 2) + abort (); + + count = 0; + b (0x60); + if (count != 2) + abort (); + + count = 0; + b (0xe0); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960311-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/960311-2.c new file mode 100755 index 0000000..d5c2d07 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960311-2.c @@ -0,0 +1,69 @@ +#include <stdio.h> + +#ifdef DEBUG +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned short data) +{ + if (data & 0x8000) a1(); + data <<= 1; + + if (data & 0x8000) a1(); + data <<= 1; + + if (data & 0x8000) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x8000); + if (count != 1) + abort (); + + count = 0; + b (0x4000); + if (count != 1) + abort (); + + count = 0; + b (0x2000); + if (count != 1) + abort (); + + count = 0; + b (0xc000); + if (count != 2) + abort (); + + count = 0; + b (0xa000); + if (count != 2) + abort (); + + count = 0; + b (0x6000); + if (count != 2) + abort (); + + count = 0; + b (0xe000); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960311-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/960311-3.c new file mode 100755 index 0000000..755fc72 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960311-3.c @@ -0,0 +1,69 @@ +#include <stdio.h> + +#ifdef DEBUG +#define abort() printf ("error, line %d\n", __LINE__) +#endif + +int count; + +void a1() { ++count; } + +void +b (unsigned long data) +{ + if (data & 0x80000000) a1(); + data <<= 1; + + if (data & 0x80000000) a1(); + data <<= 1; + + if (data & 0x80000000) a1(); +} + +main () +{ + count = 0; + b (0); + if (count != 0) + abort (); + + count = 0; + b (0x80000000); + if (count != 1) + abort (); + + count = 0; + b (0x40000000); + if (count != 1) + abort (); + + count = 0; + b (0x20000000); + if (count != 1) + abort (); + + count = 0; + b (0xc0000000); + if (count != 2) + abort (); + + count = 0; + b (0xa0000000); + if (count != 2) + abort (); + + count = 0; + b (0x60000000); + if (count != 2) + abort (); + + count = 0; + b (0xe0000000); + if (count != 3) + abort (); + +#ifdef DEBUG + printf ("Done.\n"); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960312-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960312-1.c new file mode 100755 index 0000000..94e67df --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960312-1.c @@ -0,0 +1,34 @@ +struct S +{ + int *sp, fc, *sc, a[2]; +}; + +f (struct S *x) +{ + int *t = x->sc; + int t1 = t[0]; + int t2 = t[1]; + int t3 = t[2]; + int a0 = x->a[0]; + int a1 = x->a[1]; + asm("": :"r" (t2), "r" (t3)); + t[2] = t1; + t[0] = a1; + x->a[1] = a0; + x->a[0] = t3; + x->fc = t2; + x->sp = t; +} + +main () +{ + struct S s; + static int sc[3] = {2, 3, 4}; + s.sc = sc; + s.a[0] = 10; + s.a[1] = 11; + f (&s); + if (s.sp[2] != 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960317-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960317-1.c new file mode 100755 index 0000000..8d7907d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960317-1.c @@ -0,0 +1,22 @@ +int +f (unsigned bitcount, int mant) +{ + int mask = -1 << bitcount; + { + if (! (mant & -mask)) + goto ab; + if (mant & ~mask) + goto auf; + } +ab: + return 0; +auf: + return 1; +} + +main () +{ + if (f (0, -1)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960321-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960321-1.c new file mode 100755 index 0000000..eafe48f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960321-1.c @@ -0,0 +1,14 @@ +char a[10] = "deadbeef"; + +char +acc_a (long i) +{ + return a[i-2000000000L]; +} + +main () +{ + if (acc_a (2000000000L) != 'd') + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960326-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960326-1.c new file mode 100755 index 0000000..f201373 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960326-1.c @@ -0,0 +1,16 @@ +struct s +{ + int a; + int b; + short c; + int d[3]; +}; + +struct s s = { .b = 3, .d = {2,0,0} }; + +main () +{ + if (s.b != 3) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960327-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960327-1.c new file mode 100755 index 0000000..d630a7b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960327-1.c @@ -0,0 +1,30 @@ +#include <stdio.h> +g () +{ + return '\n'; +} + +f () +{ + char s[] = "abcedfg01234"; + char *sp = s + 12; + + switch (g ()) + { + case '\n': + break; + } + + while (*--sp == '0') + ; + sprintf (sp + 1, "X"); + + if (s[12] != 'X') + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960402-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960402-1.c new file mode 100755 index 0000000..601a9a3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960402-1.c @@ -0,0 +1,11 @@ +f (signed long long int x) +{ + return x > 0xFFFFFFFFLL || x < -0x80000000LL; +} + +main () +{ + if (f (0) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960405-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960405-1.c new file mode 100755 index 0000000..d8480cc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960405-1.c @@ -0,0 +1,13 @@ +#define X 5.9486574767861588254287966331400356538172e4931L + +long double x = X + X; +long double y = 2.0L * X; + +main () +{ +#if ! defined (__vax__) && ! defined (_CRAY) + if (x != y) + abort (); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960416-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960416-1.c new file mode 100755 index 0000000..f7cb056 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960416-1.c @@ -0,0 +1,63 @@ +typedef unsigned long int st; +typedef unsigned long long dt; +typedef union +{ + dt d; + struct + { + st h, l; + } + s; +} t_be; + +typedef union +{ + dt d; + struct + { + st l, h; + } + s; +} t_le; + +#define df(f, t) \ +int \ +f (t afh, t bfh) \ +{ \ + t hh; \ + t hp, lp, dp, m; \ + st ad, bd; \ + int s; \ + s = 0; \ + ad = afh.s.h - afh.s.l; \ + bd = bfh.s.l - bfh.s.h; \ + if (bd > bfh.s.l) \ + { \ + bd = -bd; \ + s = ~s; \ + } \ + lp.d = (dt) afh.s.l * bfh.s.l; \ + hp.d = (dt) afh.s.h * bfh.s.h; \ + dp.d = (dt) ad *bd; \ + dp.d ^= s; \ + hh.d = hp.d + hp.s.h + lp.s.h + dp.s.h; \ + m.d = (dt) lp.s.h + hp.s.l + lp.s.l + dp.s.l; \ + return hh.s.l + m.s.l; \ +} + +df(f_le, t_le) +df(f_be, t_be) + +main () +{ + t_be x; + x.s.h = 0x10000000U; + x.s.l = 0xe0000000U; + if (x.d == 0x10000000e0000000ULL + && f_be ((t_be) 0x100000000ULL, (t_be) 0x100000000ULL) != -1) + abort (); + if (x.d == 0xe000000010000000ULL + && f_le ((t_le) 0x100000000ULL, (t_le) 0x100000000ULL) != -1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960419-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960419-1.c new file mode 100755 index 0000000..68bd2b9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960419-1.c @@ -0,0 +1,17 @@ +static int i; + +void +check(x) + int x; +{ + if (!x) + abort(); +} + +main() +{ + int *p = &i; + + check(p != (void *)0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960419-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/960419-2.c new file mode 100755 index 0000000..c9526dc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960419-2.c @@ -0,0 +1,13 @@ +#define SIZE 8 + +main() +{ + int a[SIZE] = {1}; + int i; + + for (i = 1; i < SIZE; i++) + if (a[i] != 0) + abort(); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960512-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960512-1.c new file mode 100755 index 0000000..a7c1d5f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960512-1.c @@ -0,0 +1,19 @@ +__complex__ +double f () +{ + int a[40]; + __complex__ double c; + + a[9] = 0; + c = a[9]; + return c; +} + +main () +{ + __complex__ double c; + + if (c = f ()) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960513-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960513-1.c new file mode 100755 index 0000000..acc263c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960513-1.c @@ -0,0 +1,25 @@ +long double +f (d, i) + long double d; + int i; +{ + long double e; + + d = -d; + e = d; + if (i == 1) + d *= 2; + d -= e * d; + d -= e * d; + d -= e * d; + d -= e * d; + d -= e * d; + return d; +} + +main () +{ + if (! (int) (f (2.0L, 1))) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960521-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960521-1.c new file mode 100755 index 0000000..9fc5821 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960521-1.c @@ -0,0 +1,30 @@ +#include <stdlib.h> + +int *a, *b; +int n; + +#ifdef STACK_SIZE +#define BLOCK_SIZE (STACK_SIZE / (sizeof (*a) + sizeof (*b))) +#else +#define BLOCK_SIZE 32768 +#endif +foo () +{ + int i; + for (i = 0; i < n; i++) + a[i] = -1; + for (i = 0; i < BLOCK_SIZE - 1; i++) + b[i] = -1; +} + +main () +{ + n = BLOCK_SIZE; + a = malloc (n * sizeof(*a)); + b = malloc (n * sizeof(*b)); + *b++ = 0; + foo (); + if (b[-1]) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960608-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960608-1.c new file mode 100755 index 0000000..1f47d02 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960608-1.c @@ -0,0 +1,34 @@ +typedef struct +{ + unsigned char a : 2; + unsigned char b : 3; + unsigned char c : 1; + unsigned char d : 1; + unsigned char e : 1; +} a_struct; + +foo (flags) + a_struct *flags; +{ + return (flags->c != 0 + || flags->d != 1 + || flags->e != 1 + || flags->a != 2 + || flags->b != 3); +} + +main () +{ + a_struct flags; + + flags.c = 0; + flags.d = 1; + flags.e = 1; + flags.a = 2; + flags.b = 3; + + if (foo (&flags) != 0) + abort (); + else + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960801-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960801-1.c new file mode 100755 index 0000000..1707269 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960801-1.c @@ -0,0 +1,32 @@ +unsigned +f () +{ + long long l2; + unsigned short us; + unsigned long long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} + +unsigned long long +g () +{ + long long l2; + unsigned short us; + unsigned long long ul; + short s2; + + ul = us = l2 = s2 = -1; + return ul; +} + +main () +{ + if (f () != (unsigned short) -1) + abort (); + if (g () != (unsigned short) -1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960802-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960802-1.c new file mode 100755 index 0000000..f9ee752 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960802-1.c @@ -0,0 +1,36 @@ +long val = 0x5e000000; + +long +f1 (void) +{ + return 0x132; +} + +long +f2 (void) +{ + return 0x5e000000; +} + +void +f3 (long b) +{ + val = b; +} + +void +f4 () +{ + long v = f1 (); + long o = f2 (); + v = (v & 0x00ffffff) | (o & 0xff000000); + f3 (v); +} + +main () +{ + f4 (); + if (val != 0x5e000132) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960830-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960830-1.c new file mode 100755 index 0000000..d87b39e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960830-1.c @@ -0,0 +1,22 @@ +#ifdef __i386__ +f (rp) + unsigned int *rp; +{ + __asm__ ("mull %3" : "=a" (rp[0]), "=d" (rp[1]) : "%0" (7), "rm" (7)); +} + +main () +{ + unsigned int s[2]; + + f (s); + if (s[1] != 0 || s[0] != 49) + abort (); + exit (0); +} +#else +main () +{ + exit (0); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/960909-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/960909-1.c new file mode 100755 index 0000000..de1ed93 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/960909-1.c @@ -0,0 +1,29 @@ +int +ffs (x) + int x; +{ + int bit, mask; + + if (x == 0) + return 0; + + for (bit = 1, mask = 1; !(x & mask); bit++, mask <<= 1) + ; + + return bit; +} + +f (x) + int x; +{ + int y; + y = ffs (x) - 1; + if (y < 0) + abort (); +} + +main () +{ + f (1); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961004-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961004-1.c new file mode 100755 index 0000000..7ebba2d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961004-1.c @@ -0,0 +1,22 @@ +int k = 0; + +main() +{ + int i; + int j; + + for (i = 0; i < 2; i++) + { + if (k) + { + if (j != 2) + abort (); + } + else + { + j = 2; + k++; + } + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961017-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961017-1.c new file mode 100755 index 0000000..88c9d95 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961017-1.c @@ -0,0 +1,8 @@ +main () +{ + unsigned char z = 0; + + do ; + while (--z > 0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961017-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/961017-2.c new file mode 100755 index 0000000..768ddbc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961017-2.c @@ -0,0 +1,32 @@ +main () +{ + int i = 0; + + + if (sizeof (unsigned long int) == 4) + { + unsigned long int z = 0; + + do { + z -= 0x00004000; + i++; + if (i > 0x00040000) + abort (); + } while (z > 0); + exit (0); + } + else if (sizeof (unsigned int) == 4) + { + unsigned int z = 0; + + do { + z -= 0x00004000; + i++; + if (i > 0x00040000) + abort (); + } while (z > 0); + exit (0); + } + else + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961026-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961026-1.c new file mode 100755 index 0000000..942a6eb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961026-1.c @@ -0,0 +1,17 @@ +int +test (arg) + int arg; +{ + if (arg > 0 || arg == 0) + return 0; + return -1; +} + +main () +{ + if (test (0) != 0) + abort (); + if (test (-1) != -1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961112-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961112-1.c new file mode 100755 index 0000000..4b1c312 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961112-1.c @@ -0,0 +1,13 @@ +f (x) +{ + if (x != 0 || x == 0) + return 0; + return 1; +} + +main () +{ + if (f (3)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961122-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961122-1.c new file mode 100755 index 0000000..1f0a634 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961122-1.c @@ -0,0 +1,23 @@ +long long acc; + +addhi (short a) +{ + acc += (long long) a << 32; +} + +subhi (short a) +{ + acc -= (long long) a << 32; +} + +main () +{ + acc = 0xffff00000000ll; + addhi (1); + if (acc != 0x1000000000000ll) + abort (); + subhi (1); + if (acc != 0xffff00000000ll) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961122-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/961122-2.c new file mode 100755 index 0000000..81e404e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961122-2.c @@ -0,0 +1,12 @@ +int +f (int a) +{ + return ((a >= 0 && a <= 10) && ! (a >= 0)); +} + +main () +{ + if (f (0)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961125-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961125-1.c new file mode 100755 index 0000000..7fe3dd4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961125-1.c @@ -0,0 +1,33 @@ +static char * +begfield (int tab, char *ptr, char *lim, int sword, int schar) +{ + if (tab) + { + while (ptr < lim && sword--) + { + while (ptr < lim && *ptr != tab) + ++ptr; + if (ptr < lim) + ++ptr; + } + } + else + { + while (1) + ; + } + + if (ptr + schar <= lim) + ptr += schar; + + return ptr; +} + +main () +{ + char *s = ":ab"; + char *lim = s + 3; + if (begfield (':', s, lim, 1, 1) != s + 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961206-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961206-1.c new file mode 100755 index 0000000..943ac66 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961206-1.c @@ -0,0 +1,52 @@ +int +sub1 (unsigned long long i) +{ + if (i < 0x80000000) + return 1; + else + return 0; +} + +int +sub2 (unsigned long long i) +{ + if (i <= 0x7FFFFFFF) + return 1; + else + return 0; +} + +int +sub3 (unsigned long long i) +{ + if (i >= 0x80000000) + return 0; + else + return 1; +} + +int +sub4 (unsigned long long i) +{ + if (i > 0x7FFFFFFF) + return 0; + else + return 1; +} + +main() +{ + if (sub1 (0x80000000ULL)) + abort (); + + if (sub2 (0x80000000ULL)) + abort (); + + if (sub3 (0x80000000ULL)) + abort (); + + if (sub4 (0x80000000ULL)) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961213-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961213-1.c new file mode 100755 index 0000000..12bb27f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961213-1.c @@ -0,0 +1,22 @@ +int +g (unsigned long long int *v, int n, unsigned int a[], int b) +{ + int cnt; + *v = 0; + for (cnt = 0; cnt < n; ++cnt) + *v = *v * b + a[cnt]; + return n; +} + +main () +{ + int res; + unsigned int ar[] = { 10, 11, 12, 13, 14 }; + unsigned long long int v; + + res = g (&v, sizeof(ar)/sizeof(ar[0]), ar, 16); + if (v != 0xabcdeUL) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/961223-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/961223-1.c new file mode 100755 index 0000000..9bc6cfa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/961223-1.c @@ -0,0 +1,19 @@ +struct s { + double d; +}; + +inline struct s +sub (struct s s) +{ + s.d += 1.0; + return s; +} + +main () +{ + struct s t = { 2.0 }; + t = sub (t); + if (t.d != 3.0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/970214-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/970214-1.c new file mode 100755 index 0000000..4a06dfe --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/970214-1.c @@ -0,0 +1,5 @@ +#define L 1 +main () +{ + exit (L'1' != L'1'); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/970214-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/970214-2.c new file mode 100755 index 0000000..cb90076 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/970214-2.c @@ -0,0 +1,5 @@ +#define m(L) (L'1' + (L)) +main () +{ + exit (m (0) != L'1'); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/970217-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/970217-1.c new file mode 100755 index 0000000..09e716a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/970217-1.c @@ -0,0 +1,10 @@ +sub (int i, int array[i++]) +{ + return i; +} + +main() +{ + int array[10]; + exit (sub (10, array) != 11); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/970312-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/970312-1.c new file mode 100755 index 0000000..6b78ee1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/970312-1.c @@ -0,0 +1,73 @@ +#include <stdio.h> + +__inline__ static int +dummy (x) +{ + int y; + y = (long) (x * 4711.3); + return y; +} + +int getval (void); + +int +f2 (double x) +{ + unsigned short s; + int a, b, c, d, e, f, g, h, i, j; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + + s = x; + + return a + b + c + d + e + f + g + h + i + j + s; +} + +int x = 1; + +int +getval (void) +{ + return x++; +} + +char buf[10]; + +void +f () +{ + int a, b, c, d, e, f, g, h, i, j, k; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + k = f2 (17.0); + + sprintf (buf, "%d\n", a + b + c + d + e + f + g + h + i + j + k); + if (a + b + c + d + e + f + g + h + i + j + k != 227) + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/970923-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/970923-1.c new file mode 100755 index 0000000..1d78b47 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/970923-1.c @@ -0,0 +1,27 @@ +int +ts(a) + int a; +{ + if (a < 1000 && a > 2000) + return 1; + else + return 0; +} + +int +tu(a) + unsigned int a; +{ + if (a < 1000 && a > 2000) + return 1; + else + return 0; +} + + +main() +{ + if (ts (0) || tu (0)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980205.c b/gcc_arm/testsuite/gcc.c-torture/execute/980205.c new file mode 100755 index 0000000..da15d3c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980205.c @@ -0,0 +1,20 @@ +#include <stdarg.h> + +void fdouble (double one, ...) +{ + double value; + va_list ap; + + va_start (ap, one); + value = va_arg (ap, double); + va_end (ap); + + if (one != 1.0 || value != 2.0) + abort (); +} + +int main () +{ + fdouble (1.0, 2.0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980223.c b/gcc_arm/testsuite/gcc.c-torture/execute/980223.c new file mode 100755 index 0000000..eccfdfa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980223.c @@ -0,0 +1,31 @@ +typedef struct { long addr; long type; } object; + +object bar (object blah) +{ + abort(); +} + +object foo (object x, object y) +{ + object z = *(object*)(x.addr); + if (z.type & 64) + { + y = *(object*)(z.addr+sizeof(object)); + z = *(object*)(z.addr); + if (z.type & 64) + y = bar(y); + } + return y; +} + +int nil; +object cons1[2] = { {(long) &nil, 0}, {(long) &nil, 0} }; +object cons2[2] = { {(long) &cons1, 64}, {(long) &nil, 0} }; + +main() +{ + object x = {(long) &cons2, 64}; + object y = {(long) &nil, 0}; + object three = foo(x,y); + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980424-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980424-1.c new file mode 100755 index 0000000..514e917 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980424-1.c @@ -0,0 +1,22 @@ +int i, a[99]; + +void f (int one) +{ + if (one != 1) + abort (); +} + +void +g () +{ + f (a[i & 0x3f]); +} + +int +main () +{ + a[0] = 1; + i = 0x40; + g (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980505-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980505-1.c new file mode 100755 index 0000000..9052411 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980505-1.c @@ -0,0 +1,11 @@ +static int f(int) __attribute__((const)); +int main() +{ + int f1, f2, x; + x = 1; f1 = f(x); + x = 2; f2 = f(x); + if (f1 != 1 || f2 != 2) + abort (); + exit (0); +} +static int f(int x) { return x; } diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980505-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/980505-2.c new file mode 100755 index 0000000..d0d8aa8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980505-2.c @@ -0,0 +1,22 @@ +typedef unsigned short Uint16; +typedef unsigned int Uint; + +Uint f () +{ + Uint16 token; + Uint count; + static Uint16 values[1] = {0x9300}; + + token = values[0]; + count = token >> 8; + + return count; +} + +int +main () +{ + if (f () != 0x93) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980506-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980506-1.c new file mode 100755 index 0000000..a48b3ad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980506-1.c @@ -0,0 +1,26 @@ +struct decision +{ + char enforce_mode; + struct decision *next; +}; + + +static void +clear_modes (p) + register struct decision *p; +{ + goto blah; + +foo: + p->enforce_mode = 0; +blah: + if (p) + goto foo; +} + +main() +{ + struct decision *p = 0; + clear_modes (p); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.c new file mode 100755 index 0000000..4dd9a2c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.c @@ -0,0 +1,22 @@ +static void *self(void *p){ return p; } + +int +f() +{ + struct { int i; } s, *sp; + int *ip = &s.i; + + s.i = 1; + sp = self(&s); + + *ip = 0; + return sp->i+1; +} + +main() +{ + if (f () != 1) + abort (); + else + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.x b/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.x new file mode 100755 index 0000000..aa6d1f4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980506-2.x @@ -0,0 +1,22 @@ +# This test is known to fail on targets that use the instruction scheduler +# at optimisation levels of 2 or more because the alias analysis is confused +# by the reassignment of a variable structure to a fixed structure. The +# failure could be suppressed by preventing instruction scheduling: +# +# set additional_flags "-fno-schedule-insns -fno-schedule-insns2"; +# +# but this would disguise the fact that there is a problem. Instead we use +# we generate an xfail result and explain that it is alias analysis that +# is at fault. + +set torture_eval_before_execute { + + set compiler_conditional_xfail_data { + "alias analysis conflicts with instruction scheduling" \ + "arm-*-* thumb-*-*" \ + {"-O2" "-Os"} \ + {"-O2 -fomit-frame-pointer -finline-functions" } + } +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980506-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/980506-3.c new file mode 100755 index 0000000..a943e9a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980506-3.c @@ -0,0 +1,24 @@ +unsigned char lookup_table [257]; + +static int +build_lookup (pattern) + unsigned char *pattern; +{ + int m; + + m = strlen (pattern) - 1; + + memset (lookup_table, ++m, 257); + return m; +} + +int main(argc, argv) + int argc; + char **argv; +{ + if (build_lookup ("bind") != 4) + abort (); + else + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.c new file mode 100755 index 0000000..57a910e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.c @@ -0,0 +1,37 @@ +int expect_do1 = 1, expect_do2 = 2; + +static int doit(int x){ + __label__ lbl1; + __label__ lbl2; + static int jtab_init = 0; + static void *jtab[2]; + + if(!jtab_init) { + jtab[0] = &&lbl1; + jtab[1] = &&lbl2; + jtab_init = 1; + } + goto *jtab[x]; +lbl1: + return 1; +lbl2: + return 2; +} + +static void do1(void) { + if (doit(0) != expect_do1) + abort (); +} + +static void do2(void){ + if (doit(1) != expect_do2) + abort (); +} + +int main(void){ +#ifndef NO_LABEL_VALUES + do1(); + do2(); +#endif + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.x new file mode 100755 index 0000000..eec70ee --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980526-1.x @@ -0,0 +1,12 @@ +set torture_eval_before_execute { + + set compiler_conditional_xfail_data { + "I sure wish I knew why this was hosed" \ + "arm-*-* thumb-*-* fr30-*-elf" \ + {"-O2 -finline-functions"} \ + {"" } + } +} + +return 0 + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980526-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/980526-2.c new file mode 100755 index 0000000..2547147 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980526-2.c @@ -0,0 +1,57 @@ +typedef unsigned int dev_t; +typedef unsigned int kdev_t; + +static inline kdev_t to_kdev_t(int dev) +{ + int major, minor; + + if (sizeof(kdev_t) == 16) + return (kdev_t)dev; + major = (dev >> 8); + minor = (dev & 0xff); + return ((( major ) << 22 ) | ( minor )) ; + +} + +void do_mknod(const char * filename, int mode, kdev_t dev) +{ + if (dev==0x15800078) + exit(0); + else + abort(); +} + + +char * getname(const char * filename) +{ + register unsigned int a1,a2,a3,a4,a5,a6,a7,a8,a9; + a1 = (unsigned int)(filename) *5 + 1; + a2 = (unsigned int)(filename) *6 + 2; + a3 = (unsigned int)(filename) *7 + 3; + a4 = (unsigned int)(filename) *8 + 4; + a5 = (unsigned int)(filename) *9 + 5; + a6 = (unsigned int)(filename) *10 + 5; + a7 = (unsigned int)(filename) *11 + 5; + a8 = (unsigned int)(filename) *12 + 5; + a9 = (unsigned int)(filename) *13 + 5; + return (char *)(a1*a2+a3*a4+a5*a6+a7*a8+a9); +} + +int sys_mknod(const char * filename, int mode, dev_t dev) +{ + int error; + char * tmp; + + tmp = getname(filename); + error = ((long)( tmp )) ; + do_mknod(tmp,mode,to_kdev_t(dev)); + return error; +} + +int main(void) +{ + if (sizeof (int) < 4) + exit (0); + + return sys_mknod("test",1,0x12345678); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980526-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/980526-3.c new file mode 100755 index 0000000..a564174 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980526-3.c @@ -0,0 +1,20 @@ +int compare(x, y) +unsigned int x; +unsigned int y; +{ + if (x==y) + return 0; + else + return 1; +} + +main() +{ + unsigned int i, j, k, l; + i = 5; j = 2; k=0; l=2; + if (compare(5%(~(unsigned) 2), i%~j) + || compare(0, k%~l)) + abort(); + else + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980602-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980602-1.c new file mode 100755 index 0000000..2df7283 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980602-1.c @@ -0,0 +1,10 @@ +main() +{ + int i; + for (i = 1; i < 100; i++) + ; + if (i == 100) + exit (0); + abort (); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980602-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/980602-2.c new file mode 100755 index 0000000..8ef2322 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980602-2.c @@ -0,0 +1,11 @@ +struct { + unsigned bit : 30; +} t; + +int main() +{ + if (!(t.bit++)) + exit (0); + else + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980604-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980604-1.c new file mode 100755 index 0000000..8992a90 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980604-1.c @@ -0,0 +1,20 @@ +int a = 1; +int b = -1; + +int c = 1; +int d = 0; + +main () +{ + double e; + double f; + double g; + + f = c; + g = d; + e = (a < b) ? f : g; + if (e) + abort (); + exit(0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980605-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980605-1.c new file mode 100755 index 0000000..2fc2691 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980605-1.c @@ -0,0 +1,78 @@ +#include <stdio.h> + +#ifndef STACK_SIZE +#define STACK_SIZE 200000 +#endif + +__inline__ static int +dummy (x) +{ + int y; + y = (long) (x * 4711.3); + return y; +} + +int getval (void); + +int +f2 (double x) +{ + unsigned short s; + int a, b, c, d, e, f, g, h, i, j; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + + s = x; + + return a + b + c + d + e + f + g + h + i + j + s; +} + +int x = 1; + +int +getval (void) +{ + return x++; +} + +char buf[10]; + +void +f () +{ + char ar[STACK_SIZE/2]; + int a, b, c, d, e, f, g, h, i, j, k; + + a = getval (); + b = getval (); + c = getval (); + d = getval (); + e = getval (); + f = getval (); + g = getval (); + h = getval (); + i = getval (); + j = getval (); + + k = f2 (17.0); + + sprintf (buf, "%d\n", a + b + c + d + e + f + g + h + i + j + k); + if (a + b + c + d + e + f + g + h + i + j + k != 227) + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980608-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980608-1.c new file mode 100755 index 0000000..b34d137 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980608-1.c @@ -0,0 +1,36 @@ +#include <stdarg.h> + +void f1(int a,int b,int c,int d,int e, int f,int g,int h,int i,int j, int k,int +l,int m,int n,int o) +{ + return; +} + +inline void debug(const char *msg,...) +{ + va_list ap; + va_start( ap, msg ); + + f1(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15); + + if ( va_arg(ap,int) != 101) + abort(); + if ( va_arg(ap,int) != 102) + abort(); + if ( va_arg(ap,int) != 103) + abort(); + if ( va_arg(ap,int) != 104) + abort(); + if ( va_arg(ap,int) != 105) + abort(); + if ( va_arg(ap,int) != 106) + abort(); + + va_end( ap ); +} + +int main(void) +{ + debug("%d %d %d %d %d %d\n", 101, 102, 103, 104, 105, 106); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980612-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980612-1.c new file mode 100755 index 0000000..db24387 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980612-1.c @@ -0,0 +1,17 @@ +struct fd +{ + unsigned char a; + unsigned char b; +} f = { 5 }; + +struct fd *g() { return &f; } +int h() { return -1; } + +int main() +{ + struct fd *f = g(); + f->b = h(); + if (((f->a & 0x7f) & ~0x10) <= 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980617-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980617-1.c new file mode 100755 index 0000000..5f7768a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980617-1.c @@ -0,0 +1,14 @@ +void foo (unsigned int * p) +{ + if ((signed char)(*p & 0xFF) == 17 || (signed char)(*p & 0xFF) == 18) + return; + else + abort (); +} + +int main () +{ + int i = 0x30011; + foo(&i); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980618-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980618-1.c new file mode 100755 index 0000000..59db7f2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980618-1.c @@ -0,0 +1,16 @@ +void func(int, int); + +int main() +{ + int x = 7; + func(!x, !7); + exit (0); +} + +void func(int x, int y) +{ + if (x == y) + return; + else + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980618-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/980618-2.c new file mode 100755 index 0000000..c97e19e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980618-2.c @@ -0,0 +1,66 @@ +typedef char CHAR; +typedef short SHORT; +typedef int INT; +typedef long LONG; +typedef float FLOAT; +typedef unsigned char UCHAR; +typedef unsigned short USHORT; +typedef unsigned int UINT; +typedef unsigned long ULONG; +typedef double DOUBLE; +#if __STDC__ +typedef signed char SCHAR; +typedef long double LDOUBLE; +#endif + +int +main () +{ + typedef union + { + CHAR c; + SHORT s; + INT i; + UCHAR uc; + USHORT us; + UINT ui; + LONG l; + ULONG ul; + FLOAT f; + DOUBLE d; +#if __STDC__ + SCHAR sc; + LDOUBLE ld; +#endif + } + D; + auto D D1; + D1.c = 7; + { + auto struct + { + CHAR c; + SHORT s; + INT i; + UCHAR uc; + USHORT us; + UINT ui; + LONG l; + ULONG ul; + FLOAT f; + DOUBLE d; +#if __STDC__ + SCHAR sc; + LDOUBLE ld; +#endif + } + F; + F.c = 7; + if ((D1.c && F.c) != 1) + abort (); + if ((F.c && D1.c) != 1) + abort (); + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980701-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980701-1.c new file mode 100755 index 0000000..391cc0e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980701-1.c @@ -0,0 +1,22 @@ +ns_name_skip (unsigned char **x, unsigned char *y) +{ + *x = 0; + return 0; +} + +unsigned char a[2]; + +int dn_skipname(unsigned char *ptr, unsigned char *eom) { + unsigned char *saveptr = ptr; + + if (ns_name_skip(&ptr, eom) == -1) + return (-1); + return (ptr - saveptr); +} + +main() +{ + if (dn_skipname (&a[0], &a[1]) == 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980707-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980707-1.c new file mode 100755 index 0000000..3af163a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980707-1.c @@ -0,0 +1,46 @@ +#include <stdio.h> +#include <ctype.h> +#include <string.h> + +char ** +buildargv (char *input) +{ + static char *arglist[256]; + int numargs = 0; + + while (1) + { + while (isspace ((unsigned char)*input) && *input != 0) + input++; + if (*input == 0) + break; + arglist [numargs++] = input; + while (!isspace ((unsigned char)*input) && *input != 0) + input++; + if (*input == 0) + break; + *(input++) = 0; + } + arglist [numargs] = NULL; + return arglist; +} + + +int main() +{ + char **args; + char input[256]; + int i; + + strcpy(input, " a b"); + args = buildargv(input); + + if (strcmp (args[0], "a")) + abort (); + if (strcmp (args[1], "b")) + abort (); + if (args[2] != NULL) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980709-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980709-1.c new file mode 100755 index 0000000..cda8076 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980709-1.c @@ -0,0 +1,14 @@ +#include <math.h> + +main() +{ + volatile double a; + double c; + a = 32.0; + c = pow(a, 1.0/3.0); + if (c + 0.1 > 3.174802 + && c - 0.1 < 3.174802) + exit (0); + else + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980716-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980716-1.c new file mode 100755 index 0000000..91e5518 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980716-1.c @@ -0,0 +1,26 @@ +#include <stdarg.h> + +void +stub(int num, ...) +{ + va_list ap; + char *end; + int i; + + for (i = 0; i < 2; i++) { + va_start(ap, num); + while ( 1 ) { + end = va_arg(ap, char *); + if (!end) break; + } + va_end(ap); + } +} + +int +main() +{ + stub(1, "ab", "bc", "cx", 0); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/980929-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/980929-1.c new file mode 100755 index 0000000..1d9246e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/980929-1.c @@ -0,0 +1,21 @@ +void f(int i) +{ + if (i != 1000) + abort (); +} + + +int main() +{ + int n=1000; + int i; + + f(n); + for(i=0; i<1; ++i) { + f(n); + n=666; + &n; + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/981001-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/981001-1.c new file mode 100755 index 0000000..da63f47 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/981001-1.c @@ -0,0 +1,38 @@ +#define NG 0x100L + +unsigned long flg = 0; + +long sub (int n) +{ + int a, b ; + + if (n >= 2) + { + if (n % 2 == 0) + { + a = sub (n / 2); + + return (a + 2 * sub (n / 2 - 1)) * a; + } + else + { + a = sub (n / 2 + 1); + b = sub (n / 2); + + return a * a + b * b; + } + } + else + return (long) n; +} + +int main (void) +{ + if (sub (30) != 832040L) + flg |= NG; + + if (flg) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/981019-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/981019-1.c new file mode 100755 index 0000000..5d1f009 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/981019-1.c @@ -0,0 +1,44 @@ +extern int f2(void); +extern int f3(void); +extern void f1(void); + +void +ff(int fname, int part, int nparts) +{ + if (fname) /* bb 0 */ + { + if (nparts) /* bb 1 */ + f1(); /* bb 2 */ + } + else + fname = 2; /* bb 3 */ + + /* bb 4 is the branch to bb 10 + (bb 10 is physically at the end of the loop) */ + while (f3() /* bb 10 */) + { + if (nparts /* bb 5 */ && f2() /* bb 6 */) + { + f1(); /* bb 7 ... */ + nparts = part; + if (f3()) /* ... bb 7 */ + f1(); /* bb 8 */ + f1(); /* bb 9 */ + break; + } + } + + if (nparts) /* bb 11 */ + f1(); /* bb 12 */ + return; /* bb 13 */ +} + +int main(void) +{ + ff(0, 1, 0); + return 0; +} + +int f3(void) { static int x = 0; x = !x; return x; } +void f1(void) { abort(); } +int f2(void) { abort(); } diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.c new file mode 100755 index 0000000..72630b0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.c @@ -0,0 +1,30 @@ +struct s { int a; int b;}; +struct s s1; +struct s s2 = { 1, 2, }; + +void +check (a, b) + int a; + int b; +{ + if (a == b) + exit (0); + else + abort (); +} + +int +main () +{ + int * p; + int x; + + s1.a = 9; + p = & s1.a; + s1 = s2; + x = * p; + + check (x, 1); +} + + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.x new file mode 100755 index 0000000..1565c68 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/981130-1.x @@ -0,0 +1,22 @@ +# This test is known to fail on targets that use the instruction scheduler +# at optimisation levels of 2 or more because the alias analysis is confused +# by the reassignment of a variable structure to a fixed structure. The +# failure could be suppressed by preventing instruction scheduling: +# +# set additional_flags "-fno-schedule-insns2"; +# +# but this would disguise the fact that there is a problem. Instead we use +# we generate an xfail result and explain that it is alias analysis that +# is at fault. + +set torture_eval_before_execute { + + set compiler_conditional_xfail_data { + "alias analysis conflicts with instruction scheduling" \ + "m32r-*-*" \ + { "-O2" "-O1" "-O0" "-Os"} \ + { "" } + } +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/981206-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/981206-1.c new file mode 100755 index 0000000..12ec0ab --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/981206-1.c @@ -0,0 +1,17 @@ +/* Verify unaligned address aliasing on Alpha EV[45]. */ + +static unsigned short x, y; + +void foo() +{ + x = 0x345; + y = 0x567; +} + +int main() +{ + foo (); + if (x != 0x345 || y != 0x567) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/990106-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/990106-1.c new file mode 100755 index 0000000..6631bfd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/990106-1.c @@ -0,0 +1,16 @@ +foo(bufp) +char *bufp; +{ + int x = 80; + return (*bufp++ = x ? 'a' : 'b'); +} + +main() +{ + char x; + + if (foo (&x) != 'a') + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/990106-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/990106-2.c new file mode 100755 index 0000000..b057dfd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/990106-2.c @@ -0,0 +1,21 @@ +unsigned calc_mp(unsigned mod) +{ + unsigned a,b,c; + c=-1; + a=c/mod; + b=0-a*mod; + if (b > mod) { a += 1; b-=mod; } + return b; +} + +int main(int argc, char *argv[]) +{ + unsigned x = 1234; + unsigned y = calc_mp(x); + + if (y != 680) + abort (); + exit (0); +} + + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/990127-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/990127-1.c new file mode 100755 index 0000000..c495848 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/990127-1.c @@ -0,0 +1,31 @@ +main() +{ + int a,b,c; + int *pa, *pb, *pc; + int **ppa, **ppb, **ppc; + int i,j,k,x,y,z; + + a = 10; + b = 20; + c = 30; + pa = &a; pb = &b; pc = &c; + ppa = &pa; ppb = &pb; ppc = &pc; + x = 0; y = 0; z = 0; + + for(i=0;i<10;i++){ + if( pa == &a ) pa = &b; + else pa = &a; + while( (*pa)-- ){ + x++; + if( (*pa) < 3 ) break; + else pa = &b; + } + x++; + pa = &b; + } + + if ((*pa) != -5 || (*pb) != -5 || x != 43) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/990127-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/990127-2.c new file mode 100755 index 0000000..0d0f495 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/990127-2.c @@ -0,0 +1,20 @@ +void +fpEq (double x, double y) +{ + if (x != y) + abort (); +} + +void +fpTest (double x, double y) +{ + double result1 = (35.7 * 100.0) / 45.0; + double result2 = (x * 100.0) / y; + fpEq (result1, result2); +} + +main () +{ + fpTest (35.7, 45.0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/990128-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/990128-1.c new file mode 100755 index 0000000..cfdab3e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/990128-1.c @@ -0,0 +1,50 @@ +extern int printf (const char *,...); + +struct s { struct s *n; } *p; +struct s ss; +#define MAX 10 +struct s sss[MAX]; +int count = 0; + +void sub( struct s *p, struct s **pp ); +int look( struct s *p, struct s **pp ); + +main() +{ + struct s *pp; + struct s *next; + int i; + + p = &ss; + next = p; + for ( i = 0; i < MAX; i++ ) { + next->n = &sss[i]; + next = next->n; + } + next->n = 0; + + sub( p, &pp ); + if (count != MAX+2) + abort (); + + exit( 0 ); +} + +void sub( struct s *p, struct s **pp ) +{ + for ( ; look( p, pp ); ) { + if ( p ) + p = p->n; + else + break; + } +} + +int look( struct s *p, struct s **pp ) +{ + for ( ; p; p = p->n ) + ; + *pp = p; + count++; + return( 1 ); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/execute/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/arith-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/arith-1.c new file mode 100755 index 0000000..58df322 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/arith-1.c @@ -0,0 +1,15 @@ +unsigned +sat_add (unsigned i) +{ + unsigned ret = i + 1; + if (ret < i) + ret = i; + return ret; +} + +main () +{ + if (sat_add (~0U) != ~0U) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/arith-rand.c b/gcc_arm/testsuite/gcc.c-torture/execute/arith-rand.c new file mode 100755 index 0000000..4af146a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/arith-rand.c @@ -0,0 +1,114 @@ +long +simple_rand () +{ + static unsigned long seed = 47114711; + unsigned long this = seed * 1103515245 + 12345; + seed = this; + return this >> 8; +} + +unsigned long int +random_bitstring () +{ + unsigned long int x; + int n_bits; + long ran; + int tot_bits = 0; + + x = 0; + for (;;) + { + ran = simple_rand (); + n_bits = (ran >> 1) % 16; + tot_bits += n_bits; + + if (n_bits == 0) + return x; + else + { + x <<= n_bits; + if (ran & 1) + x |= (1 << n_bits) - 1; + + if (tot_bits > 8 * sizeof (long) + 6) + return x; + } + } +} + +#define ABS(x) ((x) >= 0 ? (x) : -(x)) + +main () +{ + long int i; + + for (i = 0; i < 1000; i++) + { + unsigned long x, y; + x = random_bitstring (); + y = random_bitstring (); + + if (sizeof (int) == sizeof (long)) + goto save_time; + + { unsigned long xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed long xx = x, yy = y, r1, r2; + if ((unsigned long) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned long) ABS (yy) || (signed long) (r1 * yy + r2) != xx) + abort (); + } + save_time: + { unsigned int xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed int xx = x, yy = y, r1, r2; + if ((unsigned int) xx << 1 == 0 && yy == -1) + continue; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned int) ABS (yy) || (signed int) (r1 * yy + r2) != xx) + abort (); + } + { unsigned short xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed short xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned short) ABS (yy) || (signed short) (r1 * yy + r2) != xx) + abort (); + } + { unsigned char xx = x, yy = y, r1, r2; + if (yy == 0) continue; + r1 = xx / yy; + r2 = xx % yy; + if (r2 >= yy || r1 * yy + r2 != xx) + abort (); + } + { signed char xx = x, yy = y, r1, r2; + r1 = xx / yy; + r2 = xx % yy; + if (ABS (r2) >= (unsigned char) ABS (yy) || (signed char) (r1 * yy + r2) != xx) + abort (); + } + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.c new file mode 100755 index 0000000..38b1d3e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.c @@ -0,0 +1,90 @@ +int global; + +/* These must fail. */ +int bad0(void) { return __builtin_constant_p(global); } +int bad1(void) { return __builtin_constant_p(global++); } +inline int bad2(int x) { return __builtin_constant_p(x++); } +inline int bad3(int x) { return __builtin_constant_p(x); } +inline int bad4(const char *x) { return __builtin_constant_p(x); } +int bad5(void) { return bad2(1); } +inline int bad6(int x) { return __builtin_constant_p(x+1); } +int bad7(void) { return __builtin_constant_p(abort()); } +int bad8(void) { char buf[10]; return __builtin_constant_p(buf); } +int bad9(const char *x) { return __builtin_constant_p(x[123456]); } +int bad10(void) { return __builtin_constant_p(&global); } + +/* These must pass, or we've broken gcc2 functionality. */ +int good0(void) { return __builtin_constant_p(1); } +int good1(void) { return __builtin_constant_p("hi"); } +int good2(void) { return __builtin_constant_p((1234 + 45) & ~7); } + +/* These are extensions to gcc2. Failure indicates an optimization + regression. */ +int opt0(void) { return bad3(1); } +int opt1(void) { return bad6(1); } +int opt2(void) { return __builtin_constant_p("hi"[0]); } + +/* + * Opt3 is known to fail. It is one of the important cases that glibc + * was interested in though, so keep this around as a reminder. + * + * The solution is to add bits to recover bytes from constant pool + * elements given nothing but a constant pool label and an offset. + * When we can do that, and we can simplify strlen after the fact, + * then we can enable recognition of constant pool labels as constants. + */ + +/* int opt3(void) { return bad4("hi"); } */ + + +/* Call through tables so -finline-functions can't screw with us. */ +int (*bad_t0[])(void) = { + bad0, bad1, bad5, bad7, bad8, bad10 +}; + +int (*bad_t1[])(int x) = { + bad2, bad3, bad6 +}; + +int (*bad_t2[])(const char *x) = { + bad4, bad9 +}; + +int (*good_t0[])(void) = { + good0, good1, good2 +}; + +int (*opt_t0[])(void) = { + opt0, opt1, opt2 /* , opt3 */ +}; + +#define N(arr) (sizeof(arr)/sizeof(*arr)) + +int main() +{ + int i; + + for (i = 0; i < N(bad_t0); ++i) + if ((*bad_t0[i])()) + abort(); + + for (i = 0; i < N(bad_t1); ++i) + if ((*bad_t1[i])(1)) + abort(); + + for (i = 0; i < N(bad_t2); ++i) + if ((*bad_t2[i])("hi")) + abort(); + + for (i = 0; i < N(good_t0); ++i) + if (! (*good_t0[i])()) + abort(); + +#ifdef __OPTIMIZE__ + for (i = 0; i < N(opt_t0); ++i) + if (! (*opt_t0[i])()) + abort(); +#endif + + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.x new file mode 100755 index 0000000..2f0be4f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bcp-1.x @@ -0,0 +1,11 @@ +set torture_eval_before_compile { + + set compiler_conditional_xfail_data { + "Bogus label refernce in debugging output" + "arm-*-* thumb-*-*" \ + {"-O2 -g" ""} \ + {"" } + } +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bf-layout-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/bf-layout-1.c new file mode 100755 index 0000000..a82429b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bf-layout-1.c @@ -0,0 +1,9 @@ +struct { long f8:8; long f24:24; } a; +struct { long f32:32; } b; + +main () +{ + if (sizeof (a) != sizeof (b)) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bf-pack-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/bf-pack-1.c new file mode 100755 index 0000000..ca3b1db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bf-pack-1.c @@ -0,0 +1,23 @@ +struct foo +{ + unsigned half:16; + unsigned long whole:32 __attribute__ ((packed)); +}; + +f (struct foo *q) +{ + if (q->half != 0x1234) + abort (); + if (q->whole != 0x56789abcL) + abort (); +} + +main () +{ + struct foo bar; + + bar.half = 0x1234; + bar.whole = 0x56789abcL; + f (&bar); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-1.c new file mode 100755 index 0000000..3cc3eac --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-1.c @@ -0,0 +1,18 @@ +main () +{ + struct { + signed int s:3; + unsigned int u:3; + int i:3; + } x = {-1, -1, -1}; + + if (x.u != 7) + abort (); + if (x.s != - 1) + abort (); + + if (x.i != -1 && x.i != 7) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-2.c new file mode 100755 index 0000000..365e061 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bf-sign-2.c @@ -0,0 +1,64 @@ +/* + This test checks promotion of bitfields. Bitfields should be promoted + very much like chars and shorts: + + Bitfields (signed or unsigned) should be promoted to signed int if their + value will fit in a signed int, otherwise to an unsigned int if their + value will fit in an unsigned int, otherwise we don't promote them (ANSI/ISO + does not specify the behavior of bitfields larger than an unsigned int). + + We test the behavior by subtracting two from the promoted value: this will + result in a negitive value for signed types, a positive value for unsigned + types. This test (of course) assumes that the compiler is correctly + implementing signed and unsigned arithmetic. + */ + +struct X { + unsigned int u3:3; + long int s31:31; + long int s32:32; + unsigned long int u31:31; + unsigned long int u32:32; + unsigned long long ull3 :3; + unsigned long long ull35:35; + unsigned u15:15; +}; + +struct X x; + +main () +{ + if ((x.u3 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.s31 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.s32 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.u15 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if (sizeof (struct { unsigned long u32:32;}) <= sizeof (int)) + { + if ((x.u31 - 2) >= 0) /* promoted value should be signed */ + abort (); + } + else + { + if ((x.u31 - 2) < 0) /* promoted value should be UNsigned */ + abort (); + } + + if ((x.u32 - 2) < 0) /* promoted value should be UNsigned */ + abort (); + + if ((x.ull3 - 2) >= 0) /* promoted value should be signed */ + abort (); + + if ((x.ull35 - 2) < 0) /* promoted value should be UNsigned */ + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/bf64-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/bf64-1.c new file mode 100755 index 0000000..60028fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/bf64-1.c @@ -0,0 +1,40 @@ +struct tmp +{ + long long int pad : 12; + long long int field : 52; +}; + +struct tmp2 +{ + long long int field : 52; + long long int pad : 12; +}; + +struct tmp +sub (struct tmp tmp) +{ + tmp.field |= 0x0008765412345678LL; + return tmp; +} + +struct tmp2 +sub2 (struct tmp2 tmp2) +{ + tmp2.field |= 0x0008765412345678LL; + return tmp2; +} + +main() +{ + struct tmp tmp = {0x123, 0xFFF000FFF000FLL}; + struct tmp2 tmp2 = {0xFFF000FFF000FLL, 0x123}; + + tmp = sub (tmp); + tmp2 = sub2 (tmp2); + + if (tmp.pad != 0x123 || tmp.field != 0xFFFFFF541FFF567FLL) + abort (); + if (tmp2.pad != 0x123 || tmp2.field != 0xFFFFFF541FFF567FLL) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/cbrt.c b/gcc_arm/testsuite/gcc.c-torture/execute/cbrt.c new file mode 100755 index 0000000..8659cc7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/cbrt.c @@ -0,0 +1,92 @@ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== +*/ + +#ifndef __vax__ +static const unsigned long + B1 = 715094163, /* B1 = (682-0.03306235651)*2**20 */ + B2 = 696219795; /* B2 = (664-0.03306235651)*2**20 */ + +static const double + C = 5.42857142857142815906e-01, /* 19/35 = 0x3FE15F15, 0xF15F15F1 */ + D = -7.05306122448979611050e-01, /* -864/1225 = 0xBFE691DE, 0x2532C834 */ + E = 1.41428571428571436819e+00, /* 99/70 = 0x3FF6A0EA, 0x0EA0EA0F */ + F = 1.60714285714285720630e+00, /* 45/28 = 0x3FF9B6DB, 0x6DB6DB6E */ + G = 3.57142857142857150787e-01; /* 5/14 = 0x3FD6DB6D, 0xB6DB6DB7 */ + +double +cbrtl (double x) +{ + long hx; + double r,s,w; + double lt; + unsigned sign; + typedef unsigned unsigned32 __attribute__((mode(SI))); + union { + double t; + unsigned32 pt[2]; + } ut, ux; + int n0; + + ut.t = 1.0; + n0 = (ut.pt[0] == 0); + + ut.t = 0.0; + ux.t = x; + + hx = ux.pt[n0]; /* high word of x */ + sign=hx&0x80000000; /* sign= sign(x) */ + hx ^=sign; + if(hx>=0x7ff00000) return(x+x); /* cbrt(NaN,INF) is itself */ + if((hx| ux.pt[1-n0])==0) + return(ux.t); /* cbrt(0) is itself */ + + ux.pt[n0] = hx; + /* rough cbrt to 5 bits */ + if(hx<0x00100000) /* subnormal number */ + {ut.pt[n0]=0x43500000; /* set t= 2**54 */ + ut.t*=x; ut.pt[n0]=ut.pt[n0]/3+B2; + } + else + ut.pt[n0]=hx/3+B1; + + /* new cbrt to 23 bits, may be implemented in single precision */ + r=ut.t*ut.t/ux.t; + s=C+r*ut.t; + ut.t*=G+F/(s+E+D/s); + + /* chopped to 20 bits and make it larger than cbrt(x) */ + ut.pt[1-n0]=0; ut.pt[n0]+=0x00000001; + + /* one step newton iteration to 53 bits with error less than 0.667 ulps */ + s=ut.t*ut.t; /* t*t is exact */ + r=ux.t/s; + w=ut.t+ut.t; + r=(r-ut.t)/(w+r); /* r-s is exact */ + ut.t=ut.t+ut.t*r; + + /* restore the sign bit */ + ut.pt[n0] |= sign; + + lt = ut.t; + lt -= (lt - (x/(lt*lt))) * 0.333333333333333333333; + return lt; +} + +main () +{ + if ((int) (cbrtl (27.0) + 0.5) != 3) + abort (); + + exit (0); +} +#else +main () { exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/cmpdi-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/cmpdi-1.c new file mode 100755 index 0000000..e3e9c86 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/cmpdi-1.c @@ -0,0 +1,218 @@ +#define F 140 +#define T 13 + +feq (x, y) + long long int x; + long long int y; +{ + if (x == y) + return T; + else + return F; +} + +fne (x, y) + long long int x; + long long int y; +{ + if (x != y) + return T; + else + return F; +} + +flt (x, y) + long long int x; + long long int y; +{ + if (x < y) + return T; + else + return F; +} + +fge (x, y) + long long int x; + long long int y; +{ + if (x >= y) + return T; + else + return F; +} + +fgt (x, y) + long long int x; + long long int y; +{ + if (x > y) + return T; + else + return F; +} + +fle (x, y) + long long int x; + long long int y; +{ + if (x <= y) + return T; + else + return F; +} + +fltu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x < y) + return T; + else + return F; +} + +fgeu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x >= y) + return T; + else + return F; +} + +fgtu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x > y) + return T; + else + return F; +} + +fleu (x, y) + unsigned long long int x; + unsigned long long int y; +{ + if (x <= y) + return T; + else + return F; +} + +long long args[] = +{ + 0LL, + 1LL, + -1LL, + 0x7fffffffffffffffLL, + 0x8000000000000000LL, + 0x8000000000000001LL, + 0x1A3F237394D36C58LL, + 0x93850E92CAAC1B04LL +}; + +int correct_results[] = +{ + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + T, F, F, T, F, T, F, T, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, F, T, T, F, T, F, F, T, + T, F, F, T, F, T, F, T, F, T, + F, T, F, T, T, F, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + F, T, T, F, F, T, T, F, F, T, + F, T, T, F, F, T, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, F, T, T, F, F, T, T, F, + F, T, T, F, F, T, F, T, T, F, + T, F, F, T, F, T, F, T, F, T +}; + +main () +{ + int i, j, *res = correct_results; + + for (i = 0; i < 8; i++) + { + long long arg0 = args[i]; + for (j = 0; j < 8; j++) + { + long long arg1 = args[j]; + + if (feq (arg0, arg1) != *res++) + abort (); + if (fne (arg0, arg1) != *res++) + abort (); + if (flt (arg0, arg1) != *res++) + abort (); + if (fge (arg0, arg1) != *res++) + abort (); + if (fgt (arg0, arg1) != *res++) + abort (); + if (fle (arg0, arg1) != *res++) + abort (); + if (fltu (arg0, arg1) != *res++) + abort (); + if (fgeu (arg0, arg1) != *res++) + abort (); + if (fgtu (arg0, arg1) != *res++) + abort (); + if (fleu (arg0, arg1) != *res++) + abort (); + } + } + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/cmpsi-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/cmpsi-1.c new file mode 100755 index 0000000..9fce104 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/cmpsi-1.c @@ -0,0 +1,32 @@ +f1 (unsigned int x, unsigned int y) +{ + if (x == 0) + dummy (); + x -= y; + /* 0xfffffff2 < 0x80000000? */ + if (x < ~(~(unsigned int) 0 >> 1)) + abort (); + return x; +} + +f2 (unsigned long int x, unsigned long int y) +{ + if (x == 0) + dummy (); + x -= y; + /* 0xfffffff2 < 0x80000000? */ + if (x < ~(~(unsigned long int) 0 >> 1)) + abort (); + return x; +} + + +dummy () {} + +main () +{ + /* 0x7ffffff3 0x80000001 */ + f1 ((~(unsigned int) 0 >> 1) - 12, ~(~(unsigned int) 0 >> 1) + 1); + f2 ((~(unsigned long int) 0 >> 1) - 12, ~(~(unsigned long int) 0 >> 1) + 1); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.c new file mode 100755 index 0000000..f9f6c12 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.c @@ -0,0 +1,164 @@ +#include <stdlib.h> + +#ifndef NO_LABEL_VALUES +typedef unsigned int uint32; +typedef signed int sint32; + +typedef uint32 reg_t; + +typedef unsigned long int host_addr_t; +typedef uint32 target_addr_t; +typedef sint32 target_saddr_t; + +typedef union +{ + struct + { + unsigned int offset:18; + unsigned int ignore:4; + unsigned int s1:8; + int :2; + signed int simm:14; + unsigned int s3:8; + unsigned int s2:8; + int pad2:2; + } f1; + long long ll; + double d; +} insn_t; + +typedef struct +{ + target_addr_t vaddr_tag; + unsigned long int rigged_paddr; +} tlb_entry_t; + +typedef struct +{ + insn_t *pc; + reg_t registers[256]; + insn_t *program; + tlb_entry_t tlb_tab[0x100]; +} environment_t; + +enum operations +{ + LOAD32_RR, + METAOP_DONE +}; + +host_addr_t +f () +{ + abort (); +} + +reg_t +simulator_kernel (int what, environment_t *env) +{ + register insn_t *pc = env->pc; + register reg_t *regs = env->registers; + register insn_t insn; + register int s1; + register reg_t r2; + register void *base_addr = &&sim_base_addr; + register tlb_entry_t *tlb = env->tlb_tab; + + if (what != 0) + { + int i; + static void *op_map[] = + { + &&L_LOAD32_RR, + &&L_METAOP_DONE, + }; + insn_t *program = env->program; + for (i = 0; i < what; i++) + program[i].f1.offset = op_map[program[i].f1.offset] - base_addr; + } + + sim_base_addr:; + + insn = *pc++; + r2 = (*(reg_t *) (((char *) regs) + (insn.f1.s2 << 2))); + s1 = (insn.f1.s1 << 2); + goto *(base_addr + insn.f1.offset); + + L_LOAD32_RR: + { + target_addr_t vaddr_page = r2 / 4096; + unsigned int x = vaddr_page % 0x100; + insn = *pc++; + + for (;;) + { + target_addr_t tag = tlb[x].vaddr_tag; + host_addr_t rigged_paddr = tlb[x].rigged_paddr; + + if (tag == vaddr_page) + { + *(reg_t *) (((char *) regs) + s1) = *(uint32 *) (rigged_paddr + r2); + r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2)); + s1 = insn.f1.s1 << 2; + goto *(base_addr + insn.f1.offset); + } + + if (((target_saddr_t) tag < 0)) + { + *(reg_t *) (((char *) regs) + s1) = *(uint32 *) f (); + r2 = *(reg_t *) (((char *) regs) + (insn.f1.s2 << 2)); + s1 = insn.f1.s1 << 2; + goto *(base_addr + insn.f1.offset); + } + + x = (x - 1) % 0x100; + } + + L_METAOP_DONE: + return (*(reg_t *) (((char *) regs) + s1)); + } +} + +insn_t program[2 + 1]; + +void *malloc (); + +int +main () +{ + environment_t env; + insn_t insn; + int i, res; + host_addr_t a_page = (host_addr_t) malloc (2 * 4096); + target_addr_t a_vaddr = 0x123450; + target_addr_t vaddr_page = a_vaddr / 4096; + a_page = (a_page + 4096 - 1) & -4096; + + env.tlb_tab[((vaddr_page) % 0x100)].vaddr_tag = vaddr_page; + env.tlb_tab[((vaddr_page) % 0x100)].rigged_paddr = a_page - vaddr_page * 4096; + insn.f1.offset = LOAD32_RR; + env.registers[0] = 0; + env.registers[2] = a_vaddr; + *(int *) (a_page + a_vaddr % 4096) = 88; + insn.f1.s1 = 0; + insn.f1.s2 = 2; + + for (i = 0; i < 2; i++) + program[i] = insn; + + insn.f1.offset = METAOP_DONE; + insn.f1.s1 = 0; + program[2] = insn; + + env.pc = program; + env.program = program; + + res = simulator_kernel (2 + 1, &env); + + if (res != 88) + abort (); + exit (0); +} +#else +main(){ exit (0); } +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.x new file mode 100755 index 0000000..2f0be4f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/comp-goto-1.x @@ -0,0 +1,11 @@ +set torture_eval_before_compile { + + set compiler_conditional_xfail_data { + "Bogus label refernce in debugging output" + "arm-*-* thumb-*-*" \ + {"-O2 -g" ""} \ + {"" } + } +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/complex-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/complex-1.c new file mode 100755 index 0000000..424fa65 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/complex-1.c @@ -0,0 +1,40 @@ +double +g0 (double x) +{ + return 1.0; +} + +double +g1 (double x) +{ + return -1.0; +} + +double +g2 (double x) +{ + return 0.0; +} + +__complex__ double +cexp (__complex__ double x) +{ + double r; + + r = g0 (__real__ x); + __real__ x = r * g1 (__imag__ x); + __imag__ x = r * g2 (__imag__ x); + return x; +} + +main () +{ + __complex__ double x; + + x = cexp (1.0i); + if (__real__ x != -1.0) + abort (); + if (__imag__ x != 0.0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/complex-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/complex-2.c new file mode 100755 index 0000000..9634c79 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/complex-2.c @@ -0,0 +1,27 @@ +__complex__ double +f (__complex__ double x, __complex__ double y) +{ + x += y; + return x; +} + +__complex__ double ag = 1.0 + 1.0i; +__complex__ double bg = -2.0 + 2.0i; + +main () +{ + __complex__ double a, b, c; + + a = ag; + b = -2.0 + 2.0i; + c = f (a, b); + + if (a != 1.0 + 1.0i) + abort (); + if (b != -2.0 + 2.0i) + abort (); + if (c != -1.0 + 3.0i) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/complex-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/complex-3.c new file mode 100755 index 0000000..4297cf1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/complex-3.c @@ -0,0 +1,25 @@ +struct complex +{ + float r; + float i; +}; + +struct complex cmplx (float, float); + +struct complex +f (float a, float b) +{ + struct complex c; + c.r = a; + c.i = b; + return c; +} + +main () +{ + struct complex z = f (1.0, 0.0); + + if (z.r != 1.0 || z.i != 0.0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/complex-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/complex-4.c new file mode 100755 index 0000000..1c458d2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/complex-4.c @@ -0,0 +1,9 @@ +main () +{ + if ((__complex__ double) 0.0 != (__complex__ double) (-0.0)) + abort (); + + if (0.0 != -0.0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/complex-5.c b/gcc_arm/testsuite/gcc.c-torture/execute/complex-5.c new file mode 100755 index 0000000..a333808 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/complex-5.c @@ -0,0 +1,20 @@ +float __complex__ +p (float __complex__ a, float __complex__ b) +{ + return a + b; +} + +float __complex__ x = 1.0 + 14.0 * (1.0fi); +float __complex__ y = 7.0 + 5.0 * (1.0fi); +float __complex__ w = 8.0 + 19.0 * (1.0fi); +float __complex__ z; + +main () +{ + + z = p (x,y); + y = p (x, 1.0f / z); + if (z != w) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/compndlit-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/compndlit-1.c new file mode 100755 index 0000000..4a8488d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/compndlit-1.c @@ -0,0 +1,15 @@ +struct S +{ + int a:3; + unsigned b:1, c:28; +}; + +struct S x = {1, 1, 1}; + +main () +{ + x = (struct S) {b:0, a:0, c:({ struct S o = x; o.a == 1 ? 10 : 20;})}; + if (x.c != 10) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/configure.in b/gcc_arm/testsuite/gcc.c-torture/execute/configure.in new file mode 100755 index 0000000..7d7078d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=execute.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/conversion.c b/gcc_arm/testsuite/gcc.c-torture/execute/conversion.c new file mode 100755 index 0000000..fc69d62 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/conversion.c @@ -0,0 +1,380 @@ +/* Test front-end conversions, optimizer conversions, and run-time + conversions between different arithmetic types. + + Constants are specified in a non-obvious way to make them work for + any word size. Their value on a 32-bit machine is indicated in the + comments. + + Note that this code is NOT intended for testing of accuracy of fp + conversions. */ + +float +u2f(u) + unsigned int u; +{ + return u; +} + +double +u2d(u) + unsigned int u; +{ + return u; +} + +float +s2f(s) + int s; +{ + return s; +} + +double +s2d(s) + int s; +{ + return s; +} + +int +fnear (float x, float y) +{ + float t = x - y; + return t == 0 || x / t > 1000000.0; +} + +int +dnear (double x, double y) +{ + double t = x - y; + return t == 0 || x / t > 100000000000000.0; +} + +test_integer_to_float() +{ + if (u2f(0U) != (float) 0U) /* 0 */ + abort(); + if (!fnear (u2f(~0U), (float) ~0U)) /* 0xffffffff */ + abort(); + if (!fnear (u2f((~0U) >> 1), (float) ((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (u2f(~((~0U) >> 1)) != (float) ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (u2d(0U) != (double) 0U) /* 0 */ + abort(); + if (!dnear (u2d(~0U), (double) ~0U)) /* 0xffffffff */ + abort(); + if (!dnear (u2d((~0U) >> 1),(double) ((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (u2d(~((~0U) >> 1)) != (double) ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (s2f(0) != (float) 0) /* 0 */ + abort(); + if (!fnear (s2f(~0), (float) ~0)) /* 0xffffffff */ + abort(); + if (!fnear (s2f((int)((~0U) >> 1)), (float)(int)((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (s2f((int)(~((~0U) >> 1))) != (float)(int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + if (s2d(0) != (double) 0) /* 0 */ + abort(); + if (!dnear (s2d(~0), (double) ~0)) /* 0xffffffff */ + abort(); + if (!dnear (s2d((int)((~0U) >> 1)), (double)(int)((~0U) >> 1))) /* 0x7fffffff */ + abort(); + if (s2d((int)~((~0U) >> 1)) != (double)(int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); +} + +#if __GNUC__ +float +ull2f(u) + unsigned long long int u; +{ + return u; +} + +double +ull2d(u) + unsigned long long int u; +{ + return u; +} + +float +sll2f(s) + long long int s; +{ + return s; +} + +double +sll2d(s) + long long int s; +{ + return s; +} + +test_longlong_integer_to_float() +{ + if (ull2f(0ULL) != (float) 0ULL) /* 0 */ + abort(); + if (ull2f(~0ULL) != (float) ~0ULL) /* 0xffffffff */ + abort(); + if (ull2f((~0ULL) >> 1) != (float) ((~0ULL) >> 1)) /* 0x7fffffff */ + abort(); + if (ull2f(~((~0ULL) >> 1)) != (float) ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (ull2d(0ULL) != (double) 0ULL) /* 0 */ + abort(); +#if __HAVE_68881__ + /* Some 68881 targets return values in fp0, with excess precision. + But the compile-time conversion to double works correctly. */ + if (! dnear (ull2d(~0ULL), (double) ~0ULL)) /* 0xffffffff */ + abort(); + if (! dnear (ull2d((~0ULL) >> 1), (double) ((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); +#else + if (ull2d(~0ULL) != (double) ~0ULL) /* 0xffffffff */ + abort(); + if (ull2d((~0ULL) >> 1) != (double) ((~0ULL) >> 1)) /* 0x7fffffff */ + abort(); +#endif + if (ull2d(~((~0ULL) >> 1)) != (double) ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (sll2f(0LL) != (float) 0LL) /* 0 */ + abort(); + if (sll2f(~0LL) != (float) ~0LL) /* 0xffffffff */ + abort(); + if (! fnear (sll2f((long long int)((~0ULL) >> 1)), (float)(long long int)((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); + if (sll2f((long long int)(~((~0ULL) >> 1))) != (float)(long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (sll2d(0LL) != (double) 0LL) /* 0 */ + abort(); + if (sll2d(~0LL) != (double) ~0LL) /* 0xffffffff */ + abort(); + if (!dnear (sll2d((long long int)((~0ULL) >> 1)), (double)(long long int)((~0ULL) >> 1))) /* 0x7fffffff */ + abort(); + if (! dnear (sll2d((long long int)~((~0ULL) >> 1)), (double)(long long int)~((~0ULL) >> 1))) /* 0x80000000 */ + abort(); +} +#endif + +unsigned int +f2u(float f) +{ + return (unsigned) f; +} + +unsigned int +d2u(double d) +{ + return (unsigned) d; +} + +int +f2s(float f) +{ + return (int) f; +} + +int +d2s(double d) +{ + return (int) d; +} + +test_float_to_integer() +{ + if (f2u(0.0) != 0) + abort(); + if (f2u(0.999) != 0) + abort(); + if (f2u(1.0) != 1) + abort(); + if (f2u(1.99) != 1) + abort(); + if (f2u((float) ((~0U) >> 1)) != (~0U) >> 1 && /* 0x7fffffff */ + f2u((float) ((~0U) >> 1)) != ((~0U) >> 1) + 1) + abort(); + if (f2u((float) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + /* CYGNUS LOCAL -- amylaar/32bit doubles */ + /* These tests require double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (double) >= 8) { + /* END CYGNUS LOCAL -- amylaar/32bit doubles */ + if (d2u(0.0) != 0) + abort(); + if (d2u(0.999) != 0) + abort(); + if (d2u(1.0) != 1) + abort(); + if (d2u(1.99) != 1) + abort(); + if (d2u((double) (~0U)) != ~0U) /* 0xffffffff */ + abort(); + if (d2u((double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (d2u((double) ~((~0U) >> 1)) != ~((~0U) >> 1)) /* 0x80000000 */ + abort(); + /* CYGNUS LOCAL -- amylaar/32bit doubles */ + } + /* END CYGNUS LOCAL -- amylaar/32bit doubles */ + + + if (f2s(0.0) != 0) + abort(); + if (f2s(0.999) != 0) + abort(); + if (f2s(1.0) != 1) + abort(); + if (f2s(1.99) != 1) + abort(); + if (f2s(-0.999) != 0) + abort(); + if (f2s(-1.0) != -1) + abort(); + if (f2s(-1.99) != -1) + abort(); + if (f2s((float)(int)~((~0U) >> 1)) != (int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + + /* CYGNUS LOCAL -- amylaar/32bit doubles */ + /* These tests require double precision, so for hosts that don't offer + that much precision, just ignore these test. */ + if (sizeof (double) >= 8) { + /* END CYGNUS LOCAL -- amylaar/32bit doubles */ + if (d2s(0.0) != 0) + abort(); + if (d2s(0.999) != 0) + abort(); + if (d2s(1.0) != 1) + abort(); + if (d2s(1.99) != 1) + abort(); + if (d2s(-0.999) != 0) + abort(); + if (d2s(-1.0) != -1) + abort(); + if (d2s(-1.99) != -1) + abort(); + if (d2s((double) ((~0U) >> 1)) != (~0U) >> 1) /* 0x7fffffff */ + abort(); + if (d2s((double)(int)~((~0U) >> 1)) != (int)~((~0U) >> 1)) /* 0x80000000 */ + abort(); + /* CYGNUS LOCAL -- amylaar/32bit doubles */ + } + /* END CYGNUS LOCAL -- amylaar/32bit doubles */ +} + +#if __GNUC__ +unsigned long long int +f2ull(float f) +{ + return (unsigned long long int) f; +} + +unsigned long long int +d2ull(double d) +{ + return (unsigned long long int) d; +} + +long long int +f2sll(float f) +{ + return (long long int) f; +} + +long long int +d2sll(double d) +{ + return (long long int) d; +} + +test_float_to_longlong_integer() +{ + if (f2ull(0.0) != 0LL) + abort(); + if (f2ull(0.999) != 0LL) + abort(); + if (f2ull(1.0) != 1LL) + abort(); + if (f2ull(1.99) != 1LL) + abort(); + if (f2ull((float) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ + f2ull((float) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) + abort(); + if (f2ull((float) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (d2ull(0.0) != 0LL) + abort(); + if (d2ull(0.999) != 0LL) + abort(); + if (d2ull(1.0) != 1LL) + abort(); + if (d2ull(1.99) != 1LL) + abort(); + if (d2ull((double) ((~0ULL) >> 1)) != (~0ULL) >> 1 && /* 0x7fffffff */ + d2ull((double) ((~0ULL) >> 1)) != ((~0ULL) >> 1) + 1) + abort(); + if (d2ull((double) ~((~0ULL) >> 1)) != ~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + + if (f2sll(0.0) != 0LL) + abort(); + if (f2sll(0.999) != 0LL) + abort(); + if (f2sll(1.0) != 1LL) + abort(); + if (f2sll(1.99) != 1LL) + abort(); + if (f2sll(-0.999) != 0LL) + abort(); + if (f2sll(-1.0) != -1LL) + abort(); + if (f2sll(-1.99) != -1LL) + abort(); + if (f2sll((float)(long long int)~((~0ULL) >> 1)) != (long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); + + if (d2sll(0.0) != 0LL) + abort(); + if (d2sll(0.999) != 0LL) + abort(); + if (d2sll(1.0) != 1LL) + abort(); + if (d2sll(1.99) != 1LL) + abort(); + if (d2sll(-0.999) != 0LL) + abort(); + if (d2sll(-1.0) != -1LL) + abort(); + if (d2sll(-1.99) != -1LL) + abort(); + if (d2sll((double)(long long int)~((~0ULL) >> 1)) != (long long int)~((~0ULL) >> 1)) /* 0x80000000 */ + abort(); +} +#endif + +main() +{ + test_integer_to_float(); + test_float_to_integer(); +#if __GNUC__ + test_longlong_integer_to_float(); + test_float_to_longlong_integer(); +#endif + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.c new file mode 100755 index 0000000..d7c2b33 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.c @@ -0,0 +1,30 @@ +/* CYGNUS LOCAL -- meissner/16 bit ints */ +static inline long +g1 (double x) +{ + return (double) (long) x; +} + +long +g2 (double f) +{ + return f; +} + +double +f (long i) +{ + if (g1 (i) != g2 (i)) + abort (); + return g2 (i); +} + +main () +{ + if (f (123456789L) != 123456789L) + abort (); + if (f (123456789L) != g2 (123456789L)) + abort (); + exit (0); +} +/* END CYGNUS LOCAL -- meissner/16 bit ints */ diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.x new file mode 100755 index 0000000..997c865 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/cvt-1.x @@ -0,0 +1,7 @@ +# This doesn't work on d10v if ints are not 32 bits + +if { [istarget "d10v-*-*"] && ! [string-match "*-mint32*" $CFLAGS] } { + set torture_execute_xfail "d10v-*-*" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/dbra-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/dbra-1.c new file mode 100755 index 0000000..20ae898 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/dbra-1.c @@ -0,0 +1,95 @@ +f1 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a == -1) + return i; + } + return -1; +} + +f2 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a != -1) + return i; + } + return -1; +} + +f3 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a == 0) + return i; + } + return -1; +} + +f4 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (--a != 0) + return i; + } + return -1; +} + +f5 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (++a == 0) + return i; + } + return -1; +} + +f6 (a) + long a; +{ + int i; + for (i = 0; i < 10; i++) + { + if (++a != 0) + return i; + } + return -1; +} + + +main() +{ + if (f1 (5L) != 5) + abort (); + if (f2 (1L) != 0) + abort (); + if (f2 (0L) != 1) + abort (); + if (f3 (5L) != 4) + abort (); + if (f4 (1L) != 1) + abort (); + if (f4 (0L) != 0) + abort (); + if (f5 (-5L) != 4) + abort (); + if (f6 (-1L) != 1) + abort (); + if (f6 (0L) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/divconst-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-1.c new file mode 100755 index 0000000..ce9dd60 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-1.c @@ -0,0 +1,21 @@ +typedef struct +{ + unsigned a, b, c, d; +} t1; + +f (t1 *ps) +{ + ps->a = 10000; + ps->b = ps->a / 3; + ps->c = 10000; + ps->d = ps->c / 3; +} + +main () +{ + t1 s; + f (&s); + if (s.a != 10000 || s.b != 3333 || s.c != 10000 || s.d != 3333) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/divconst-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-2.c new file mode 100755 index 0000000..d3adaf3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-2.c @@ -0,0 +1,12 @@ +long +f (long x) +{ + return x / (-0x7fffffffL - 1L); +} + +main () +{ + if (f (-1L) != 0L || f (0x7fffffffL) != 0L || f (-0x7fffffffL - 1L) != 1l) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/divconst-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-3.c new file mode 100755 index 0000000..ddd687c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/divconst-3.c @@ -0,0 +1,12 @@ +long long +f (long long x) +{ + return x / 10000000000LL; +} + +main () +{ + if (f (10000000000LL) != 1 || f (100000000000LL) != 10) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/divmod-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/divmod-1.c new file mode 100755 index 0000000..ade019c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/divmod-1.c @@ -0,0 +1,72 @@ +div1 (x) + signed char x; +{ + return x / -1; +} + +div2 (x) + signed short x; +{ + return x / -1; +} + +div3 (x, y) + signed char x; + signed char y; +{ + return x / y; +} + +div4 (x, y) + signed short x; + signed short y; +{ + return x / y; +} + +mod1 (x) + signed char x; +{ + return x % -1; +} + +mod2 (x) + signed short x; +{ + return x % -1; +} + +mod3 (x, y) + signed char x; + signed char y; +{ + return x % y; +} + +mod4 (x, y) + signed short x; + signed short y; +{ + return x % y; +} + +main () +{ + if (div1 (-(1 << 7)) != 1 << 7) + abort (); + if (div2 (-(1 << 15)) != 1 << 15) + abort (); + if (div3 (-(1 << 7), -1) != 1 << 7) + abort (); + if (div4 (-(1 << 15), -1) != 1 << 15) + abort (); + if (mod1 (-(1 << 7)) != 0) + abort (); + if (mod2 (-(1 << 15)) != 0) + abort (); + if (mod3 (-(1 << 7), -1) != 0) + abort (); + if (mod4 (-(1 << 15), -1) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/enum-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/enum-1.c new file mode 100755 index 0000000..381e354 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/enum-1.c @@ -0,0 +1,43 @@ +typedef enum +{ + END = -1, + EMPTY = (1 << 8 ) , + BACKREF, + BEGLINE, + ENDLINE, + BEGWORD, + ENDWORD, + LIMWORD, + NOTLIMWORD, + QMARK, + STAR, + PLUS, + REPMN, + CAT, + OR, + ORTOP, + LPAREN, + RPAREN, + CSET +} token; + +static token tok; + +static int +atom () +{ + if ((tok >= 0 && tok < (1 << 8 ) ) || tok >= CSET || tok == BACKREF + || tok == BEGLINE || tok == ENDLINE || tok == BEGWORD + || tok == ENDWORD || tok == LIMWORD || tok == NOTLIMWORD) + return 1; + else + return 0; +} + +main () +{ + tok = 0; + if (atom () != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/execute.exp b/gcc_arm/testsuite/gcc.c-torture/execute/execute.exp new file mode 100755 index 0000000..8c896cb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/execute.exp @@ -0,0 +1,46 @@ +# Copyright (C) 1991, 1992, 1993, 1995, 1997 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +# Please email any bugs, comments, and/or additions to this file to: +# bug-gcc@prep.ai.mit.edu + +# This file was written by Rob Savoye. (rob@cygnus.com) +# Modified and maintained by Jeffrey Wheat (cassidy@cygnus.com) + +# +# These tests come from Torbjorn Granlund (tege@cygnus.com) +# C torture test suite. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +# +# main test loop +# + +foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.c]] { + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $src] then { + continue + } + + c-torture-execute $src +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/func-ptr-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/func-ptr-1.c new file mode 100755 index 0000000..55f0e10 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/func-ptr-1.c @@ -0,0 +1,16 @@ +static double f (float a); +static double (*fp) (float a); + +main () +{ + fp = f; + if (fp ((float) 1) != 1.0) + abort (); + exit (0); +} + +static double +f (float a) +{ + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/gofast.c b/gcc_arm/testsuite/gcc.c-torture/execute/gofast.c new file mode 100755 index 0000000..f55ced2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/gofast.c @@ -0,0 +1,99 @@ +/* Program to test gcc's usage of the gofast library. */ + +/* The main guiding themes are to make it trivial to add test cases over time + and to make it easy for a program to parse the output to see if the right + libcalls are being made. */ + +#include <stdio.h> + +float fp_add (float a, float b) { return a + b; } +float fp_sub (float a, float b) { return a - b; } +float fp_mul (float a, float b) { return a * b; } +float fp_div (float a, float b) { return a / b; } +float fp_neg (float a) { return -a; } + +double dp_add (double a, double b) { return a + b; } +double dp_sub (double a, double b) { return a - b; } +double dp_mul (double a, double b) { return a * b; } +double dp_div (double a, double b) { return a / b; } +double dp_neg (double a) { return -a; } + +double fp_to_dp (float f) { return f; } +float dp_to_fp (double d) { return d; } + +int eqsf2 (float a, float b) { return a == b; } +int nesf2 (float a, float b) { return a != b; } +int gtsf2 (float a, float b) { return a > b; } +int gesf2 (float a, float b) { return a >= b; } +int ltsf2 (float a, float b) { return a < b; } +int lesf2 (float a, float b) { return a <= b; } + +int eqdf2 (double a, double b) { return a == b; } +int nedf2 (double a, double b) { return a != b; } +int gtdf2 (double a, double b) { return a > b; } +int gedf2 (double a, double b) { return a >= b; } +int ltdf2 (double a, double b) { return a < b; } +int ledf2 (double a, double b) { return a <= b; } + +float floatsisf (int i) { return i; } +double floatsidf (int i) { return i; } +int fixsfsi (float f) { return f; } +int fixdfsi (double d) { return d; } +unsigned int fixunssfsi (float f) { return f; } +unsigned int fixunsdfsi (double d) { return d; } + +int fail_count = 0; + +int +fail (char *msg) +{ + fail_count++; + fprintf (stderr, "Test failed: %s\n", msg); +} + +int +main() +{ + if (fp_add (1, 1) != 2) fail ("fp_add 1+1"); + if (fp_sub (3, 2) != 1) fail ("fp_sub 3-2"); + if (fp_mul (2, 3) != 6) fail ("fp_mul 2*3"); + if (fp_div (3, 2) != 1.5) fail ("fp_div 3/2"); + if (fp_neg (1) != -1) fail ("fp_neg 1"); + + if (dp_add (1, 1) != 2) fail ("dp_add 1+1"); + if (dp_sub (3, 2) != 1) fail ("dp_sub 3-2"); + if (dp_mul (2, 3) != 6) fail ("dp_mul 2*3"); + if (dp_div (3, 2) != 1.5) fail ("dp_div 3/2"); + if (dp_neg (1) != -1) fail ("dp_neg 1"); + + if (fp_to_dp (1.5) != 1.5) fail ("fp_to_dp 1.5"); + if (dp_to_fp (1.5) != 1.5) fail ("dp_to_fp 1.5"); + + if (floatsisf (1) != 1) fail ("floatsisf 1"); + if (floatsidf (1) != 1) fail ("floatsidf 1"); + if (fixsfsi (1.42) != 1) fail ("fixsfsi 1.42"); + if (fixunssfsi (1.42) != 1) fail ("fixunssfsi 1.42"); + if (fixdfsi (1.42) != 1) fail ("fixdfsi 1.42"); + if (fixunsdfsi (1.42) != 1) fail ("fixunsdfsi 1.42"); + + if (eqsf2 (1, 1) == 0) fail ("eqsf2 1==1"); + if (eqsf2 (1, 2) != 0) fail ("eqsf2 1==2"); + if (nesf2 (1, 2) == 0) fail ("nesf2 1!=1"); + if (nesf2 (1, 1) != 0) fail ("nesf2 1!=1"); + if (gtsf2 (2, 1) == 0) fail ("gtsf2 2>1"); + if (gtsf2 (1, 1) != 0) fail ("gtsf2 1>1"); + if (gtsf2 (0, 1) != 0) fail ("gtsf2 0>1"); + if (gesf2 (2, 1) == 0) fail ("gesf2 2>=1"); + if (gesf2 (1, 1) == 0) fail ("gesf2 1>=1"); + if (gesf2 (0, 1) != 0) fail ("gesf2 0>=1"); + if (ltsf2 (1, 2) == 0) fail ("ltsf2 1<2"); + if (ltsf2 (1, 1) != 0) fail ("ltsf2 1<1"); + if (ltsf2 (1, 0) != 0) fail ("ltsf2 1<0"); + if (lesf2 (1, 2) == 0) fail ("lesf2 1<=2"); + if (lesf2 (1, 1) == 0) fail ("lesf2 1<=1"); + if (lesf2 (1, 0) != 0) fail ("lesf2 1<=0"); + + if (fail_count != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920518-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920518-1.c new file mode 100755 index 0000000..7f072b2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920518-1.c @@ -0,0 +1,8 @@ +unsigned u=2147483839;float f0=2147483648e0,f1=2147483904e0; +main() +{ + float f=u; + if(f==f0) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920810-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920810-1.c new file mode 100755 index 0000000..62d2294 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/920810-1.c @@ -0,0 +1,3 @@ +#include <stdio.h> +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);} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/930529-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/930529-1.c new file mode 100755 index 0000000..b96a3c0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/930529-1.c @@ -0,0 +1,27 @@ +main () +{ + union { + double d; + unsigned char c[8]; + } d; + + d.d = 1.0/7.0; + + if (sizeof (char) * 8 == sizeof (double)) + { + if (d.c[0] == 0x92 && d.c[1] == 0x24 && d.c[2] == 0x49 && d.c[3] == 0x92 + && d.c[4] == 0x24 && d.c[5] == 0x49 && d.c[6] == 0xc2 && d.c[7] == 0x3f) + exit (0); + if (d.c[7] == 0x92 && d.c[6] == 0x24 && d.c[5] == 0x49 && d.c[4] == 0x92 + && d.c[3] == 0x24 && d.c[2] == 0x49 && d.c[1] == 0xc2 && d.c[0] == 0x3f) + exit (0); +#if defined __arm__ || defined __thumb__ + if (d.c[4] == 0x92 && d.c[5] == 0x24 && d.c[6] == 0x49 && d.c[7] == 0x92 + && d.c[0] == 0x24 && d.c[1] == 0x49 && d.c[2] == 0xc2 && d.c[3] == 0x3f) + exit (0); +#endif + abort (); + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/980619-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/980619-1.c new file mode 100755 index 0000000..0465ed5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/980619-1.c @@ -0,0 +1,23 @@ + int main(void) + { + float reale = 1.0f; + float oneplus; + int i; + + if (sizeof (float) != 4) + exit (0); + + for (i = 0; ; i++) + { + oneplus = 1.0f + reale; + if (oneplus == 1.0f) + break; + reale=reale/2.0f; + } + /* Assumes ieee754 accurate arithmetic above. */ + if (i != 24) + abort (); + else + exit (0); + } + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/configure.in b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/configure.in new file mode 100755 index 0000000..7d7078d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=execute.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c new file mode 100755 index 0000000..4794efc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c @@ -0,0 +1,41 @@ +#include <signal.h> + +double nan = 1.0/0.0 - 1.0/0.0; +double x = 1.0; + +void leave () +{ + exit (0); +} + +main () +{ +#if ! defined (__vax__) && ! defined (_CRAY) + /* Move this line earlier, for architectures (like alpha) that issue + SIGFPE on the first comparisons. */ +#ifndef SIGNAL_SUPPRESS + /* Some machines catches a SIGFPE when a NaN is compared. + Let this test succeed o such machines. */ + signal (SIGFPE, leave); +#endif + /* NaN is an IEEE unordered operand. All these test should be false. */ + if (nan == nan) + abort (); + if (nan != x) + x = 1.0; + else + abort (); + + if (nan < x) + abort (); + if (nan > x) + abort (); + if (nan <= x) + abort (); + if (nan >= x) + abort (); + if (nan == x) + abort (); +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/ieee.exp b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/ieee.exp new file mode 100755 index 0000000..903d5ce --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/ieee.exp @@ -0,0 +1,61 @@ +# +# Expect driver script for GCC Regression Tests +# Copyright (C) 1993, 1996 Free Software Foundation +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# +# Written by Jeffrey Wheat (cassidy@cygnus.com) +# + +# +# These tests come from Torbjorn Granlund's (tege@cygnus.com) +# C torture test suite, and other contributors. +# + +if $tracelevel then { + strace $tracelevel +} + +if [target_info exists ieee_multilib_flags] { + set additional_flags [target_info ieee_multilib_flags]; +} else { + set additional_flags ""; +} + +# We must use -ffloat-store to ensure that excess precision on some machines +# does not cause problems +lappend additional_flags "-ffloat-store" + +# load support procs +load_lib c-torture.exp + +# initialize harness +gcc_init + +# +# main test loop +# + +foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.c]] { + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $src] then { + continue + } + + c-torture-execute $src $additional_flags +} + +# All done. +gcc_finish diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/minuszero.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/minuszero.c new file mode 100755 index 0000000..8571526 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/minuszero.c @@ -0,0 +1,22 @@ +main () +{ + union + { + double d; + unsigned short i[sizeof (double) / sizeof (short)]; + } u; + int a = 0; + int b = -5; + int j; + + u.d = (double) a / b; + + /* Look for the right pattern, but be sloppy since + we don't know the byte order. */ + for (j = 0; j < sizeof (double) / sizeof (short); j++) + { + if (u.i[j] == 0x8000) + exit (0); + } + abort (); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/mzero2.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/mzero2.c new file mode 100755 index 0000000..0da53d2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/mzero2.c @@ -0,0 +1,58 @@ +/* Test IEEE +0/-0 rules */ + +static double pzero = +0.0; +static double nzero = -0.0; +static double pinf = +1.0 / 0.0; +static double ninf = -1.0 / 0.0; +static double nan = 0.0 / 0.0; + +void +expect (double value, double expected) +{ + if (expected != expected) /* expected value is Not a number */ + { + if (value == value) /* actual value is a number */ + abort (); + } + + else if (value != value) + abort (); /* actual value is a NaN */ + + else if (memcmp ((void *)&value, (void *)&expected, sizeof (double)) != 0) + abort (); /* values don't match */ +} + +main () +{ + expect (pzero + pzero, pzero); + expect (pzero + nzero, pzero); + expect (nzero + pzero, pzero); + expect (nzero + nzero, nzero); + + expect (pzero - pzero, pzero); + expect (pzero - nzero, pzero); + expect (nzero - pzero, nzero); + expect (nzero - nzero, pzero); + + expect (pzero * pzero, pzero); + expect (pzero * nzero, nzero); + expect (nzero * pzero, nzero); + expect (nzero * nzero, pzero); + + expect (+1.00 * pzero, pzero); + expect (-1.00 * pzero, nzero); + expect (+1.00 * nzero, nzero); + expect (-1.00 * nzero, pzero); + + expect (pzero / pzero, nan); + expect (pzero / nzero, nan); + expect (nzero / pzero, nan); + expect (nzero / nzero, nan); + + expect (+1.00 / pzero, pinf); + expect (-1.00 / pzero, ninf); + expect (+1.00 / nzero, ninf); + expect (-1.00 / nzero, pinf); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.c b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.c new file mode 100755 index 0000000..a91a99e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.c @@ -0,0 +1,41 @@ +double d (unsigned long long k) +{ + double x; + + x = (double) k; + return x; +} + +float s (unsigned long long k) +{ + float x; + + x = (float) k; + return x; +} + +main () +{ + unsigned long long int k; + double x; + + /* CYGNUS LOCAL -- meissner/32bit doubles */ + if (sizeof (double) >= 8) + { + k = 0x8693ba6d7d220401ULL; + x = d (k); + k = (unsigned long long) x; + if (k != 0x8693ba6d7d220800ULL) + abort (); + } + /* END CYGNUS LOCAL -- meissner/32bit doubles */ + + k = 0x8234508000000001ULL; + x = s (k); + k = (unsigned long long) x; + if (k != 0x8234510000000000ULL) + abort (); + + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.cexp b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.cexp new file mode 100755 index 0000000..0ae0a35 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.cexp @@ -0,0 +1,7 @@ +# This doesn't work on d10v if doubles are not 64 bits + +if { [istarget "d10v-*-*"] && ! [string-match "*-mdouble64*" $CFLAGS] } { + set torture_execute_xfail "d10v-*-*" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.x b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.x new file mode 100755 index 0000000..0ae0a35 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ieee/rbug.x @@ -0,0 +1,7 @@ +# This doesn't work on d10v if doubles are not 64 bits + +if { [istarget "d10v-*-*"] && ! [string-match "*-mdouble64*" $CFLAGS] } { + set torture_execute_xfail "d10v-*-*" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/index-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/index-1.c new file mode 100755 index 0000000..b00090d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/index-1.c @@ -0,0 +1,20 @@ +int a[] = +{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 +}; + +int +f (long n) +{ + return a[n - 100000]; +} + +main () +{ + if (f (100030L) != 30) + abort(); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/inst-check.c b/gcc_arm/testsuite/gcc.c-torture/execute/inst-check.c new file mode 100755 index 0000000..ff4b00d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/inst-check.c @@ -0,0 +1,14 @@ +#include <stdarg.h> + +f(m) +{ + int i,s=0; + for(i=0;i<m;i++) + s+=i; + return s; +} + +main() +{ + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/int-compare.c b/gcc_arm/testsuite/gcc.c-torture/execute/int-compare.c new file mode 100755 index 0000000..017a8cc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/int-compare.c @@ -0,0 +1,108 @@ +#include <limits.h> + +gt (a, b) +{ + return a > b; +} + +ge (a, b) +{ + return a >= b; +} + +lt (a, b) +{ + return a < b; +} + +le (a, b) +{ + return a <= b; +} + +void +true (c) +{ + if (!c) + abort(); +} + +void +false (c) +{ + if (c) + abort(); +} + +f () +{ + true (gt (2, 1)); + false (gt (1, 2)); + + true (gt (INT_MAX, 0)); + false (gt (0, INT_MAX)); + true (gt (INT_MAX, 1)); + false (gt (1, INT_MAX)); + + false (gt (INT_MIN, 0)); + true (gt (0, INT_MIN)); + false (gt (INT_MIN, 1)); + true (gt (1, INT_MIN)); + + true (gt (INT_MAX, INT_MIN)); + false (gt (INT_MIN, INT_MAX)); + + true (ge (2, 1)); + false (ge (1, 2)); + + true (ge (INT_MAX, 0)); + false (ge (0, INT_MAX)); + true (ge (INT_MAX, 1)); + false (ge (1, INT_MAX)); + + false (ge (INT_MIN, 0)); + true (ge (0, INT_MIN)); + false (ge (INT_MIN, 1)); + true (ge (1, INT_MIN)); + + true (ge (INT_MAX, INT_MIN)); + false (ge (INT_MIN, INT_MAX)); + + false (lt (2, 1)); + true (lt (1, 2)); + + false (lt (INT_MAX, 0)); + true (lt (0, INT_MAX)); + false (lt (INT_MAX, 1)); + true (lt (1, INT_MAX)); + + true (lt (INT_MIN, 0)); + false (lt (0, INT_MIN)); + true (lt (INT_MIN, 1)); + false (lt (1, INT_MIN)); + + false (lt (INT_MAX, INT_MIN)); + true (lt (INT_MIN, INT_MAX)); + + false (le (2, 1)); + true (le (1, 2)); + + false (le (INT_MAX, 0)); + true (le (0, INT_MAX)); + false (le (INT_MAX, 1)); + true (le (1, INT_MAX)); + + true (le (INT_MIN, 0)); + false (le (0, INT_MIN)); + true (le (INT_MIN, 1)); + false (le (1, INT_MIN)); + + false (le (INT_MAX, INT_MIN)); + true (le (INT_MIN, INT_MAX)); +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-1.c new file mode 100755 index 0000000..81aeeb6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-1.c @@ -0,0 +1,18 @@ +main () +{ + int i, j, k[3]; + + j = 0; + for (i=0; i < 3; i++) + { + k[i] = j++; + } + + for (i=2; i >= 0; i--) + { + if (k[i] != i) + abort (); + } + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2.c new file mode 100755 index 0000000..3227734 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2.c @@ -0,0 +1,17 @@ +int a[2]; + +f (b) +{ + unsigned int i; + for (i = 0; i < b; i++) + a[i] = i - 2; +} + +main () +{ + a[0] = a[1] = 0; + f (2); + if (a[0] != -2 || a[1] != -1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2b.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2b.c new file mode 100755 index 0000000..7f67bcd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2b.c @@ -0,0 +1,22 @@ +#include <limits.h> + +int a[2]; + +f (int i) +{ + for (; i < INT_MAX; i++) + { + a[i] = -2; + if (&a[i] == &a[1]) + break; + } +} + +main () +{ + a[0] = a[1] = 0; + f (0); + if (a[0] != -2 || a[1] != -2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2c.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2c.c new file mode 100755 index 0000000..9facf3b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2c.c @@ -0,0 +1,23 @@ +int a[2]; + +__inline__ f (b, o) +{ + unsigned int i; + int *p; + for (p = &a[b], i = b; --i < ~0; ) + *--p = i * 3 + o; +} + +g(int b) +{ + f (b, (int)a); +} + +main () +{ + a[0] = a[1] = 0; + g (2); + if (a[0] != (int)a || a[1] != (int)a + 3) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2d.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2d.c new file mode 100755 index 0000000..19272bf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2d.c @@ -0,0 +1,18 @@ +int a[2]; + +f (b) +{ + unsigned int i; + int *p; + for (p = &a[b], i = b; --i < ~0; ) + *--p = i * 3 + (int)a; +} + +main () +{ + a[0] = a[1] = 0; + f (2); + if (a[0] != (int)a || a[1] != (int)a + 3) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.c new file mode 100755 index 0000000..b6ee650 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.c @@ -0,0 +1,60 @@ +#include <limits.h> + +#ifdef __unix__ /* ??? Is that good enough? */ +#include <sys/types.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#ifndef MAP_ANON +#ifdef MAP_ANONYMOUS +#define MAP_ANON MAP_ANONYMOUS +#else +#define MAP_ANON MAP_FILE +#endif +#endif +#ifndef MAP_FILE +#define MAP_FILE 0 +#endif +#ifndef MAP_FIXED +#define MAP_FIXED 0 +#endif +#endif + +#define MAP_START (void *)0x7fff8000 +#define MAP_LEN 0x10000 + +#define OFFSET (MAP_LEN/2 - 2 * sizeof (int)); + +f (int *p, int **q) +{ + int i; + for (i = 0; i < 40; i++) + { + *q++ = &p[i]; + } +} + +main () +{ +#ifdef MAP_ANON + void *p; + int *q[40]; + int dev_zero; + + dev_zero = open ("/dev/zero", O_RDONLY); + /* -1 is OK when we have MAP_ANON; else mmap will flag an error. */ + if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int)) + exit (0); + p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0); + if (p != (void *)-1) + { + p = (char *)p + OFFSET; + q[39] = 0; + f (p, q); + if (q[39] != (int *)p + 39) + abort (); + } +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.x b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.x new file mode 100755 index 0000000..e68b8fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2e.x @@ -0,0 +1,9 @@ +# This doesn't work on m68k-motorola-sysv +# It also doesn't work on m88k-motorola-sysv3 + +global target_triplet +if { [istarget "m68k-motorola-sysv"] || [istarget "m88k-motorola-sysv3"] } { + set torture_compile_xfail "$target_triplet" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.c new file mode 100755 index 0000000..9f544b9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.c @@ -0,0 +1,63 @@ +#include <limits.h> + +#ifdef __unix__ /* ??? Is that good enough? */ +#include <sys/types.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#ifndef MAP_ANON +#ifdef MAP_ANONYMOUS +#define MAP_ANON MAP_ANONYMOUS +#else +#define MAP_ANON MAP_FILE +#endif +#endif +#ifndef MAP_FILE +#define MAP_FILE 0 +#endif +#ifndef MAP_FIXED +#define MAP_FIXED 0 +#endif +#endif + +#define MAP_START (void *)0x7fff8000 +#define MAP_LEN 0x10000 + +#define OFFSET (MAP_LEN/2 - 2 * sizeof (char)); + +f (int s, char *p) +{ + int i; + for (i = s; i >= 0 && &p[i] < &p[40]; i++) + { + p[i] = -2; + } +} + +main () +{ +#ifdef MAP_ANON + char *p; + int dev_zero; + + dev_zero = open ("/dev/zero", O_RDONLY); + /* -1 is OK when we have MAP_ANON; else mmap will flag an error. */ + if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int)) + exit (0); + p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0); + if (p != (char *)-1) + { + p += OFFSET; + p[39] = 0; + f (0, p); + if (p[39] != (char)-2) + abort (); + p[39] = 0; + f (-1, p); + if (p[39] != 0) + abort (); + } +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.x b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.x new file mode 100755 index 0000000..e68b8fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2f.x @@ -0,0 +1,9 @@ +# This doesn't work on m68k-motorola-sysv +# It also doesn't work on m88k-motorola-sysv3 + +global target_triplet +if { [istarget "m68k-motorola-sysv"] || [istarget "m88k-motorola-sysv3"] } { + set torture_compile_xfail "$target_triplet" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.c new file mode 100755 index 0000000..8792dbf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.c @@ -0,0 +1,63 @@ +#include <limits.h> + +#ifdef __unix__ /* ??? Is that good enough? */ +#include <sys/types.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#ifndef MAP_ANON +#ifdef MAP_ANONYMOUS +#define MAP_ANON MAP_ANONYMOUS +#else +#define MAP_ANON MAP_FILE +#endif +#endif +#ifndef MAP_FILE +#define MAP_FILE 0 +#endif +#ifndef MAP_FIXED +#define MAP_FIXED 0 +#endif +#endif + +#define MAP_START (void *)0x7fff8000 +#define MAP_LEN 0x10000 + +#define OFFSET (MAP_LEN/2 - 2 * sizeof (char)); + +f (int s, char *p) +{ + int i; + for (i = s; &p[i] < &p[40] && i >= 0; i++) + { + p[i] = -2; + } +} + +main () +{ +#ifdef MAP_ANON + char *p; + int dev_zero; + + dev_zero = open ("/dev/zero", O_RDONLY); + /* -1 is OK when we have MAP_ANON; else mmap will flag an error. */ + if (INT_MAX != 0x7fffffffL || sizeof (char *) != sizeof (int)) + exit (0); + p = mmap (MAP_START, MAP_LEN, PROT_READ|PROT_WRITE, + MAP_ANON|MAP_FIXED|MAP_PRIVATE, dev_zero, 0); + if (p != (char *)-1) + { + p += OFFSET; + p[39] = 0; + f (0, p); + if (p[39] != (char)-2) + abort (); + p[39] = 0; + f (-1, p); + if (p[39] != 0) + abort (); + } +#endif + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.x b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.x new file mode 100755 index 0000000..e68b8fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-2g.x @@ -0,0 +1,9 @@ +# This doesn't work on m68k-motorola-sysv +# It also doesn't work on m88k-motorola-sysv3 + +global target_triplet +if { [istarget "m68k-motorola-sysv"] || [istarget "m88k-motorola-sysv3"] } { + set torture_compile_xfail "$target_triplet" +} + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3.c new file mode 100755 index 0000000..e314a01 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3.c @@ -0,0 +1,27 @@ +#include <limits.h> + +int n = 0; + +g (i) +{ + n++; +} + +f (m) +{ + int i; + i = m; + do + { + g (i * INT_MAX / 2); + } + while (--i > 0); +} + +main () +{ + f (4); + if (n != 4) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-3b.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3b.c new file mode 100755 index 0000000..3de322c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3b.c @@ -0,0 +1,28 @@ +#include <limits.h> + +int n = 0; + +g (i) +{ + n++; +} + +f (m) +{ + int i; + i = m; + do + { + g (i * 4); + i -= INT_MAX / 8; + } + while (i > 0); +} + +main () +{ + f (INT_MAX/8*4); + if (n != 4) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-3c.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3c.c new file mode 100755 index 0000000..bc74c2e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-3c.c @@ -0,0 +1,31 @@ +#include <limits.h> + +void * a[255]; + +f (m) +{ + int i; + int sh = 0x100; + i = m; + do + { + a[sh >>= 1] = ((unsigned)i << 3) + (char*)a; + i += 4; + } + while (i < INT_MAX/2 + 1 + 4 * 4); +} + +main () +{ + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + INT_MAX/4 + 2); + if (a[0x10] || a[0x08]) + abort (); + a[0x10] = 0; + a[0x08] = 0; + f (INT_MAX/2 + 1); + if (! a[0x10] || a[0x08]) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-4.c new file mode 100755 index 0000000..b308aa2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-4.c @@ -0,0 +1,16 @@ +int +f() +{ + int j = 1; + long i; + for (i = -0x70000000L; i < 0x60000000L; i += 0x10000000L) j <<= 1; + return j; +} + +int +main () +{ + if (f () != 8192) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/loop-4b.c b/gcc_arm/testsuite/gcc.c-torture/execute/loop-4b.c new file mode 100755 index 0000000..eaf7f30 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/loop-4b.c @@ -0,0 +1,21 @@ +int +f() +{ + int j = 1; + long i; + i = 0x60000000L; + do + { + j <<= 1; + i += 0x10000000L; + } while (i < -0x60000000L); + return j; +} + +int +main () +{ + if (f () != 2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.c new file mode 100755 index 0000000..4f448d6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.c @@ -0,0 +1,75 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +/* Test permissions of BLKmode arguments constructed purely on the + stack. + + Maybe we can't guarantee that we'll always wind up with stack args, + but if we don't, they're in registers, and permissions should just + always yield success. So while this test may not be effective on + all platforms, failure probably does indicate a real bug. + + Note that because of the implementation, we do want to test BLKmode + arguments that live purely on the stack and are constructed there. + We want to test other situations of function arguments, of course, + but don't assume this case would be covered by using one monster + argument that is read from memory (including using constructor + syntax but constant values), or may live partially in registers. */ + +int expect_error = 0; + +/* Must be BLKmode. Using only two fields gets TImode on Alpha. */ +struct S +{ + unsigned long long ll; + long xx; + long yy; +}; + +unsigned long long x = 0x12345689ULL; +#define I2 42 + +static int first_time = 1; + +/* Leading ten arguments force struct S onto the stack on both Alpha and MIPS. */ +int +foo (int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, + struct S s) +{ + if (a1 != 1 || a2 != 2 || a3 != 3 || a4 != 4 || a5 != 5 || a6 != 6 || a7 != 7 + || a8 != 8 || a9 !=9 || a10 != 10) + abort (); + + if (first_time) + { + if (s.ll != x || s.xx != I2 || s.yy != 0) + abort (); + + first_time = 0; + } + else + { + if (s.ll != 0 || s.xx != 0 || s.yy != 0) + abort (); + } + + return 0; +} + +void +test () +{ + foo (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, (struct S) { x, I2 }); + foo (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, (struct S) { 0 }); +} + +void +setup () /* NOCHECK */ +{ + mark_region (&x, sizeof (x), ACCESS_RO); + mark_region (&first_time, sizeof (first_time), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.x b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.x new file mode 100755 index 0000000..52b53fe --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/blkarg.x @@ -0,0 +1,9 @@ +# The memeory checking code does not mark the stack as readable or writable +# so this test fails. Ideally the memory checking library ought to +# cooperate with the host OS to mark the stack as it is used or individual +# function prologues and epilogues ought to mark their pieces of stack as +# writable and readable-after-written. + +set torture_execute_xfail "*-*-*" + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.c new file mode 100755 index 0000000..1da22e7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.c @@ -0,0 +1,272 @@ +/* GNU C dependencies: + Checker support hooks + ISO C 9x array element initialization + void-pointer arithmetic */ + +#include "driver.h" + +int verbose = 0; +int debug = 0; +int bad_accesses = 0; + +const char *const memory_use_strings[] = +{ +#define INIT(x) [x] = #x + INIT (MEMORY_USE_BAD), + INIT (MEMORY_USE_DONT), + INIT (MEMORY_USE_RO), + INIT (MEMORY_USE_RW), + INIT (MEMORY_USE_TW), + INIT (MEMORY_USE_WO), +#undef INIT +}; + +/* This won't be used for any really huge test cases, so a simple + linked list is adequate. We won't even worry about overlapping + regions; the matching entry that comes up first wins. */ +const char *const access_mode_strings[] = +{ + "none", "ro", "wo", "rw", +}; +struct access_node +{ + struct access_node *next; + const void *addr; + size_t sz; + enum access_mode mode; +}; + +static struct access_node *access_list; + +void +mark_region (const void *addr, size_t sz, enum access_mode mode) +{ + struct access_node *a; + if (debug) + printf ("mark_region (%p, %ld, %s)\n", addr, (long) sz, + access_mode_strings[mode]); + a = malloc (sizeof (struct access_node)); + a->next = access_list; + a->addr = addr; + a->sz = sz; + a->mode = mode; + access_list = a; +} + +void report_bad_access (void *, size_t, enum memory_use_mode) NOCHECK; +void +report_bad_access (void *addr, size_t sz, enum memory_use_mode mode) +{ + if (++bad_accesses > 100) + bad_accesses = 100; + if (verbose) + { + static char x[100]; + const char *mode_str; + if (mode >= 0 + && mode < sizeof (memory_use_strings) / sizeof (*memory_use_strings) + && memory_use_strings[mode] != 0) + mode_str = memory_use_strings[mode]; + else + { + sprintf (x, "<bad mode %d>", mode); + mode_str = x; + } + printf ("bad access (%p, %ld, %s)\n", addr, (long) sz, mode_str); + } +} + +int verify1 (void *, size_t, enum access_mode, struct access_node *) NOCHECK; +int +verify1 (void *addr, size_t sz, enum access_mode mode, + struct access_node *a) +{ + while (a && (addr + sz <= a->addr || addr >= a->addr + a->sz)) + a = a->next; + if (a == 0) + return 0; + + if (debug) + printf ("verify1 (%p, %ld, %s)\n", addr, (long) sz, + access_mode_strings[mode]); + + if (mode & ~a->mode) + return 0; + + if (addr < a->addr) + if (verify1 (a, a->addr - addr, mode, a->next) == 0) + return 0; + if (addr + sz > a->addr + a->sz) + if (verify1 (a->addr + a->sz, (addr + sz) - (a->addr + a->sz), mode, a->next) == 0) + return 0; + + /* All regions okay. */ + return 1; +} + +int verify_range_permission (void *, size_t, enum access_mode) NOCHECK; +int +verify_range_permission (void *addr, size_t sz, enum access_mode mode) +{ + if (debug) + printf ("verify_range_permission (%p, %ld, %s)\n", addr, (long) sz, + access_mode_strings[mode]); + return verify1 (addr, sz, mode, access_list); +} + +void chkr_check_addr (void *, size_t, int) NOCHECK; +void +chkr_check_addr (void *addr, size_t sz, int mode) +{ + switch (mode) + { + case MEMORY_USE_BAD: + case MEMORY_USE_DONT: + default: + report_bad_access (addr, sz, mode); + return; + case MEMORY_USE_RO: + /* verify range readable */ + if (!verify_range_permission (addr, sz, ACCESS_RO)) + report_bad_access (addr, sz, mode); + return; + case MEMORY_USE_WO: + /* verify writeable, set writeable and readable */ + if (!verify_range_permission (addr, sz, ACCESS_WO)) + report_bad_access (addr, sz, mode); + mark_region (addr, sz, ACCESS_RW); + return; + case MEMORY_USE_RW: + /* verify readable and writeable, no change */ + if (!verify_range_permission (addr, sz, ACCESS_RW)) + report_bad_access (addr, sz, mode); + return; + case MEMORY_USE_TW: + /* verify writeable, no change */ + if (!verify_range_permission (addr, sz, ACCESS_WO)) + report_bad_access (addr, sz, mode); + return; + } + /* All branches should return. */ + abort (); +} + +void copy1 (void *, void *, size_t, struct access_node *) NOCHECK; +void +copy1 (void *dest, void *src, size_t sz, struct access_node *a) +{ + while (a && (src + sz <= a->addr || src >= a->addr + a->sz)) + a = a->next; + if (a == 0) + { + report_bad_access (src, sz, MEMORY_USE_RO); + return; + } + + if (debug) + printf ("copy1 (%p, %p, %ld)\n", dest, src, (long) sz); + + { + void *start, *end; + start = src; + if (start < a->addr) + start = a->addr; + end = src + sz; + if (end > a->addr + a->sz) + end = a->addr + a->sz; + mark_region (dest + (start - src), end - start, a->mode); + } + + if (src < a->addr) + copy1 (dest, src, a->addr - src, a->next); + if (src + sz > a->addr + a->sz) + copy1 (dest + (a->addr + a->sz - src), a->addr + a->sz, + (src + sz) - (a->addr + a->sz), a->next); +} + +void chkr_copy_bitmap (void *, void *, size_t) NOCHECK; +void +chkr_copy_bitmap (void *dest, void *src, size_t sz) +{ + if (verify_range_permission (dest, sz, MEMORY_USE_WO) == 0) + report_bad_access (dest, sz, MEMORY_USE_WO); + copy1 (dest, src, sz, access_list); +} + +void chkr_set_right (void *, size_t, enum access_mode) NOCHECK; +void +chkr_set_right (void *addr, size_t sz, enum access_mode mode) +{ + mark_region (addr, sz, mode); +} + +int main () NOCHECK; +int +main () +{ + setup (); + test (); + bad_accesses = !!bad_accesses; /* get 0 or 1 */ + + if (bad_accesses == expect_error) + exit (0); + else + abort (); + + return 0; +} + +struct malloc_node +{ + struct malloc_node *next; + void *addr; + size_t sz; + unsigned is_free : 1; +}; +static struct malloc_node *malloc_list; + +void * +c_malloc (size_t sz) +{ + void *p; + struct malloc_node *m; + if (sz == 0) + return 0; + p = malloc (sz); + if (p == 0) + { + if (verbose) + printf ("malloc(%ld) failed\n", (long) sz); + exit (1); + } + m = malloc (sizeof (struct malloc_node)); + if (m == 0) + { + if (verbose) + printf ("malloc(%ld) failed\n", (long) sizeof (struct malloc_node)); + exit (1); + } + mark_region (p, sz, ACCESS_WO); + m->addr = p; + m->sz = sz; + m->is_free = 0; + m->next = malloc_list; + malloc_list = m; + return p; +} + +void +c_free (void *p) +{ + struct malloc_node *m; + if (p == 0) + return; + for (m = malloc_list; m; m = m->next) + if (m->addr == p) + break; + if (m == 0 || m->is_free) + /* Test is broken. */ + abort (); + m->is_free = 1; + free (p); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.h b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.h new file mode 100755 index 0000000..d8d22d2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/driver.h @@ -0,0 +1,28 @@ +/* GNU C dependencies: + Checker support hooks + ISO C 9x array element initialization + void-pointer arithmetic */ + +typedef __SIZE_TYPE__ size_t; + +extern void *malloc (size_t); +extern int printf (const char *, ...); + +/* This comes from gcc internals. Should be exported. */ +enum memory_use_mode {MEMORY_USE_BAD = 0, MEMORY_USE_RO = 1, + MEMORY_USE_WO = 2, MEMORY_USE_RW = 3, + MEMORY_USE_TW = 6, MEMORY_USE_DONT = 99}; + +enum access_mode { + ACCESS_NONE = 0, ACCESS_RO = 1, ACCESS_WO = 2, ACCESS_RW = 3 +}; + +#define NOCHECK __attribute__ ((no_check_memory_usage)) + +void mark_region (const void *, size_t, enum access_mode) NOCHECK; +void setup () NOCHECK; +void test (); +extern int expect_error; + +void *c_malloc (size_t) NOCHECK; +void c_free (void *) NOCHECK; diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/memcheck.exp b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/memcheck.exp new file mode 100755 index 0000000..7fb756b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/memcheck.exp @@ -0,0 +1,54 @@ +# Copyright (C) 1991, 92-93, 95, 97, 1998 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +# Please email any bugs, comments, and/or additions to this file to: +# bug-gcc@prep.ai.mit.edu + +# This file was written by Rob Savoye. (rob@cygnus.com) +# Modified and maintained by Jeffrey Wheat (cassidy@cygnus.com) + +# +# These tests come from Torbjorn Granlund (tege@cygnus.com) +# C torture test suite. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +# +# main test loop +# + +set tests [lsort [glob -nocomplain $srcdir/$subdir/*.c]] +set idx [lsearch $tests */driver.c] +if $idx>=0 { + set tests [lreplace $tests $idx $idx] +} else { + error "list can't find driver.c in $srcdir/$subdir" +} +gcc_target_compile $srcdir/$subdir/driver.c driver.o object {additional_flags=-w additional_flags=-g} +foreach src $tests { + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $src] then { + continue + } + + c-torture-execute $src "-fcheck-memory-usage driver.o" +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t1.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t1.c new file mode 100755 index 0000000..03b6acc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t1.c @@ -0,0 +1,27 @@ +/* Must define: + int expect_error; + void test (); + void setup (); -- NOCHECK */ + +#include "driver.h" + +int expect_error = 0; + +int *ip; + +void test () +{ + ip = c_malloc (sizeof (int)); + *ip = 42; + t2 (); +} + +int t2 () +{ + return *ip; +} + +void setup () /* NOCHECK */ +{ + mark_region (&ip, sizeof (ip), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t2.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t2.c new file mode 100755 index 0000000..d386eb7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t2.c @@ -0,0 +1,26 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 1; + +int *ip; + +void test () +{ + ip = c_malloc (sizeof (int)); + t2 (); +} + +int t2 () +{ + return *ip; +} + +void setup () /* NOCHECK */ +{ + mark_region (&ip, sizeof (ip), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t3.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t3.c new file mode 100755 index 0000000..5b6333d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t3.c @@ -0,0 +1,25 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 0; + +int *ip; + +void test () +{ + ip = c_malloc (sizeof (int)); + t2 (ip); +} + +int t2 (int *ip) +{ +} + +void setup () /* NOCHECK */ +{ + mark_region (&ip, sizeof (ip), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t4.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t4.c new file mode 100755 index 0000000..25010a0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t4.c @@ -0,0 +1,34 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 0; + +struct s { + char c; + int a, b; +}; + +struct s *sp; + +void test () +{ + sp = c_malloc (sizeof (struct s)); + sp->c = 0; + sp->a = 12; + sp->b = 47; + foo (sp); +} + +int foo (struct s *sp) +{ + return sp->c + sp->a + sp->b; +} + +void setup () /* NOCHECK */ +{ + mark_region (&sp, sizeof (sp), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t5.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t5.c new file mode 100755 index 0000000..c3bbf64 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t5.c @@ -0,0 +1,33 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 1; + +struct s { + char c; + int a, b; +}; + +struct s *sp; + +void test () +{ + sp = c_malloc (sizeof (struct s)); + sp->c = 0; + sp->b = 47; + foo (sp); +} + +int foo (struct s *sp) +{ + return sp->c + sp->a + sp->b; +} + +void setup () /* NOCHECK */ +{ + mark_region (&sp, sizeof (sp), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t6.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t6.c new file mode 100755 index 0000000..652d33d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t6.c @@ -0,0 +1,39 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 1; + +struct s { + char c; + int a, b; +}; + +struct s *sp; + +void test () +{ + sp = c_malloc (sizeof (struct s) * 2); + sp->c = 0; + sp->b = 47; + cp (sp); + foo (sp); +} + +int foo (struct s *sp) +{ + return sp[1].c + sp[1].a + sp[1].b; +} + +int cp (struct s *sp) +{ + sp[1] = sp[0]; +} + +void setup () /* NOCHECK */ +{ + mark_region (&sp, sizeof (sp), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t7.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t7.c new file mode 100755 index 0000000..a7c6f51 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t7.c @@ -0,0 +1,40 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 0; + +struct s { + char c; + int a, b; +}; + +struct s *sp; + +void test () +{ + sp = c_malloc (sizeof (struct s) * 2); + sp->c = 0; + sp->a = 13; + sp->b = 47; + cp (sp); + foo (sp); +} + +int foo (struct s *sp) +{ + return sp[1].c + sp[1].a + sp[1].b; +} + +int cp (struct s *sp) +{ + sp[1] = sp[0]; +} + +void setup () /* NOCHECK */ +{ + mark_region (&sp, sizeof (sp), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t8.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t8.c new file mode 100755 index 0000000..01c1672 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t8.c @@ -0,0 +1,41 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 0; + +typedef struct { + short a; + char b; +} S1; +typedef struct { + struct { int x; S1 *s1p; } *p; +} S2; + +S1 *s1; +S2 *s2; + +void test () +{ + s1 = c_malloc (sizeof (S1)); + s2 = c_malloc (sizeof (S2)); + s2->p = c_malloc (sizeof (*s2->p)); + s2->p->s1p = s1; + s1->a = 47; + s1->b = 3; + foo (); +} + +int foo () +{ + return s2->p->s1p->b; +} + +void setup () /* NOCHECK */ +{ + mark_region (&s1, sizeof (s1), ACCESS_RW); + mark_region (&s2, sizeof (s2), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t9.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t9.c new file mode 100755 index 0000000..f32ca01 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/t9.c @@ -0,0 +1,40 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = 1; + +typedef struct { + short a; + char b; +} S1; +typedef struct { + struct { int x; S1 *s1p; } *p; +} S2; + +S1 *s1; +S2 *s2; + +void test () +{ + s1 = c_malloc (sizeof (S1)); + s2 = c_malloc (sizeof (S2)); + s2->p = c_malloc (sizeof (*s2->p)); + s2->p->s1p = s1; + s1->a = 47; + foo (); +} + +int foo () +{ + return s2->p->s1p->b; +} + +void setup () /* NOCHECK */ +{ + mark_region (&s1, sizeof (s1), ACCESS_RW); + mark_region (&s2, sizeof (s2), ACCESS_RW); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/template b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/template new file mode 100755 index 0000000..37ebb13 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcheck/template @@ -0,0 +1,16 @@ +/* Must define: + int expect_error; + void test (); + void setup () NOCHECK; */ + +#include "driver.h" + +int expect_error = ; + +void test () +{ +} + +void setup () /* NOCHECK */ +{ +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-1.c new file mode 100755 index 0000000..684854b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-1.c @@ -0,0 +1,63 @@ +#include <string.h> + +#if defined (STACK_SIZE) +#define MEMCPY_SIZE (STACK_SIZE / 3) +#else +#define MEMCPY_SIZE (1 << 17) +#endif + + +void *copy (void *o, const void *i, unsigned l) +{ + return memcpy (o, i, l); +} + +main () +{ + unsigned i; + unsigned char src[MEMCPY_SIZE]; + unsigned char dst[MEMCPY_SIZE]; + + for (i = 0; i < MEMCPY_SIZE; i++) + src[i] = (unsigned char) i, dst[i] = 0; + + (void) memcpy (dst, src, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 1, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != 1) + abort (); + + (void) memcpy (dst, src, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 0, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != 0) + abort (); + + (void) copy (dst, src, MEMCPY_SIZE / 128); + + for (i = 0; i < MEMCPY_SIZE / 128; i++) + if (dst[i] != (unsigned char) i) + abort (); + + (void) memset (dst, 0, MEMCPY_SIZE); + + (void) copy (dst, src, MEMCPY_SIZE); + + for (i = 0; i < MEMCPY_SIZE; i++) + if (dst[i] != (unsigned char) i) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-bi.c b/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-bi.c new file mode 100755 index 0000000..c6d6e03 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/memcpy-bi.c @@ -0,0 +1,52 @@ +/* Test builtin-memcpy (which may emit different code for different N). */ + +#define TESTSIZE 80 + +char src[TESTSIZE] __attribute__ ((aligned)); +char dst[TESTSIZE] __attribute__ ((aligned)); + +void +check (char *test, char *match, int n) +{ + if (memcmp (test, match, n)) + abort (); +} + +#define TN(n) \ +{ memset (dst, 0, n); memcpy (dst, src, n); check (dst, src, n); } +#define T(n) \ +TN (n) \ +TN ((n) + 1) \ +TN ((n) + 2) \ +TN ((n) + 3) + +main () +{ + int i,j; + + for (i = 0; i < sizeof (src); ++i) + src[i] = 'a' + i % 26; + + T (0); + T (4); + T (8); + T (12); + T (16); + T (20); + T (24); + T (28); + T (32); + T (36); + T (40); + T (44); + T (48); + T (52); + T (56); + T (60); + T (64); + T (68); + T (72); + T (76); + + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/mod-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/mod-1.c new file mode 100755 index 0000000..b460df5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/mod-1.c @@ -0,0 +1,11 @@ +f (x, y) +{ + if (x % y != 0) + abort (); +} + +main () +{ + f (-5, 5); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/nest-stdar-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/nest-stdar-1.c new file mode 100755 index 0000000..2c6108b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/nest-stdar-1.c @@ -0,0 +1,19 @@ +#include <stdarg.h> + +main () +{ + static double f (int x, ...) + { + va_list args; + double a; + + va_start (args, x); + a = va_arg (args, double); + va_end (args); + return a; + } + + if (f (1, (double)1) != 1.0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/nestfunc-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/nestfunc-1.c new file mode 100755 index 0000000..e34a56b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/nestfunc-1.c @@ -0,0 +1,28 @@ +int +g (int a, int b, int (*gi) (int, int)) +{ + if ((*gi) (a, b)) + return a; + else + return b; +} + +f () +{ +#ifndef NO_TRAMPOLINES + int i, j; + int f2 (int a, int b) + { + return a > b; + } + + if (g (1, 2, f2) != 2) + abort (); +#endif +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/packed-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/packed-1.c new file mode 100755 index 0000000..9b226ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/packed-1.c @@ -0,0 +1,19 @@ +short x1 = 17; + +struct +{ + short i __attribute__ ((packed)); +} t; + +f () +{ + t.i = x1; + if (t.i != 17) + abort (); +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/pending-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/pending-4.c new file mode 100755 index 0000000..8000621 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/pending-4.c @@ -0,0 +1,33 @@ + +void dummy (x, y) + int *x; + int y; +{} + +int +main (argc, argv) + int argc; + char **argv; +{ + int number_columns=9; + int cnt0 = 0; + int cnt1 = 0; + int i,A1; + + for (i = number_columns-1; i != 0; i--) + { + if (i == 1) + { + dummy(&A1, i); + cnt0++; + } + else + { + dummy(&A1, i-1); + cnt1++; + } + } + if (cnt0 != 1 || cnt1 != 7) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/ptr-arith-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/ptr-arith-1.c new file mode 100755 index 0000000..46162b8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/ptr-arith-1.c @@ -0,0 +1,14 @@ +char * +f (char *s, unsigned int i) +{ + return &s[i + 3 - 1]; +} + +main () +{ + char *str = "abcdefghijkl"; + char *x2 = f (str, 12); + if (str + 14 != x2) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/regstack-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/regstack-1.c new file mode 100755 index 0000000..51fb858 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/regstack-1.c @@ -0,0 +1,26 @@ +long double C = 5; +long double U = 1; +long double Y2 = 11; +long double Y1 = 17; +long double X, Y, Z, T, R, S; +main () +{ + X = (C + U) * Y2; + Y = C - U - U; + Z = C + U + U; + T = (C - U) * Y1; + X = X - (Z + U); + R = Y * Y1; + S = Z * Y2; + T = T - Y; + Y = (U - Y) + R; + Z = S - (Z + U + U); + R = (Y2 + U) * Y1; + Y1 = Y2 * Y1; + R = R - Y2; + Y1 = Y1 - 0.5L; + if (Z != 68. || Y != 49. || X != 58. || Y1 != 186.5 || R != 193. || S != 77. + || T != 65. || Y2 != 11.) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/scope-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/scope-1.c new file mode 100755 index 0000000..cedd0b4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/scope-1.c @@ -0,0 +1,17 @@ +int v = 3; + +f () +{ + int v = 4; + { + extern int v; + if (v != 3) + abort (); + } +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/scope-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/scope-2.c new file mode 100755 index 0000000..c9a4775 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/scope-2.c @@ -0,0 +1,17 @@ +static int v = 3; + +f () +{ + int v = 4; + { + extern int v; + if (v != 3) + abort (); + } +} + +main () +{ + f (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-1.c new file mode 100755 index 0000000..7b702f2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-1.c @@ -0,0 +1,25 @@ +typedef struct +{ + short s __attribute__ ((aligned(2), packed)); + double d __attribute__ ((aligned(2), packed)); +} TRIAL; + +int +check (TRIAL *t) +{ + if (t->s != 1 || t->d != 16.0) + return 1; + return 0; +} + +main () +{ + TRIAL trial; + + trial.s = 1; + trial.d = 16.0; + + if (check (&trial) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-2.c new file mode 100755 index 0000000..be76c76 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-2.c @@ -0,0 +1,13 @@ +typedef struct +{ + short a __attribute__ ((aligned (2),packed)); + short *ap[2] __attribute__ ((aligned (2),packed)); +} A; + +main () +{ + short i, j = 1; + A a, *ap = &a; + ap->ap[j] = &i; + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-3.c new file mode 100755 index 0000000..8f91b04 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-3.c @@ -0,0 +1,28 @@ +typedef struct +{ + short i __attribute__ ((aligned (2),packed)); + int f[2] __attribute__ ((aligned (2),packed)); +} A; + +f (ap) + A *ap; +{ + short i, j = 1; + + i = ap->f[1]; + i += ap->f[j]; + for (j = 0; j < 2; j++) + i += ap->f[j]; + + return i; +} + +main () +{ + A a; + a.f[0] = 100; + a.f[1] = 13; + if (f (&a) != 139) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-4.c new file mode 100755 index 0000000..56d315f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-pack-4.c @@ -0,0 +1,29 @@ +typedef struct +{ + unsigned char a __attribute__((packed)); + unsigned short b __attribute__((packed)); +} three_char_t; + +unsigned char +my_set_a (void) +{ + return 0xab; +} + +unsigned short +my_set_b (void) +{ + return 0x1234; +} + +main () +{ + three_char_t three_char; + + three_char.a = my_set_a (); + three_char.b = my_set_b (); + if (three_char.a != 0xab || three_char.b != 0x1234) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-stdarg-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-stdarg-1.c new file mode 100755 index 0000000..508c954 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-stdarg-1.c @@ -0,0 +1,61 @@ +#include <stdarg.h> + +struct tiny +{ + char c; + char d; + char e; + char f; + char g; +}; + +f (int n, ...) +{ + struct tiny x; + int i; + + va_list ap; + va_start (ap,n); + for (i = 0; i < n; i++) + { + x = va_arg (ap,struct tiny); + if (x.c != i + 10) + abort(); + if (x.d != i + 20) + abort(); + if (x.e != i + 30) + abort(); + if (x.f != i + 40) + abort(); + if (x.g != i + 50) + abort(); + } + { + long x = va_arg (ap, long); + if (x != 123) + abort(); + } + va_end (ap); +} + +main () +{ + struct tiny x[3]; + x[0].c = 10; + x[1].c = 11; + x[2].c = 12; + x[0].d = 20; + x[1].d = 21; + x[2].d = 22; + x[0].e = 30; + x[1].e = 31; + x[2].e = 32; + x[0].f = 40; + x[1].f = 41; + x[2].f = 42; + x[0].g = 50; + x[1].g = 51; + x[2].g = 52; + f (3, x[0], x[1], x[2], (long) 123); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.c new file mode 100755 index 0000000..f76bb36 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.c @@ -0,0 +1,56 @@ +#ifdef NO_VARARGS +#include <stdarg.h> +#define va_alist int x_attr, ... +#define va_dcl +#else +#include <varargs.h> +#endif + +struct s { int x, y; }; + +f (va_alist) + va_dcl +{ + struct s va_values; + va_list va; + int attr; + int i; + +#ifdef NO_VARARGS + va_start (va, x_attr); + attr = x_attr; +#else + va_start (va); + attr = va_arg (va, int); +#endif + + if (attr != 2) + abort (); + + va_values = va_arg (va, struct s); + if (va_values.x != 0xaaaa || va_values.y != 0x5555) + abort (); + + attr = va_arg (va, int); + if (attr != 3) + abort (); + + va_values = va_arg (va, struct s); + if (va_values.x != 0xffff || va_values.y != 0x1111) + abort (); + + va_end (va); +} + +main () +{ + struct s a, b; + + a.x = 0xaaaa; + a.y = 0x5555; + b.x = 0xffff; + b.y = 0x1111; + + f (2, a, 3, b); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.x b/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.x new file mode 100755 index 0000000..22e08ef --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/strct-varg-1.x @@ -0,0 +1,10 @@ +# This doesn't work on mn10200 + +if { [istarget "mn10200*-*-*"] } { + set torture_execute_xfail "mn10200*-*-*" +} + +if { [istarget "h8300*-*-*"] } { + set torture_execute_xfail "h8300*-*-*" +} +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-1.c new file mode 100755 index 0000000..ab2d178 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-1.c @@ -0,0 +1,15 @@ +struct S +{ + char f1; + int f2[2]; +}; + +struct S object = {'X', 8, 9}; + +main () +{ + if (object.f1 != 'X' || object.f2[0] != 8 || object.f2[1] != 9) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-2.c new file mode 100755 index 0000000..c785257 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-2.c @@ -0,0 +1,17 @@ +struct { + int a:4; + int :4; + int b:4; + int c:4; +} x = { 2,3,4 }; + +main () +{ + if (x.a != 2) + abort (); + if (x.b != 3) + abort (); + if (x.c != 4) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-3.c new file mode 100755 index 0000000..7d282ec --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-3.c @@ -0,0 +1,11 @@ +struct +{ + 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 () +{ + if ((result.f3 & ~7) != 0 || (result.f4 & ~7) != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-4.c new file mode 100755 index 0000000..3342439 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ini-4.c @@ -0,0 +1,15 @@ +struct s { + int a[3]; + int c[3]; +}; + +struct s s = { + c: {1, 2, 3} +}; + +main() +{ + if (s.c[0] != 1) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-1.c new file mode 100755 index 0000000..e5274ec --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-1.c @@ -0,0 +1,57 @@ +#include <stdio.h> +#include <string.h> + +char out[100]; + +typedef struct { double d; int i[3]; } B; +typedef struct { char c[33],c1; } X; + +char c1 = 'a'; +char c2 = 127; +char c3 = (char)128; +char c4 = (char)255; +char c5 = -1; + +double d1 = 0.1; +double d2 = 0.2; +double d3 = 0.3; +double d4 = 0.4; +double d5 = 0.5; +double d6 = 0.6; +double d7 = 0.7; +double d8 = 0.8; +double d9 = 0.9; + +B B1 = {0.1,{1,2,3}}; +B B2 = {0.2,{5,4,3}}; +X X1 = {"abcdefghijklmnopqrstuvwxyzABCDEF", 'G'}; +X X2 = {"123",'9'}; +X X3 = {"return-return-return",'R'}; + +X f (B a, char b, double c, B d) +{ + static X xr = {"return val", 'R'}; + X r; + r = xr; + r.c1 = b; + sprintf (out, "X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})", + a.d, a.i[0], a.i[1], a.i[2], b, c, d.d, d.i[0], d.i[1], d.i[2]); + return r; +} + +X (*fp) (B, char, double, B) = &f; + +main () +{ + X Xr; + char tmp[100]; + + Xr = f (B1, c2, d3, B2); + strcpy (tmp, out); + Xr.c[0] = Xr.c1 = '\0'; + Xr = (*fp) (B1, c2, d3, B2); + if (strcmp (tmp, out)) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-2.c new file mode 100755 index 0000000..06a40a7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/struct-ret-2.c @@ -0,0 +1,29 @@ +typedef struct +{ + unsigned char a __attribute__ ((packed)); + unsigned short b __attribute__ ((packed)); +} three_byte_t; + +unsigned char +f (void) +{ + return 0xab; +} + +unsigned short +g (void) +{ + return 0x1234; +} + +main () +{ + three_byte_t three_byte; + + three_byte.a = f (); + three_byte.b = g (); + if (three_byte.a != 0xab || three_byte.b != 0x1234) + abort (); + exit (0); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/tstdi-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/tstdi-1.c new file mode 100755 index 0000000..3e31fdf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/tstdi-1.c @@ -0,0 +1,139 @@ +#define FALSE 140 +#define TRUE 13 + +feq (x) + long long int x; +{ + if (x == 0) + return TRUE; + else + return FALSE; +} + +fne (x) + long long int x; +{ + if (x != 0) + return TRUE; + else + return FALSE; +} + +flt (x) + long long int x; +{ + if (x < 0) + return TRUE; + else + return FALSE; +} + +fge (x) + long long int x; +{ + if (x >= 0) + return TRUE; + else + return FALSE; +} + +fgt (x) + long long int x; +{ + if (x > 0) + return TRUE; + else + return FALSE; +} + +fle (x) + long long int x; +{ + if (x <= 0) + return TRUE; + else + return FALSE; +} + +main () +{ + if (feq (0LL) != TRUE) + abort (); + if (feq (-1LL) != FALSE) + abort (); + if (feq (0x8000000000000000LL) != FALSE) + abort (); + if (feq (0x8000000000000001LL) != FALSE) + abort (); + if (feq (1LL) != FALSE) + abort (); + if (feq (0x7fffffffffffffffLL) != FALSE) + abort (); + + if (fne (0LL) != FALSE) + abort (); + if (fne (-1LL) != TRUE) + abort (); + if (fne (0x8000000000000000LL) != TRUE) + abort (); + if (fne (0x8000000000000001LL) != TRUE) + abort (); + if (fne (1LL) != TRUE) + abort (); + if (fne (0x7fffffffffffffffLL) != TRUE) + abort (); + + if (flt (0LL) != FALSE) + abort (); + if (flt (-1LL) != TRUE) + abort (); + if (flt (0x8000000000000000LL) != TRUE) + abort (); + if (flt (0x8000000000000001LL) != TRUE) + abort (); + if (flt (1LL) != FALSE) + abort (); + if (flt (0x7fffffffffffffffLL) != FALSE) + abort (); + + if (fge (0LL) != TRUE) + abort (); + if (fge (-1LL) != FALSE) + abort (); + if (fge (0x8000000000000000LL) != FALSE) + abort (); + if (fge (0x8000000000000001LL) != FALSE) + abort (); + if (fge (1LL) != TRUE) + abort (); + if (fge (0x7fffffffffffffffLL) != TRUE) + abort (); + + if (fgt (0LL) != FALSE) + abort (); + if (fgt (-1LL) != FALSE) + abort (); + if (fgt (0x8000000000000000LL) != FALSE) + abort (); + if (fgt (0x8000000000000001LL) != FALSE) + abort (); + if (fgt (1LL) != TRUE) + abort (); + if (fgt (0x7fffffffffffffffLL) != TRUE) + abort (); + + if (fle (0LL) != TRUE) + abort (); + if (fle (-1LL) != TRUE) + abort (); + if (fle (0x8000000000000000LL) != TRUE) + abort (); + if (fle (0x8000000000000001LL) != TRUE) + abort (); + if (fle (1LL) != FALSE) + abort (); + if (fle (0x7fffffffffffffffLL) != FALSE) + abort (); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-1.c new file mode 100755 index 0000000..3f3b141 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-1.c @@ -0,0 +1,24 @@ +#include <stdarg.h> + +typedef unsigned long L; +f (L p0, L p1, L p2, L p3, L p4, L p5, L p6, L p7, L p8, ...) +{ + va_list select; + + va_start (select, p8); + + if (va_arg (select, L) != 10) + abort (); + if (va_arg (select, L) != 11) + abort (); + if (va_arg (select, L) != 0) + abort (); + + va_end (select); +} + +main () +{ + f (1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L, 11L, 0L); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-2.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-2.c new file mode 100755 index 0000000..7675b3f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-2.c @@ -0,0 +1,292 @@ +/* The purpose of this test is to catch edge cases when arguments are passed + in regs and on the stack. We test 16 cases, trying to catch multiple + targets (some use 3 regs for argument passing, some use 12, etc.). + We test both the arguments and the `lastarg' (the argument to va_start). */ + +#include <stdarg.h> + +extern __SIZE_TYPE__ strlen (); + +int +to_hex (unsigned int a) +{ + static char hex[] = "0123456789abcdef"; + + if (a > 15) + abort (); + return hex[a]; +} + +void +f0 (char* format, ...) +{ + va_list ap; + + va_start (ap, format); + if (strlen (format) != 16 - 0) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f1 (int a1, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 1) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f2 (int a1, int a2, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 2) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f3 (int a1, int a2, int a3, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 3) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f4 (int a1, int a2, int a3, int a4, char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 4) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f5 (int a1, int a2, int a3, int a4, int a5, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 5) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f6 (int a1, int a2, int a3, int a4, int a5, + int a6, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 6) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f7 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 7) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f8 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 8) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f9 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 9) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f10 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 10) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f11 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 11) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f12 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 12) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f13 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 13) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f14 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 14) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f15 (int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, int a15, + char* format, ...) +{ + va_list ap; + + va_start(ap, format); + if (strlen (format) != 16 - 15) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +main () +{ + char *f = "0123456789abcdef"; + + f0 (f+0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f1 (0, f+1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f2 (0, 1, f+2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f3 (0, 1, 2, f+3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f4 (0, 1, 2, 3, f+4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f5 (0, 1, 2, 3, 4, f+5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f6 (0, 1, 2, 3, 4, 5, f+6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f7 (0, 1, 2, 3, 4, 5, 6, f+7, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f8 (0, 1, 2, 3, 4, 5, 6, 7, f+8, 8, 9, 10, 11, 12, 13, 14, 15); + f9 (0, 1, 2, 3, 4, 5, 6, 7, 8, f+9, 9, 10, 11, 12, 13, 14, 15); + f10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, f+10, 10, 11, 12, 13, 14, 15); + f11 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, f+11, 11, 12, 13, 14, 15); + f12 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, f+12, 12, 13, 14, 15); + f13 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, f+13, 13, 14, 15); + f14 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, f+14, 14, 15); + f15 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, f+15, 15); + + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.c new file mode 100755 index 0000000..7b0a0b0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.c @@ -0,0 +1,339 @@ +/* Same as va-arg-2.c but using varargs.h. */ +/* The purpose of this test is to catch edge cases when arguments are passed + in regs and on the stack. We test 16 cases, trying to catch multiple + targets (some use 3 regs for argument passing, some use 12, etc.). + We test both the arguments and the `lastarg' (the argument to va_start). */ + +#ifdef NO_VARARGS +int main() +{ + exit (0); +} + +#else +#include <varargs.h> + +extern __SIZE_TYPE__ strlen (); + +int +to_hex (unsigned int a) +{ + static char hex[] = "0123456789abcdef"; + + if (a > 15) + abort (); + return hex[a]; +} + +void +f0 (va_alist) + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 0) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f1 (a1, va_alist) + int a1; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 1) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f2 (a1, a2, va_alist) + int a1, a2; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 2) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f3 (a1, a2, a3, va_alist) + int a1, a2, a3; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 3) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f4 (a1, a2, a3, a4, va_alist) + int a1, a2, a3, a4; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 4) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f5 (a1, a2, a3, a4, a5, va_alist) + int a1, a2, a3, a4, a5; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 5) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f6 (a1, a2, a3, a4, a5, a6, va_alist) + int a1, a2, a3, a4, a5, a6; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 6) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f7 (a1, a2, a3, a4, a5, a6, a7, va_alist) + int a1, a2, a3, a4, a5, a6, a7; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 7) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f8 (a1, a2, a3, a4, a5, a6, a7, a8, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 8) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f9 (a1, a2, a3, a4, a5, a6, a7, a8, a9, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 9) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f10 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 10) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f11 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, + va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 11) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f12 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 12) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f13 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 13) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f14 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 14) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +void +f15 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, va_alist) + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15; + va_dcl +{ + va_list ap; + char *format; + + va_start (ap); + format = va_arg (ap, char *); + if (strlen (format) != 16 - 15) + abort (); + while (*format) + if (*format++ != to_hex (va_arg (ap, int))) + abort (); + va_end(ap); +} + +main () +{ + char *f = "0123456789abcdef"; + + f0 (f+0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f1 (0, f+1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f2 (0, 1, f+2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f3 (0, 1, 2, f+3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f4 (0, 1, 2, 3, f+4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f5 (0, 1, 2, 3, 4, f+5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f6 (0, 1, 2, 3, 4, 5, f+6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f7 (0, 1, 2, 3, 4, 5, 6, f+7, 7, 8, 9, 10, 11, 12, 13, 14, 15); + f8 (0, 1, 2, 3, 4, 5, 6, 7, f+8, 8, 9, 10, 11, 12, 13, 14, 15); + f9 (0, 1, 2, 3, 4, 5, 6, 7, 8, f+9, 9, 10, 11, 12, 13, 14, 15); + f10 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, f+10, 10, 11, 12, 13, 14, 15); + f11 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, f+11, 11, 12, 13, 14, 15); + f12 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, f+12, 12, 13, 14, 15); + f13 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, f+13, 13, 14, 15); + f14 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, f+14, 14, 15); + f15 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, f+15, 15); + + exit (0); +} +#endif /* ! NO_VARARGS */ diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.x b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.x new file mode 100755 index 0000000..865aaf8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-3.x @@ -0,0 +1,12 @@ +# This doesn't work on mn10200 + +if { [istarget "mn10200*-*-*"] } { + set torture_execute_xfail "mn10200*-*-*" +} + +if { [istarget "h8300*-*-*"] } { + set torture_execute_xfail "h8300*-*-*" +} + + +return 0 diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-4.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-4.c new file mode 100755 index 0000000..a824f64 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-4.c @@ -0,0 +1,33 @@ +/* On the i960 any arg bigger than 16 bytes causes all subsequent args + to be passed on the stack. We test this. */ + +#include <stdarg.h> + +typedef struct { + char a[32]; +} big; + +void +f (big x, char *s, ...) +{ + va_list ap; + + if (x.a[0] != 'a' || x.a[1] != 'b' || x.a[2] != 'c') + abort (); + va_start (ap, s); + if (va_arg (ap, int) != 42) + abort (); + if (va_arg (ap, int) != 'x') + abort (); + if (va_arg (ap, int) != 0) + abort (); + va_end (ap); +} + +main () +{ + static big x = { "abc" }; + + f (x, "", 42, 'x', 0); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-5.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-5.c new file mode 100755 index 0000000..3d8b1a7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-5.c @@ -0,0 +1,44 @@ +#include <stdarg.h> + +va_double (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, double) != 3.141592) + abort (); + if (va_arg (args, double) != 2.71827) + abort (); + if (va_arg (args, double) != 2.2360679) + abort (); + if (va_arg (args, double) != 2.1474836) + abort (); + + va_end (args); +} + +va_long_double (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, long double) != 3.141592L) + abort (); + if (va_arg (args, long double) != 2.71827L) + abort (); + if (va_arg (args, long double) != 2.2360679L) + abort (); + if (va_arg (args, long double) != 2.1474836L) + abort (); + + va_end (args); +} + +main () +{ + va_double (4, 3.141592, 2.71827, 2.2360679, 2.1474836); + va_long_double (4, 3.141592L, 2.71827L, 2.2360679L, 2.1474836L); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-6.c b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-6.c new file mode 100755 index 0000000..e8d495d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/va-arg-6.c @@ -0,0 +1,35 @@ +#include <stdarg.h> + +f (int n, ...) +{ + va_list args; + + va_start (args, n); + + if (va_arg (args, int) != 10) + abort (); + if (va_arg (args, long long) != 10000000000LL) + abort (); + if (va_arg (args, int) != 11) + abort (); + if (va_arg (args, long double) != 3.14L) + abort (); + if (va_arg (args, int) != 12) + abort (); + if (va_arg (args, int) != 13) + abort (); + if (va_arg (args, long long) != 20000000000LL) + abort (); + if (va_arg (args, int) != 14) + abort (); + if (va_arg (args, double) != 2.72) + abort (); + + va_end(args); +} + +main () +{ + f (4, 10, 10000000000LL, 11, 3.14L, 12, 13, 20000000000LL, 14, 2.72); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/execute/widechar-1.c b/gcc_arm/testsuite/gcc.c-torture/execute/widechar-1.c new file mode 100755 index 0000000..45b9d89 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/execute/widechar-1.c @@ -0,0 +1,14 @@ +#define C L'\400' + +#if C +#define zero (!C) +#else +#define zero C +#endif + +main() +{ + if (zero != 0) + abort (); + exit (0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/920507-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/920507-1.c new file mode 100755 index 0000000..e1bd993 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/920507-1.c @@ -0,0 +1 @@ +x(){register*a asm("fr1");int*v[1]={a};} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/920616-2.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/920616-2.c new file mode 100755 index 0000000..ddfa0de --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/920616-2.c @@ -0,0 +1 @@ +f(void a,...){} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/920721-2.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/920721-2.c new file mode 100755 index 0000000..4621983 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/920721-2.c @@ -0,0 +1 @@ +f(int n){int s;for(s=0;s<n;s++)s==5?1 n=1;} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/920824-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/920824-1.c new file mode 100755 index 0000000..36661f6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/920824-1.c @@ -0,0 +1 @@ +struct s{struct s{int i;}x;}; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/920923-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/920923-1.c new file mode 100755 index 0000000..52f8338 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/920923-1.c @@ -0,0 +1,36 @@ +typedef BYTE unsigned char;typedef int item_n;typedef int perm_set;struct +PENT{caddr_t v_addr;};typedef struct PENT prec;typedef struct PENT* +prec_t;prec_t mem_hash;BYTE*mem_base;struct PTE{BYTE*p_page;perm_set +p_perms;};typedef struct PTE pte;struct PTP{union{struct*PTP +p_tablep;struct*PTE p_entry;}u;int valid;};typedef struct PTP +(u.p_tablep);int pfree=0;int pcount=0;void mmu_walk_find(va)caddr_t va;{ +BYTE*page_addr;if(mmu_base[Level1(va)]->valid==0x0){l1_base= +mmu_base[Level1(va)]->(u.p_tablep)=p_alloc();mmu_base[Level1(va)]->valid= +0x3;for(idx=0;idx<LEVEL1_ENTRIES;idx++)l1_base[idx]->valid=0x0;goto +build_level2;}else l1_base=mmu_base[Level1(va)]->(u.p_tablep);if +(l1_base[Level2(va)]->valid==0x0){build_level2:l2_base= +l1_base[Level2(va)]->(u.p_tablep)=p_alloc();l1_base[Level2(va)]->valid= +0x3;for(idx=0;idx<LEVEL2_ENTRIES;idx++)l2_base[idx]->valid=0x0;goto +build_page;}else l2_base=mmu_base[Level2(va)]->(u.p_tablep); +page_addr=l2_base[Level2(va)]->valid;}void*a_translate(va_op,v_addr)int +va_op;caddr_t v_addr;{register prec_t bucket;register caddr_t p_addr; +bucket=mem_hash+((((v_addr)>>ITEMBITS))&hash_mask);do{if +(bucket->v_addr==((v_addr)>>ITEMBITS){if(!(bucket->perm_set&va_op)) +goto prot_fault;return mem_base+v_addr;}}while((bucket++)->v_addr!= +((caddr_t)0));page_miss:p_addr=(--bucket)->p_addr;page_type:switch +(p_addr){case BUCKET_FULL:enlarge_hash_table(mem_hash);case((caddr_t)0): +p_addr=fill_item_entry(va_op,v_addr);goto page_type;case((caddr_t)1): +default:((void)(((0))?0:(__eprintf("Failed assertion`%s'at line%d +of`%s'.\n","FALSE",327,"b.c"),0)));}}void flush_hash(hasht, +hash_size)prec_t hasht;int hash_size;{register prec_t bucket;register int +idx;bucket=hasht;for(idx=(hash_size*3)-1;idx>=0;idx--){ +bucket->v_addr=((caddr_t)0);bucket->p_addr=((caddr_t)0); +bucket->perm_set=VA_EMPTY;}}void init_mem(){mem_base=(BYTE*)calloc(1024 +,(1<<13));((void)((mem_base!=(BYTE*)0)?0:(__eprintf("Failed +assertion`%s'at line%d of`%s'.\n","mem_base!=(BYTE*)0",366,"b.c"), +0)));hash_num=INIT_NUM_ENTRIES*3;mem_hash=(prec_t)calloc(hash_num, +sizeof(prec));((void)((mem_hash!=(prec_t)0)?0:(__eprintf("Failed +assertion`%s'at line%d of`%s'.\n","mem_hash!=(prec_t)0",370,"b.c"), +0)));flush_hash(mem_hash,32);build_ptables(mem_base,1024*(1<<13));} +struct tm{int tm_sec;int tm_min;int tm_hour;int tm_mday;int tm_mon;int +tm_year;int tm_wday;int tm_yday;int tm_isdst;char*tm_zone;long tm_gmtoff;}; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/921102-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/921102-1.c new file mode 100755 index 0000000..3fb42f1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/921102-1.c @@ -0,0 +1 @@ +int x[]={[0.3 ... 4.6]9}; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/921116-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/921116-1.c new file mode 100755 index 0000000..78a75ea --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/921116-1.c @@ -0,0 +1 @@ +void a (void x) {} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/930301-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/930301-1.c new file mode 100755 index 0000000..de42714 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/930301-1.c @@ -0,0 +1,5 @@ +struct a *q; +f() +{ + q++; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-1.c new file mode 100755 index 0000000..27bb9eb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-1.c @@ -0,0 +1,6 @@ +f () +{ + double b; + b = b * 10; + goto c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-2.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-2.c new file mode 100755 index 0000000..a75e0c4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/930622-2.c @@ -0,0 +1,6 @@ +f () +{ + int i; + for (i--) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/930714-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/930714-1.c new file mode 100755 index 0000000..d940c55 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/930714-1.c @@ -0,0 +1,25 @@ +typedef union _yystype +{ + int i; + int *iptr; + int (*ifunc)(int); + void (*vfunc)(int); +} +YYSTYPE; + +extern int f1(int k); + +void test() +{ + YYSTYPE a; + int (*iptr)(int); + int foo[5]; + + a = f1; + a = (YYSTYPE)f1; + a = (YYSTYPE)foo; + a = (YYSTYPE)(int *)foo; + iptr = f1; + a = iptr; + a = (YYSTYPE)iptr; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/931203-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/931203-1.c new file mode 100755 index 0000000..1f5a8c3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/931203-1.c @@ -0,0 +1,11 @@ +typedef struct +{ + int x, y; +} point_t; + + +point_t +f () +{ + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940112-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/940112-1.c new file mode 100755 index 0000000..17dda8b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940112-1.c @@ -0,0 +1,7 @@ +double +f (int x) +{ + double e = 1; + e = 1; + return (e) +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940227-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/940227-1.c new file mode 100755 index 0000000..21bba6c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940227-1.c @@ -0,0 +1,5 @@ +struct font { + struct { + char *line,*ulmask; + } c[2]; +} character[1] = { { {"", ""}, {"", ""} } }; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940510-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/940510-1.c new file mode 100755 index 0000000..9882d15 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940510-1.c @@ -0,0 +1 @@ +struct { int a[]; } x = { 0 }; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.c new file mode 100755 index 0000000..b1b8234 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.c @@ -0,0 +1,14 @@ +/* PR 4713 */ + +#include "940712-1.h" +#include "940712-1a.h" +#include "940712-1b.h" + +/* comment start in comment error +/* in a .c file */ + +int main () +{ + return 0; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.h b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.h new file mode 100755 index 0000000..1838213 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1.h @@ -0,0 +1,10 @@ +/* comment start in comment error +/* in a .h file */ + +#if 0 +#endif /* comment start in comment error +/* after a cpp directive */ + +/* comment start in comment error + + diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1a.h b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1a.h new file mode 100755 index 0000000..55ab6b8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1a.h @@ -0,0 +1,4 @@ +/* spanning a .h file */ + +#if 0 +#endif /* comment start in comment error diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1b.h b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1b.h new file mode 100755 index 0000000..d75156c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/940712-1b.h @@ -0,0 +1,2 @@ +/* spanning a .h file */ + diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/950825-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/950825-1.c new file mode 100755 index 0000000..6104444 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/950825-1.c @@ -0,0 +1 @@ +main() { return (struct x) {{y: 0}}; } diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/950921-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/950921-1.c new file mode 100755 index 0000000..bcf2f05 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/950921-1.c @@ -0,0 +1,10 @@ +typedef enum +{ + a = (X) 0, + b +} c; + +typedef enum +{ + d = (X) 0 +} e; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/951025-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/951025-1.c new file mode 100755 index 0000000..6948872 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/951025-1.c @@ -0,0 +1 @@ +#include /\ diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/951123-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/951123-1.c new file mode 100755 index 0000000..e9ed3dc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/951123-1.c @@ -0,0 +1,2 @@ +struct S { int a; int b[2]; }; +struct S x = { 0, [0]; }; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/951227-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/951227-1.c new file mode 100755 index 0000000..7c449c8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/951227-1.c @@ -0,0 +1,2 @@ +#if 0xe-1 +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/971104-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/971104-1.c new file mode 100755 index 0000000..3f0996d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/971104-1.c @@ -0,0 +1,26 @@ +typedef unsigned short ushort; +struct sembuf { + ushort sem_num; + short sem_op; + short sem_flg; +}; +union semun { + int val; + struct semid_ds *buf; + ushort *array; + struct seminfo *__buf; + void *__pad; +}; +static union semun semctl_arg; +static int semid; +static void up(int sem){ + struct sembuf sb; + sb.sem_num = (unsigned short) sem; + sb.sem_op = 1; + sb.sem_flg = 0x1000 ; + if(semop(semid, &sb, 1) == -1) error("up failure"); + if(semctl(semid, sb.sem_num, 12 , semctl_arg) == 0) + printf("%s had processes sleeping on it!\n", + ({ "MUTEX ", "BARB_SEM 1", "BARB_SEM 2", "CUST_SEM 1", "CUST_SEM 2", "WA +IT_SEM 1", "WAIT_SEM 2", "WAIT_SEM 3", "WAIT_SEM 4"} [( sb.sem_num )]) ); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/noncompile/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/configure.in b/gcc_arm/testsuite/gcc.c-torture/noncompile/configure.in new file mode 100755 index 0000000..19f62f2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=noncompile.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/init-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/init-1.c new file mode 100755 index 0000000..52f43e8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/init-1.c @@ -0,0 +1,17 @@ +struct a +{ double a, b, c; }; + +struct b +{ + struct a arr[6]; +}; + +static struct b a_b = +{ + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0}, + {0,0,0}, +}; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/init-2.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/init-2.c new file mode 100755 index 0000000..52ee17b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/init-2.c @@ -0,0 +1 @@ +int d[][] = { {1}, {2}, {3} }; diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/invalid_asm.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/invalid_asm.c new file mode 100755 index 0000000..bb017f4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/invalid_asm.c @@ -0,0 +1 @@ +asm_invalid_register_name(){asm("":::"this_is_an_invalid_register_name");} diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/noncompile.exp b/gcc_arm/testsuite/gcc.c-torture/noncompile/noncompile.exp new file mode 100755 index 0000000..be7e234 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/noncompile.exp @@ -0,0 +1,306 @@ +# Copyright (C) 1988, 1990, 1991, 1992, 1997 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +# Please email any bugs, comments, and/or additions to this file to: +# bug-gcc@prep.ai.mit.edu + +# This file was written by Jeff Law. (law@cs.utah.edu) + +# +# These tests come from Torbjorn Granlund (tege@cygnus.com) +# C torture test suite. +# + +load_lib mike-gcc.exp + +# Test 920507-1.c +prebase + +set src_code 920507-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 920616-2.c +prebase + +set src_code 920616-2.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 920721-2.c +prebase + +set src_code 920721-2.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 920824-1.c +prebase + +set src_code 920824-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 920923-1.c +prebase + +set src_code 920923-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 921102-1.c +prebase + +set src_code 921102-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 921116-1.c +prebase + +set src_code 921116-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 930301-1.c +prebase + +set src_code 930301-1.c +set compiler_output ".*:4:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 930622-1.c +prebase + +set src_code 930622-1.c +set compiler_output ".*:5:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 930622-2.c +prebase + +set src_code 930622-2.c +set compiler_output ".*:4:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 930714-1.c +prebase + +set src_code 930714-1.c +# Not really sure what the error should be here... +set compiler_output ".*:18.*:23" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + +# Test 931203-1.c +prebase + +set src_code 931203-1.c +set compiler_output ".*:10" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 940112-1.c +prebase + +set src_code 940112-1.c +set compiler_output ".*:7" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 940227-1.c +prebase + +set src_code 940227-1.c +set compiler_output ".*:5.*:5" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 940510-1.c +prebase + +set src_code 940510-1.c +set compiler_output ".*:1.*:1" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 940712-1.c +prebase + +set src_code 940712-1.c +set compiler_output ".*:8.*:4" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 950825-1.c +prebase +set src_code 950825-1.c +set compiler_output ".*:1.*:1.*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 950921-1.c +prebase +set src_code 950921-1.c +set compiler_output ".*:3.*:3.*:9.*:9:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 951025-1.c +prebase +set src_code 951025-1.c +set compiler_output ".*:2:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 951123-1.c +prebase +set src_code 951123-1.c +set compiler_output ".*:2:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 951227-1.c +prebase +set src_code 951227-1.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test 971104-1.c +prebase +set src_code 971104-1.c +set compiler_output ".*:25:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test init-1.c +prebase +set src_code init-1.c +set compiler_output ".*:12.*:12.*:13.*:13.*:14.*:14.*:15.*:15.*:16.*:16:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test init-2.c +prebase +set src_code init-2.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test invalid_asm.c +prebase +set src_code invalid_asm.c +set compiler_output ".*:1:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups + + +# Test va-arg-1.c +# It is debatable if this test should be included at all. +# varags may be implemented by macros, which may not actually +# reference the bogus argument. +prebase + +set src_code va-arg-1.c +set compiler_output ".*:6:" + +set groups {passed gcc-noncompile} + +postbase $src_code $run $groups diff --git a/gcc_arm/testsuite/gcc.c-torture/noncompile/va-arg-1.c b/gcc_arm/testsuite/gcc.c-torture/noncompile/va-arg-1.c new file mode 100755 index 0000000..0285872 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/noncompile/va-arg-1.c @@ -0,0 +1,8 @@ +#include <stdarg.h> + +f (int x, ...) +{ + va_list args; + va_start (args, bogus_variable); + va_end (args); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920413-1.c b/gcc_arm/testsuite/gcc.c-torture/special/920413-1.c new file mode 100755 index 0000000..a3e0613 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920413-1.c @@ -0,0 +1 @@ +x(b){unsigned long c;c=4294967295U/(unsigned long)b;} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920520-1.c b/gcc_arm/testsuite/gcc.c-torture/special/920520-1.c new file mode 100755 index 0000000..6b1cd7b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920520-1.c @@ -0,0 +1 @@ +f(){asm("%0"::"r"(1.5F));}g(){asm("%0"::"r"(1.5));} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920521-1.c b/gcc_arm/testsuite/gcc.c-torture/special/920521-1.c new file mode 100755 index 0000000..95b9497 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920521-1.c @@ -0,0 +1 @@ +f(){asm("f":::"cc");}g(x,y){asm("g"::"%r"(x), "r"(y));} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920717-x.c b/gcc_arm/testsuite/gcc.c-torture/special/920717-x.c new file mode 100755 index 0000000..07601e3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920717-x.c @@ -0,0 +1,3 @@ +/* 920717-1.c */ + +const char s[]="foo"; diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920717-y.c b/gcc_arm/testsuite/gcc.c-torture/special/920717-y.c new file mode 100755 index 0000000..eaffa5e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920717-y.c @@ -0,0 +1,8 @@ +/* 920717-y.c */ + +extern const char s[]; + +main() +{ + puts(s); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/920730-1.c b/gcc_arm/testsuite/gcc.c-torture/special/920730-1.c new file mode 100755 index 0000000..d97d873 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/920730-1.c @@ -0,0 +1,32 @@ +/* 920730-1.c */ + +f1() +{ + int b=0x80000000; + return b>=0x80000000; +} + +f2() +{ + int b=0x80000001; + return b>=0x80000001; +} + +f3() +{ + int b=0x7fffffff; + return b>=0x7fffffff; +} + +f4() +{ + int b=0xffffffff; + return b>=0xffffffff; +} + +main () +{ + if((f1()&f2()&f3()&f4())!=1) + abort(); + exit(0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/921210-1.c b/gcc_arm/testsuite/gcc.c-torture/special/921210-1.c new file mode 100755 index 0000000..bbbf39a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/921210-1.c @@ -0,0 +1,4 @@ +#define a1(y) (y+1) +#define a2(y) a1(y)+1 +#define f a->f +a2(f) diff --git a/gcc_arm/testsuite/gcc.c-torture/special/930510-1.c b/gcc_arm/testsuite/gcc.c-torture/special/930510-1.c new file mode 100755 index 0000000..54ad858 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/930510-1.c @@ -0,0 +1,3 @@ +#define ugly 3 +#ugly "foobar" 3 /* { dg-error "invalid" "invalid directive" } */ +int main() { exit (0); } diff --git a/gcc_arm/testsuite/gcc.c-torture/special/951130-1.c b/gcc_arm/testsuite/gcc.c-torture/special/951130-1.c new file mode 100755 index 0000000..c06ba07 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/951130-1.c @@ -0,0 +1,2 @@ +unsigned long long x = -(unsigned long long)(-(long long)(((unsigned long +long)0 - 1) >> 1) - 1); diff --git a/gcc_arm/testsuite/gcc.c-torture/special/960224-1.c b/gcc_arm/testsuite/gcc.c-torture/special/960224-1.c new file mode 100755 index 0000000..de0a6ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/960224-1.c @@ -0,0 +1,6 @@ +#if 0 +#if 0 +#endif \ +\ + +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/special/960224-2.c b/gcc_arm/testsuite/gcc.c-torture/special/960224-2.c new file mode 100755 index 0000000..3d69694 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/960224-2.c @@ -0,0 +1,4 @@ +#if 0 +#if 0 +#endif / +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/special/981006-1.c b/gcc_arm/testsuite/gcc.c-torture/special/981006-1.c new file mode 100755 index 0000000..6af6d9a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/981006-1.c @@ -0,0 +1,50 @@ +/* Test that tablejump insns are correctly handled. If the compiler + loses track of the jump targets, it will report that x and y can be + used uninitialized. + + This is broken in egcs 1998/10/06 for mips in pic mode. */ +/* { dg-do compile } */ + +int foo (int a, int b) +{ + __label__ z; + int x; /* { dg-bogus "warning: `.' might be used uninitialized in this function" } */ + int y; /* { dg-bogus "warning: `.' might be used uninitialized in this function" } */ + static void *p; + + switch (a) { + case 2: + x = 4; + break; + case 4: + x = 6; + break; + case 8: case 10: case 13: case 11: case 17: case 19: + x = 7; + break; + default: + x = -1; + break; + } + switch (b) { + case 2: + y = 4; + break; + case 4: + y = 6; + break; + case 8: case 10: case 13: case 11: case 17: case 19: + y = 7; + break; + default: + y = -1; + break; + } + z: + p = &&z; + return x * y; +} +int main (int argc, char *argv[]) +{ + return 1 == foo (argc, argc + 1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/special/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/special/configure.in b/gcc_arm/testsuite/gcc.c-torture/special/configure.in new file mode 100755 index 0000000..b9cbac3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=special.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/special/eeprof-1.c b/gcc_arm/testsuite/gcc.c-torture/special/eeprof-1.c new file mode 100755 index 0000000..6dad7ec --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/eeprof-1.c @@ -0,0 +1,67 @@ +#define ASSERT(X) if (!(X)) abort (); +#define NOCHK __attribute__ ((no_instrument_function)) + +int entry_calls, exit_calls; +void (*last_fn_entered)(); +void (*last_fn_exited)(); + +int main () NOCHK; + +void foo () +{ + ASSERT (last_fn_entered == foo); +} + +static void foo2 () +{ + ASSERT (entry_calls == 1 && exit_calls == 0); + ASSERT (last_fn_entered == foo2); + foo (); + ASSERT (entry_calls == 2 && exit_calls == 1); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo); +} + +void nfoo (void) NOCHK; +void nfoo () +{ + ASSERT (entry_calls == 2 && exit_calls == 2); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo2); + foo (); + ASSERT (entry_calls == 3 && exit_calls == 3); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo); +} + +int main () +{ + ASSERT (entry_calls == 0 && exit_calls == 0); + + foo2 (); + + ASSERT (entry_calls == 2 && exit_calls == 2); + ASSERT (last_fn_entered == foo); + ASSERT (last_fn_exited == foo2); + + nfoo (); + + ASSERT (entry_calls == 3 && exit_calls == 3); + ASSERT (last_fn_entered == foo); + + return 0; +} + +void __cyg_profile_func_enter (void (*fn)(), void (*parent)()) NOCHK; +void __cyg_profile_func_exit (void (*fn)(), void (*parent)()) NOCHK; + +void __cyg_profile_func_enter (void (*fn)(), void (*parent)()) +{ + entry_calls++; + last_fn_entered = fn; +} +void __cyg_profile_func_exit (void (*fn)(), void (*parent)()) +{ + exit_calls++; + last_fn_exited = fn; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/special/special.exp b/gcc_arm/testsuite/gcc.c-torture/special/special.exp new file mode 100755 index 0000000..a2ef927 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/special/special.exp @@ -0,0 +1,119 @@ +# Copyright (C) 1988, 90-96, 1997 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +# Please email any bugs, comments, and/or additions to this file to: +# bug-gcc@prep.ai.mit.edu + +# This file was written by Rob Savoye. (rob@cygnus.com) + +# +# These tests come from Torbjorn Granlund (tege@cygnus.com) +# C torture test suite. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp +load_lib gcc-dg.exp + +################## ADD NEXT CASE HERE (NOT AT THE END) ################## + +# 981006-1 +# For MIPS at least, pic is needed to trigger the problem. +dg-init +# CYGNUS LOCAL nickc/fr30 +if { [istarget rs6000-*-aix*] + || [istarget powerpc*-*-aix*] + || [istarget arm*-*-*] + || [istarget fr30-*-*] +} { + set extra_flags "" +} else { + set extra_flags "-fpic" +} +# END CYGNUS LOCAL +dg-runtest $srcdir/$subdir/981006-1.c "-Wuninitialized -O2 $extra_flags" "" +dg-finish + +# 921210-1 +set lines [gcc_target_compile $srcdir/$subdir/921210-1.c "" preprocess ""] +set lines [prune [split [prune_warnings [prune_gcc_output $lines]] "\n"] ""] +set line [lindex $lines [expr [llength $lines]-1]] +regsub -all " " $line "" clean +if [expr [string compare $clean "(a->f+1)+1"]==0] then { + pass "921210-1.c" +} else { + fail "921210-1.c" +} + +# 920521-1 +c-torture 920521-1.c "-S" + +# 920520-1 +c-torture 920520-1.c "-S" + +# 920717-1 +if [isnative] then { + set lines [gcc_target_compile "$srcdir/$subdir/920717-x.c" "920717-x.o" object {additional_flags="-w"}] + if ![string match "" $lines] then { + fail "920717-x.c" + } else { + # This is a completely bogus test. Sorry. + catch exec "rm -f 920717-y.o" + send_log "cc -c $srcdir/$subdir/920717-y.c 2>/dev/null >/dev/null\n" + catch exec "cc -c $srcdir/$subdir/920717-y.c 2>/dev/null >/dev/null" + if ![file exists "920717-y.o"] then { + send_log "c89 -c $srcdir/$subdir/920717-y.c 2>/dev/null >/dev/null\n" + catch exec "c89 -c $srcdir/$subdir/920717-y.c 2>/dev/null >/dev/null" + } + if [file exists "920717-y.o"] then { + set lines [gcc_target_compile "920717-y.o x.o" "x" executable ""] + if [string match "" $lines] then { + pass "920717-1.c" + } else { + fail "920717-1.c" + } + } + } +} + +# 920730-1 +if [isnative] then { + c-torture "920730-1.c" + c-torture "920730-1.c" "-traditional" +} + +# 920413-1 +c-torture 920413-1.c "-Wtraditional" + +# 930510-1 +dg-init +dg-runtest $srcdir/$subdir/930510-1.c "" "" +dg-finish + +# 951130-1 +c-torture 951130-1.c "-Werror" + +# 960224-1 +c-torture 960224-1.c "-E -ansi -pedantic-errors" + +# 960224-2 +#c-torture 960224-2.c "-E -ansi -pedantic-errors" + +c-torture-execute $srcdir/$subdir/eeprof-1.c "-finstrument-functions" diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/386.c new file mode 100755 index 0000000..432cdad --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/386.c @@ -0,0 +1,23 @@ +foo (a, p) + int *p; +{ + p[0] = a; + a = (short) a; + return a; +} + +main () +{ + int i; + foobar (i, &i); +} + + +foobar (a, b) +{ + int c; + + c = a % b; + a = a / b; + return a + b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/86.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/86.c new file mode 100755 index 0000000..deea85e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/86.c @@ -0,0 +1,19 @@ +m32 (a) + int *a; +{ + a[1] = a[0]; +} + +m16 (a) + short *a; +{ + a[1] = a[0]; +} + + +m8 (a) + char *a; +{ + a[1] = a[0]; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG1.c new file mode 100755 index 0000000..ada8eaf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG1.c @@ -0,0 +1,37 @@ +struct _XtTextSource { + /* ... */ + void (* SetSelection)(); + /* ... */ + }; + +typedef struct _XtTextSource *XtTextSource; + +typedef struct _TextPart { + XtTextSource source; + /* ... */ +} TextPart; + +typedef struct _TextRec { + /* ... */ + TextPart text; +} TextRec; + +typedef struct _TextRec *TextWidget; + + +void XtTextUnsetSelection(w) + TextWidget w; /* original is: Widget w; */ +{ + register TextWidget ctx = (TextWidget) w; + void (*nullProc)() = 0; + +/* + * the following line causes the error, when optimizing: + */ + + if (ctx->text.source->SetSelection != nullProc) { + + foo(); + + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG11.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG11.c new file mode 100755 index 0000000..fe2923a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG11.c @@ -0,0 +1,29 @@ +#define DD 2410065408 + +unsigned +foo (d) + double d; +{ + return d; +} + +#if foobar + +main () +{ +#if bar + unsigned u = DD; + double d = (double) u; +#else + double d = (double) DD; +#endif + printf ("%u = %u = %lf\n", foo ((double) DD), foo (d), d); +} +#else + +main () +{ + printf ("%lf\n", (double) ((unsigned) DD)); + foo ((double) DD); +} +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG12.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG12.c new file mode 100755 index 0000000..b32fa60 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG12.c @@ -0,0 +1,5 @@ +long long +main () +{ + return 1.1e10; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG13.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG13.c new file mode 100755 index 0000000..9a302b9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG13.c @@ -0,0 +1,19 @@ +struct tree_common +{ + int uid; + unsigned int code : 8; + unsigned int code2 : 8; + unsigned external_attr : 1; + unsigned public_attr : 1; + +}; + +static int +duplicate_decls (x) + register struct tree_common *x; +{ + if (x->external_attr) + if (x->code) + if (x->code2) + x->public_attr = 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG16.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG16.c new file mode 100755 index 0000000..daeae2c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG16.c @@ -0,0 +1,6 @@ +setgetlen (a) + int *a; +{ + while (*a++ & 0x80000000) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG17.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG17.c new file mode 100755 index 0000000..9205870 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG17.c @@ -0,0 +1,8 @@ +double d; + +main() +{ + int i; + + i = (int) d; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG18.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG18.c new file mode 100755 index 0000000..ed586a7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG18.c @@ -0,0 +1,5 @@ +main() +{ + if ((signed int) 1 < (signed int) -2147483648) + printf("true\n"); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG2.c new file mode 100755 index 0000000..6dc30be --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG2.c @@ -0,0 +1,8 @@ +BUG2 (p) int *p; +{ + int a = 0; + if (*p == a) + return 0; + else + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG21.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG21.c new file mode 100755 index 0000000..c8a1157 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG21.c @@ -0,0 +1,22 @@ +typedef struct { + int knock_on_wood; /* leave it out and it works. */ + int f1; +} FOO; + +typedef struct { + FOO *b1; +} BAR; + +Nase () +{ + int i, j; + FOO *foop; + BAR *barp; + + for (i = 0; i < 2; i++) { + foop = &barp->b1[i]; + for (j = 0; j < foop->f1; j++) { + /* dummy() */; /* put it in and it works. */ + } + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG22.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG22.c new file mode 100755 index 0000000..9fd9525 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG22.c @@ -0,0 +1,6 @@ + +void +Rotate (float angle) +{ + float mag = (angle < 0) ? -angle : angle; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG23.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG23.c new file mode 100755 index 0000000..1ff429e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG23.c @@ -0,0 +1,18 @@ +main() +{ + static char static_char_array[1]; + static char *static_char_pointer; + static char static_char; + char char_array[1]; + char *char_pointer; + char character; + + char *cp, c; + + c = cp - static_char_array; /* error */ + c = cp - static_char_pointer; + c = cp - &static_char; /* error */ + c = cp - char_array; + c = cp - char_pointer; + c = cp - &character; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG24.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG24.c new file mode 100755 index 0000000..7627a3d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG24.c @@ -0,0 +1,15 @@ +struct ack { + char a, b, c; +}; + +main() +{ + struct ack bad; + + foo(bad); +} + +foo(c) + struct ack c; +{ +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG25.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG25.c new file mode 100755 index 0000000..5744170 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG25.c @@ -0,0 +1,5 @@ + +foo (a) +{ + __builtin_ffs (a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG3.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG3.c new file mode 100755 index 0000000..30e6622 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG3.c @@ -0,0 +1,8 @@ +BUG2 (p) char *p; +{ + int a = 0; + if (*p == a) + return 0; + else + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG4.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG4.c new file mode 100755 index 0000000..be6a149 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG4.c @@ -0,0 +1,20 @@ +int foo() +{ + char c; + + return (c ^ 30 ) > (c ^ 40 ); +/* + these also get the signal : + return (c ^ 30 ) == (c ^ 40 ); + return ((int)c ^ 30 ) > (c ^ 40 ); + also fails if c is "extern char" + + these are ok : + return (c + 30 ) > (c ^ 40 ); + return (c ^ 30 ) > (c + 40 ); + return (c ^ 30 ) + (c ^ 40 ); + return ('a' ^ 30 ) > (c ^ 40 ); + return (c ^ 40 ); + return (c ^ 30 ) > (c ^ 40 ); +*/ +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG5.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG5.c new file mode 100755 index 0000000..9bed713 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG5.c @@ -0,0 +1,18 @@ +enum bar +{ + one, + two +}; + +enum bar foo; + +void bar() +{ + switch (foo) + { + case one: + case two: + printf ("one to two\n"); + break; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG6.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG6.c new file mode 100755 index 0000000..b139465 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/BUG6.c @@ -0,0 +1,8 @@ +main() +{ + unsigned long L; + double D; + D = L = -3; + printf("L=%lu, D=%g\n", L, D); + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/DFcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/DFcmp.c new file mode 100755 index 0000000..b32b0ec --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/DFcmp.c @@ -0,0 +1,280 @@ +#define type double + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)((int)&glob0)) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)((int)&glob1)) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/HIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/HIcmp.c new file mode 100755 index 0000000..eea3984 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/HIcmp.c @@ -0,0 +1,280 @@ +#define type short + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/HIset.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/HIset.c new file mode 100755 index 0000000..8108fbb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/HIset.c @@ -0,0 +1,216 @@ +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type short + +reg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = reg1; } + +reg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = indreg1; } + +reg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = imm1; } + +reg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = limm1; } + +reg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adr1; } + +reg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrreg1; } + +reg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrx1; } + +reg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = regx1; } + +indreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = reg1; } + +indreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = indreg1; } + +indreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = imm1; } + +indreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = limm1; } + +indreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adr1; } + +indreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrreg1; } + +indreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrx1; } + +indreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = regx1; } + +adr0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = reg1; } + +adr0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = indreg1; } + +adr0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = imm1; } + +adr0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = limm1; } + +adr0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adr1; } + +adr0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrreg1; } + +adr0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrx1; } + +adr0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = regx1; } + +adrreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = reg1; } + +adrreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = indreg1; } + +adrreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = imm1; } + +adrreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = limm1; } + +adrreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adr1; } + +adrreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrreg1; } + +adrreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrx1; } + +adrreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = regx1; } + +adrx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = reg1; } + +adrx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = indreg1; } + +adrx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = imm1; } + +adrx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = limm1; } + +adrx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adr1; } + +adrx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrreg1; } + +adrx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrx1; } + +adrx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = regx1; } + +regx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = reg1; } + +regx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = indreg1; } + +regx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = imm1; } + +regx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = limm1; } + +regx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adr1; } + +regx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrreg1; } + +regx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrx1; } + +regx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = regx1; } + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/Makefile.in b/gcc_arm/testsuite/gcc.c-torture/unsorted/Makefile.in new file mode 100755 index 0000000..e6209db --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/Makefile.in @@ -0,0 +1,12 @@ +#### host, target, and site specific Makefile frags come in here. + +srcdir = . + +# Nothing to do... +all: + +clean: + -rm -f *.o *.diff *~ *.bad core *.x + +distclean: clean + -rm -f Makefile config.status diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/PYRBUG.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/PYRBUG.c new file mode 100755 index 0000000..c64c3f5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/PYRBUG.c @@ -0,0 +1,17 @@ +typedef struct +{ + int v; + int h; +} Point; + +typedef struct +{ + int top, left, bottom, right; +} Rect; + +int +x_PtInRect (Point pt, Rect *r) +{ + return pt.v >= r->top && pt.v < r->bottom + && pt.h >= r->left && pt.h < r->right; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/QIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/QIcmp.c new file mode 100755 index 0000000..c516164 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/QIcmp.c @@ -0,0 +1,280 @@ +#define type signed char + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/QIset.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/QIset.c new file mode 100755 index 0000000..212609d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/QIset.c @@ -0,0 +1,216 @@ +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type char + +reg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = reg1; } + +reg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = indreg1; } + +reg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = imm1; } + +reg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = limm1; } + +reg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adr1; } + +reg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrreg1; } + +reg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrx1; } + +reg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = regx1; } + +indreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = reg1; } + +indreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = indreg1; } + +indreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = imm1; } + +indreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = limm1; } + +indreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adr1; } + +indreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrreg1; } + +indreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrx1; } + +indreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = regx1; } + +adr0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = reg1; } + +adr0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = indreg1; } + +adr0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = imm1; } + +adr0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = limm1; } + +adr0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adr1; } + +adr0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrreg1; } + +adr0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrx1; } + +adr0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = regx1; } + +adrreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = reg1; } + +adrreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = indreg1; } + +adrreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = imm1; } + +adrreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = limm1; } + +adrreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adr1; } + +adrreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrreg1; } + +adrreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrx1; } + +adrreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = regx1; } + +adrx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = reg1; } + +adrx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = indreg1; } + +adrx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = imm1; } + +adrx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = limm1; } + +adrx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adr1; } + +adrx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrreg1; } + +adrx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrx1; } + +adrx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = regx1; } + +regx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = reg1; } + +regx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = indreg1; } + +regx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = imm1; } + +regx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = limm1; } + +regx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adr1; } + +regx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrreg1; } + +regx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrx1; } + +regx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = regx1; } + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/SFset.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/SFset.c new file mode 100755 index 0000000..ad3e41b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/SFset.c @@ -0,0 +1,216 @@ +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type float + +reg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = reg1; } + +reg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = indreg1; } + +reg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = imm1; } + +reg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = limm1; } + +reg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adr1; } + +reg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrreg1; } + +reg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrx1; } + +reg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = regx1; } + +indreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = reg1; } + +indreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = indreg1; } + +indreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = imm1; } + +indreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = limm1; } + +indreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adr1; } + +indreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrreg1; } + +indreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrx1; } + +indreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = regx1; } + +adr0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = reg1; } + +adr0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = indreg1; } + +adr0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = imm1; } + +adr0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = limm1; } + +adr0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adr1; } + +adr0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrreg1; } + +adr0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrx1; } + +adr0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = regx1; } + +adrreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = reg1; } + +adrreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = indreg1; } + +adrreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = imm1; } + +adrreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = limm1; } + +adrreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adr1; } + +adrreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrreg1; } + +adrreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrx1; } + +adrreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = regx1; } + +adrx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = reg1; } + +adrx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = indreg1; } + +adrx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = imm1; } + +adrx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = limm1; } + +adrx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adr1; } + +adrx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrreg1; } + +adrx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrx1; } + +adrx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = regx1; } + +regx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = reg1; } + +regx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = indreg1; } + +regx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = imm1; } + +regx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = limm1; } + +regx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adr1; } + +regx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrreg1; } + +regx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrx1; } + +regx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = regx1; } + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/SIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/SIcmp.c new file mode 100755 index 0000000..30e0739 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/SIcmp.c @@ -0,0 +1,280 @@ +#define type int + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/SIset.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/SIset.c new file mode 100755 index 0000000..74a51cd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/SIset.c @@ -0,0 +1,216 @@ +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type int + +reg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = reg1; } + +reg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = indreg1; } + +reg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = imm1; } + +reg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = limm1; } + +reg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adr1; } + +reg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrreg1; } + +reg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = adrx1; } + +reg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{reg0 = regx1; } + +indreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = reg1; } + +indreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = indreg1; } + +indreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = imm1; } + +indreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = limm1; } + +indreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adr1; } + +indreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrreg1; } + +indreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = adrx1; } + +indreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{indreg0 = regx1; } + +adr0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = reg1; } + +adr0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = indreg1; } + +adr0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = imm1; } + +adr0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = limm1; } + +adr0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adr1; } + +adr0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrreg1; } + +adr0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = adrx1; } + +adr0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adr0 = regx1; } + +adrreg0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = reg1; } + +adrreg0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = indreg1; } + +adrreg0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = imm1; } + +adrreg0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = limm1; } + +adrreg0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adr1; } + +adrreg0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrreg1; } + +adrreg0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = adrx1; } + +adrreg0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrreg0 = regx1; } + +adrx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = reg1; } + +adrx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = indreg1; } + +adrx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = imm1; } + +adrx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = limm1; } + +adrx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adr1; } + +adrx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrreg1; } + +adrx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = adrx1; } + +adrx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{adrx0 = regx1; } + +regx0reg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = reg1; } + +regx0indreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = indreg1; } + +regx0imm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = imm1; } + +regx0limm1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = limm1; } + +regx0adr1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adr1; } + +regx0adrreg1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrreg1; } + +regx0adrx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = adrx1; } + +regx0regx1_set (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{regx0 = regx1; } + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/UHIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/UHIcmp.c new file mode 100755 index 0000000..1e969e7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/UHIcmp.c @@ -0,0 +1,280 @@ +#define type unsigned short + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/UQIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/UQIcmp.c new file mode 100755 index 0000000..3e9cdeb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/UQIcmp.c @@ -0,0 +1,280 @@ +#define type unsigned char + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/USIcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/USIcmp.c new file mode 100755 index 0000000..e217526 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/USIcmp.c @@ -0,0 +1,280 @@ +#define type unsigned int + +type glob0, glob1; + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +reg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= reg1) return 1; else return 0;} + +reg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= indreg1) return 1; else return 0;} + +reg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= imm1) return 1; else return 0;} + +reg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= limm1) return 1; else return 0;} + +reg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adr1) return 1; else return 0;} + +reg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrreg1) return 1; else return 0;} + +reg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= adrx1) return 1; else return 0;} + +reg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (reg0 <= regx1) return 1; else return 0;} + +indreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= reg1) return 1; else return 0;} + +indreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= indreg1) return 1; else return 0;} + +indreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= imm1) return 1; else return 0;} + +indreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= limm1) return 1; else return 0;} + +indreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adr1) return 1; else return 0;} + +indreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrreg1) return 1; else return 0;} + +indreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= adrx1) return 1; else return 0;} + +indreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (indreg0 <= regx1) return 1; else return 0;} + +imm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= reg1) return 1; else return 0;} + +imm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= indreg1) return 1; else return 0;} + +imm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= imm1) return 1; else return 0;} + +imm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= limm1) return 1; else return 0;} + +imm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adr1) return 1; else return 0;} + +imm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrreg1) return 1; else return 0;} + +imm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= adrx1) return 1; else return 0;} + +imm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (imm0 <= regx1) return 1; else return 0;} + +limm0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= reg1) return 1; else return 0;} + +limm0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= indreg1) return 1; else return 0;} + +limm0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= imm1) return 1; else return 0;} + +limm0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= limm1) return 1; else return 0;} + +limm0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adr1) return 1; else return 0;} + +limm0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrreg1) return 1; else return 0;} + +limm0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= adrx1) return 1; else return 0;} + +limm0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (limm0 <= regx1) return 1; else return 0;} + +adr0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= reg1) return 1; else return 0;} + +adr0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= indreg1) return 1; else return 0;} + +adr0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= imm1) return 1; else return 0;} + +adr0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= limm1) return 1; else return 0;} + +adr0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adr1) return 1; else return 0;} + +adr0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrreg1) return 1; else return 0;} + +adr0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= adrx1) return 1; else return 0;} + +adr0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adr0 <= regx1) return 1; else return 0;} + +adrreg0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= reg1) return 1; else return 0;} + +adrreg0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= indreg1) return 1; else return 0;} + +adrreg0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= imm1) return 1; else return 0;} + +adrreg0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= limm1) return 1; else return 0;} + +adrreg0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adr1) return 1; else return 0;} + +adrreg0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrreg1) return 1; else return 0;} + +adrreg0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= adrx1) return 1; else return 0;} + +adrreg0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrreg0 <= regx1) return 1; else return 0;} + +adrx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= reg1) return 1; else return 0;} + +adrx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= indreg1) return 1; else return 0;} + +adrx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= imm1) return 1; else return 0;} + +adrx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= limm1) return 1; else return 0;} + +adrx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adr1) return 1; else return 0;} + +adrx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrreg1) return 1; else return 0;} + +adrx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= adrx1) return 1; else return 0;} + +adrx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (adrx0 <= regx1) return 1; else return 0;} + +regx0reg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= reg1) return 1; else return 0;} + +regx0indreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= indreg1) return 1; else return 0;} + +regx0imm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= imm1) return 1; else return 0;} + +regx0limm1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= limm1) return 1; else return 0;} + +regx0adr1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adr1) return 1; else return 0;} + +regx0adrreg1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrreg1) return 1; else return 0;} + +regx0adrx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= adrx1) return 1; else return 0;} + +regx0regx1 (r0, r1, x0, x1, p0, p1) +type r0, r1; type *p0, *p1; +{if (regx0 <= regx1) return 1; else return 0;} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/a.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/a.c new file mode 100755 index 0000000..47fb1f4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/a.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a & 65535; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/a1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/a1.c new file mode 100755 index 0000000..654781d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/a1.c @@ -0,0 +1,7 @@ +int +foo (a, p) + int *p; +{ + p[0] = 85 * a; + p[1] = -86 * a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/a3.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/a3.c new file mode 100755 index 0000000..85d2a24 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/a3.c @@ -0,0 +1,12 @@ +foo (a) +{ + int i; + + for (i = 1; i < a; i++) + ; + { + int b = (int) &foo; + + return (a & b) == 0; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/aa.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/aa.c new file mode 100755 index 0000000..61a4147 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/aa.c @@ -0,0 +1,8 @@ +#define w 20 +#define c 1 + +foo (a) + unsigned a; +{ + return ((a & ((1 << w) - 1)) << c) > 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/aaa.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/aaa.c new file mode 100755 index 0000000..e31fb56 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/aaa.c @@ -0,0 +1,11 @@ +foo (a, b) +{ + int t; + while (b < 0) + { + t = a; + a = b; + b = t; + } + return a + b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/abs.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/abs.c new file mode 100755 index 0000000..6a746b1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/abs.c @@ -0,0 +1,9 @@ +foo (a) +{ + return __builtin_abs (a); +} + +main () +{ + printf ("%d %d\n", foo (0x80000000), foo (12)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ac.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ac.c new file mode 100755 index 0000000..1d3c085 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ac.c @@ -0,0 +1,30 @@ +barfoo (a) +{ + return (a << 16) & ~0xffff; +} + +foobar (a) +{ + return ((unsigned short) a) << 15;} + +foo (a) +{ + return (a & 0x121) << 31; +} + +bar (a) +{ + return (a & ~0xffff) << 16; +} + +main () +{ + int a; + + for (a = 1; a; a += a) + { + printf ("%d", (foo (a))); + } + puts (""); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/acc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/acc.c new file mode 100755 index 0000000..a4a027a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/acc.c @@ -0,0 +1,8 @@ +foo (a) +{ + int b = a + 1; + int c = (short) a; + if (b) + return b; + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/add.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/add.c new file mode 100755 index 0000000..d796e41 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/add.c @@ -0,0 +1,5 @@ +foo (a, b, p) + int *p; +{ + return 34 + *p; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/add386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/add386.c new file mode 100755 index 0000000..bfdffbf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/add386.c @@ -0,0 +1,4 @@ +main (a) +{ + return a + 128; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/addcc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/addcc.c new file mode 100755 index 0000000..cf52307 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/addcc.c @@ -0,0 +1,18 @@ +foo (p, a, b) + int *p; + int a; + int b; +{ + + a += p[0]; + b += p[1]; + if (a == 0) + return b; + return a; +} + + +bar (a) +{ + return -a > 0 ? 1 : 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andm.c new file mode 100755 index 0000000..17101ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andm.c @@ -0,0 +1,15 @@ +foo (p) + int *p; +{ + return (*p & 255) == 0; +} + +bar (a) +{ + return (a & 0xfff00000) == 0; +} + +main () +{ + printf ("%d%d\n", bar (-1), bar(0)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andmem.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andmem.c new file mode 100755 index 0000000..10bad00 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andmem.c @@ -0,0 +1,22 @@ +void p1 (p) int *p; +{ *p &= ~0xff; +} +void p2 (p) int *p; +{ *p &= ~0xff00; +} +void p3 (p) int *p; +{ *p &= ~0xffff0000; +} +void p4 (p) int *p; +{ *p &= ~0xffff; +} + +main () +{ + int a; + + a = 0x12345678; p1 (&a); printf ("%x\n", a); + a = 0x12345678; p2 (&a); printf ("%x\n", a); + a = 0x12345678; p3 (&a); printf ("%x\n", a); + a = 0x12345678; p4 (&a); printf ("%x\n", a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andn.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andn.c new file mode 100755 index 0000000..2e38dd0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andn.c @@ -0,0 +1,5 @@ +foo (a) +{ + int b = 0x1fff; + return a & ~b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andok.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andok.c new file mode 100755 index 0000000..d55bd01 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andok.c @@ -0,0 +1,6 @@ +foo (a, b, p) + int *p; +{ + p[1] = a & 0xfff0000; + p[2] = b & 0xfff0000; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andsi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andsi.c new file mode 100755 index 0000000..b9c3c76 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andsi.c @@ -0,0 +1,4 @@ +foo () +{ + return (int)&foo; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/andsparc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/andsparc.c new file mode 100755 index 0000000..62f0de0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/andsparc.c @@ -0,0 +1,11 @@ +foo (int *p) +{ + int a, b; + + a = 123456; + a += p[0]; + b = p[0]; + if (a == 0) + return b; + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/aos.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/aos.c new file mode 100755 index 0000000..77c92f6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/aos.c @@ -0,0 +1,8 @@ +foo (p) + int *p; +{ + if ((int) p > 0) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/arr.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/arr.c new file mode 100755 index 0000000..ed56667 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/arr.c @@ -0,0 +1,9 @@ +foo (a, b, c) +{ + bar (a, b); + { + int arr[10]; + arr[c] = b; + bar (arr[0], arr[1]); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/as.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/as.c new file mode 100755 index 0000000..172f883 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/as.c @@ -0,0 +1,14 @@ + +#define S 31 +#define A 17 + +foo (a) + unsigned a; +{ + return (a >> S) & ((1 << A) - 1); +} + +main () +{ + printf ("%d%d\n", foo (-1), foo (0)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ase.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ase.c new file mode 100755 index 0000000..2d3d8ed --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ase.c @@ -0,0 +1,10 @@ +ase (p) + short *p; +{ + int a; + a = p[1]; + p[2] = a; + if ((short) a) + p[a]++; + return (a == 0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/b.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/b.c new file mode 100755 index 0000000..498d755 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/b.c @@ -0,0 +1,4 @@ +main () +{ + *(short *) 25 = 123; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/b1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/b1.c new file mode 100755 index 0000000..b673759 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/b1.c @@ -0,0 +1,11 @@ +foo (long long x) +{ + if (x--) + return 255; + return 0; +} + +main () +{ + printf ("%d\n", foo (0)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/b2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/b2.c new file mode 100755 index 0000000..96e4556 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/b2.c @@ -0,0 +1,24 @@ + +struct s +{ + unsigned a : 8; + unsigned b : 8; + unsigned c : 8; + unsigned d : 8; +}; + +/* +struct +{ + unsigned a : 8; + unsigned b : 16; + unsigned c : 8; +}; +*/ + +struct s +foo (struct s s, int i) +{ + s.b = i; + return s; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/b3.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/b3.c new file mode 100755 index 0000000..af693f7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/b3.c @@ -0,0 +1,12 @@ +struct tree_common +{ + unsigned int code : 9; + unsigned int code2 : 7; +}; + +static int +duplicate_decls (x) + register struct tree_common x; +{ + return x.code2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/b88.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/b88.c new file mode 100755 index 0000000..971c7c7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/b88.c @@ -0,0 +1,12 @@ +foo (double d) +{ + d = -d; + if (d < 0.0) + return 1; + return 2; +} + +main () +{ + foo (0.0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bad.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bad.c new file mode 100755 index 0000000..8cc8497 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bad.c @@ -0,0 +1,26 @@ +typedef union longlong +{ + struct {unsigned short h0, h1, h2, h3;} h; + struct {signed long low, high;} si; + struct {unsigned long low, high;} ui; + signed long long sll; + unsigned long long ull; +} long_long; + + +long long +__negdi2 (u) + long long u; +{ + long_long uu; + + uu.sll = u; + + uu.si.low = -uu.si.low; + if (uu.si.low == 0) + uu.si.high = -uu.si.high; + else + uu.si.high = ~uu.si.high; + + return uu.sll; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/band.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/band.c new file mode 100755 index 0000000..74b02fd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/band.c @@ -0,0 +1,16 @@ +foo (a) +{ + return (a & (1 << 31)) != 0; +} + +main () +{ + if (foo (0)) + puts ("foo"); + else + puts ("bar"); + if (foo (~0)) + puts ("foo"); + else + puts ("bar"); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bb0.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bb0.c new file mode 100755 index 0000000..aab6d68 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bb0.c @@ -0,0 +1,5 @@ +foo (a) +{ + return (a & 0xfff000) != 0; + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bb1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bb1.c new file mode 100755 index 0000000..3f9aebe --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bb1.c @@ -0,0 +1,8 @@ +foo (a) +{ + int b = 32; + if (b & a) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bbb.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bbb.c new file mode 100755 index 0000000..837dd9e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bbb.c @@ -0,0 +1,12 @@ +struct looksets + { + int lset[10]; + }; + +struct looksets lkst[]; + +flset( p ) +struct looksets *p; +{ + p-- > lkst; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bc.c new file mode 100755 index 0000000..c713bb6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bc.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a % (1 << b); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bcopy.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bcopy.c new file mode 100755 index 0000000..1732b34 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bcopy.c @@ -0,0 +1,64 @@ +void +bcopy1 (s, d, c) + long long *s; + long long *d; + int c; +{ + int i; + c = c / 8; + for (i = 0; i < c; i++) + d[i] = s[i]; +} + +void +bcopy2 (s, d, c) + long *s; + long *d; + int c; +{ + int i; + c = c / 4; + for (i = 0; i < c; i++) + d[i] = s[i]; +} + + +void +bcopy3 (s, d, c) + char *s; + char *d; + int c; +{ + long long z0, z1; + int r = d - s; + + int i; + + c /= 16; + + z0 = *((long long *) s); + s += 8; + z1 = *((long long *) s); + s += 8; + for (i = 0; i < c; i++) + { + *(long long *)(s + r) = z0; + z0 = *((long long *) s); + s += 8; + *(long long *)(s + r) = z1; + z1 = *((long long *) s); + s += 8; + } +} + +#define BYTES 16384 + +main () +{ + long long s[BYTES / 8]; + long long d[BYTES / 8]; + int i; + + for (i = 1; i < 67108864 / BYTES; i++) + bcopy (s, d, BYTES); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bf.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bf.c new file mode 100755 index 0000000..821623d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bf.c @@ -0,0 +1,31 @@ +typedef unsigned long uint32; +typedef signed long sint32; + +uint32 +ext (sint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src >> o5 : (src << (( - o5 - w5) & 31)) >> (32 - w5); +} + +uint32 +extu (uint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src >> o5 : (src << (( - o5 - w5) & 31)) >> (32 - w5); +} + +uint32 +mak (uint32 src, unsigned o5, unsigned w5) +{ + return (w5 == 0) ? src << o5 : (src << (32 - w5)) >> (( - o5 - w5) & 31); +} + +uint32 +rot (uint32 src, unsigned o5) +{ + return (src >> o5) | (src << (( - o5) & 31)); +} + +main (int argc, char **argv) +{ + printf ("%x\n", clr (0xffffffff, atoi (argv[2]), atoi (argv[1]))); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bfins.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bfins.c new file mode 100755 index 0000000..e626d82 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bfins.c @@ -0,0 +1,15 @@ +struct foo +{ + unsigned j : 16; + unsigned i : 16; +}; + +struct foo +foo (a, b) + struct foo a; + int b; +{ + a.j = 123; + a.i = b; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bfx.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bfx.c new file mode 100755 index 0000000..d47bd7d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bfx.c @@ -0,0 +1,9 @@ +foo (x, c) +{ + return x << -c; +} + +main () +{ + printf ("%x\n", foo (0xf05, -4)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bge.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bge.c new file mode 100755 index 0000000..55f4788 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bge.c @@ -0,0 +1,7 @@ +foo (a) + double a; +{ + if (a >= 0) + return 1; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bit.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bit.c new file mode 100755 index 0000000..e76bb45 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bit.c @@ -0,0 +1,13 @@ +bar (a) +{ + return (a == 0); +} + +foo (a) + int a; +{ + if ((a & (1 << 26)) >= 0) + return 1; + else + return 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bitf.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bitf.c new file mode 100755 index 0000000..5b0aefc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bitf.c @@ -0,0 +1,17 @@ +#define int unsigned + +struct foo +{ + int aa : 1; + int a : 9; + int c : 16; + int d : 6; +}; + + +int +foo (a, b) + struct foo a; +{ + return a.d == 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bitw.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bitw.c new file mode 100755 index 0000000..585cd32 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bitw.c @@ -0,0 +1,9 @@ +foo (a) + unsigned a; +{ + unsigned b = 0; + + if ((a & 12345678) > b) + return 1; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/blk.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/blk.c new file mode 100755 index 0000000..18a9545 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/blk.c @@ -0,0 +1,18 @@ +struct +{ + double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t; +} foo, bar; + +foobar () +{ + foo = bar; + xxx (&foo, &bar); +} + +main () +{ + bar.g = 1.0; + foo.g = 2.0; + foobar (); + printf ("%lf\n", foo.g); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bt.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bt.c new file mode 100755 index 0000000..ac20c05 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bt.c @@ -0,0 +1,7 @@ +main () +{ + int i; + + for (i = 1000000; --i;) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bt386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bt386.c new file mode 100755 index 0000000..283ab5f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bt386.c @@ -0,0 +1,18 @@ +foo (a, b) +{ + return (a & (1 << b)) != 0; +} + +bar (a, b) +{ + a ^= (1 << b); + return a != 0; +} + +main () +{ + int i; + for (i = 0; i < 32; i++) + printf ("%d ", foo (0x8000000f, i)); + puts (""); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bug.c new file mode 100755 index 0000000..447eb7a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bug.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a - 65536; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bugc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bugc.c new file mode 100755 index 0000000..b2ce1fa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bugc.c @@ -0,0 +1,7 @@ + +int +reg0indreg1 (r0, p1) + short r0; short *p1; +{ + return (r0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/buns.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/buns.c new file mode 100755 index 0000000..f206bfa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/buns.c @@ -0,0 +1,12 @@ +foo (a) +{ + int bar = 0; + + return (unsigned) (a - 1) <= (unsigned) bar; +} + +main () +{ + if (foo (-1)) + puts ("The largest possible unsigned <= 0 on this machine..."); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/bx.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/bx.c new file mode 100755 index 0000000..274fb01 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/bx.c @@ -0,0 +1,12 @@ +unsigned +good (unsigned src, unsigned o5, unsigned w5) +{ + return src & ~((w5 == 0) ? (~0 << o5) : (1 << o5)); +} + +unsigned +bad (unsigned src, unsigned o5, unsigned w5) +{ + return src & ((w5 == 0) ? ~(~0 << o5) : ~(1 << o5)); +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/c.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/c.c new file mode 100755 index 0000000..384ee3e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/c.c @@ -0,0 +1,17 @@ +foo (a, b) + long long a, b; +{ + if (a & ~b) + return 1; + else + return 0; +} + +bar (a, b) + long long a, b; +{ + if (a & ~b & ((long long) 87612378)) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/c1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/c1.c new file mode 100755 index 0000000..f50d437 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/c1.c @@ -0,0 +1,7 @@ +unsigned +rec (a, b) + unsigned a; + unsigned b; +{ + return a * rec (a - 1, b + 1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/c2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/c2.c new file mode 100755 index 0000000..ef5a711 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/c2.c @@ -0,0 +1,5 @@ +foo (a) +{ + bar (a); + bar (a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/call.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/call.c new file mode 100755 index 0000000..c810603 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/call.c @@ -0,0 +1,7 @@ +int foo () {} + +main (a, b) +{ + foo (foo (a, b), foo (b, a)); + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/call386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/call386.c new file mode 100755 index 0000000..1849893 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/call386.c @@ -0,0 +1,20 @@ + +foo () {} + +main () +{ + int i; + for (i = 100000; i >= 0; i--) + { + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + foo (); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/callind.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/callind.c new file mode 100755 index 0000000..74c0f1f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/callind.c @@ -0,0 +1,8 @@ +call (foo, a) + int (**foo) (); +{ + + (foo)[1] = call; + + foo[a] (1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cc.c new file mode 100755 index 0000000..e29bec4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cc.c @@ -0,0 +1,96 @@ +cc8 (a, b) +{ + if (a < 0) + goto L1; + if (a == 0) + goto L2; + L1:b++; + L2:b++; + return b; +} + +cc7 (a) + long long a; +{ + if (a < 0) + return 1; + else + return 0; +} + +cc6 (float a, double p) +{ + p = a; + if (p < 0) + return p; + else + return p + 1; +} + +cc5 (p, a) + char *p; + char a; +{ + p[2] = a; + if (a) + return 0; + else + return 1; +} + + +cc4 (a, b, p) + int a, b; + int *p; +{ + a = (int short)b; + *p = a; + if ((int) a < 0) + return 0; + else + return 1; +} + + +cc1 (a, b) +{ + int x = 0; + + if ((int) a < (int) b) + { + if ((unsigned) a < (unsigned) b) + x++; + x++; + } + + return x; +} + +cc2 (a, b) +{ + int x = 0; + + if ((int) a <= (int) b) + { + if ((int) a < (int) b) + x++; + x++; + } + + return x; +} + +cc3 (a, b) +{ + int x = 0; + + a += b; + if ((unsigned) a > 0) + { + if (a == 0) + x++; + x++; + } + + return x; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/charmtst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/charmtst.c new file mode 100755 index 0000000..2945f19 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/charmtst.c @@ -0,0 +1,15 @@ +c_move_tst (char b) +{ + char a; + + a = b; + b = 'b'; + foo (a); + foo (b); + foo (a); + bar (a, b); + b = a; + if (b == 0) + a++; + return a + b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cmb.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmb.c new file mode 100755 index 0000000..1fd9461 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmb.c @@ -0,0 +1,6 @@ +foo (p1, p2) + short p1, *p2; +{ + int a; + return (int) p1 + (int) *p2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmp.c new file mode 100755 index 0000000..a82fe42 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmp.c @@ -0,0 +1,11 @@ +struct fooalign {char x; double d;}; +union fooround {long x; double d;}; + +int +foo () +{ + int extra = 4; + if (extra < sizeof (union fooround)) + extra = sizeof (union fooround); + return extra; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cmphi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmphi.c new file mode 100755 index 0000000..1ffc214 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmphi.c @@ -0,0 +1,4 @@ +foo (short *p, short a) +{ + return a < *p; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cmpsi386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmpsi386.c new file mode 100755 index 0000000..50b08d7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmpsi386.c @@ -0,0 +1,14 @@ +foo (a, p) + register int a; + int *p; +{ + + for (a = 10000000; a >= *p; a--) + ; +} + +main () +{ + int a; + foo (a, a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cmul.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmul.c new file mode 100755 index 0000000..cce20bc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cmul.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a * 84; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cn1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cn1.c new file mode 100755 index 0000000..866778c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cn1.c @@ -0,0 +1,5 @@ +int +foo () +{ + return 7561; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/comb.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/comb.c new file mode 100755 index 0000000..a468907 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/comb.c @@ -0,0 +1,7 @@ +foo (a, b) +{ + int c = a & b; + if ((a & b) == 0) + return 0; + return c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/configure.in b/gcc_arm/testsuite/gcc.c-torture/unsorted/configure.in new file mode 100755 index 0000000..7810172 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/configure.in @@ -0,0 +1,15 @@ +# This file is a shell script fragment that supplies the information +# necessary to tailor a template configure script into the configure +# script appropriate for this directory. For more information, check +# any existing configure script. + +srctrigger=unsorted.exp +srcname="DejaGnu" + +# per-host: + +# per-target: + +target_makefile_frag=../config/mt-${target_alias} + +# post-target: diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/consec.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/consec.c new file mode 100755 index 0000000..fd76cd2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/consec.c @@ -0,0 +1,17 @@ +int glob; + +conseq (a, b, c, d) + int *a, *b; +{ + a[2] = d; + a[1] = c; + sequence (a, b, c, d); + sequence (d, c, b, a); + b[0] = 0; + b[1] = 123; + a[0] = 321; + a[1] = 0; + sequence (111, 0, 0, 222, 0, 333); + ((int *)glob)[2] = c; + ((int *)glob)[3] = d; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/const.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/const.c new file mode 100755 index 0000000..209fc76 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/const.c @@ -0,0 +1,4 @@ +main (a) +{ + return a + (~0 - 240); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/conv.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/conv.c new file mode 100755 index 0000000..70fc024 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/conv.c @@ -0,0 +1,32 @@ +double +u2d (unsigned int u) +{ + return u; +} + +double +i2d (signed int i) +{ + return i; +} + +unsigned int +d2u (double d) +{ + return d; +} + +signed int +d2i (double d) +{ + return d; +} + +main () +{ + printf ("%lf, %lf, %lf\n", u2d (~0), u2d (1 << 31), u2d (1)); + printf ("%lf, %lf, %lf\n", i2d (~0), i2d (1 << 31), i2d (1)); + + printf ("%u, %u, %u\n", d2u (u2d (~0)), d2u (u2d (1 << 31)), d2u (u2d (1))); + printf ("%d, %d, %d\n", d2i (i2d (~0)), d2i (i2d (1 << 31)), d2i (i2d (1))); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/conv_tst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/conv_tst.c new file mode 100755 index 0000000..513d6a2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/conv_tst.c @@ -0,0 +1,66 @@ +#define ID_1 2400000000.0 +#define ID_2 1.7 +#define ID_3 -1.7 + +unsigned ui; +int si; + +conv_i1 () +{ +/* + ui = (unsigned) ID_1; + si = (int) ID_1; +*/ +} + +conv_i2 () +{ + ui = (unsigned) ID_2; + si = (int) ID_2; +} + +conv_i3 () +{ +/* ui = (unsigned) ID_3;*/ + si = (int) ID_3; +} + +conv_1 (d) + double d; +{ + ui = (unsigned) d; +/* + si = (int) d; +*/ +} + +double +foo (u) + unsigned u; +{ + return u; +} + +main () +{ + printf ("%lf\n", foo (2400000000)); + + conv_i1 (); + printf ("%lf, %u, %d\n", ID_1, ui, si); + + conv_i2 (); + printf ("%lf, %u, %d\n", ID_2, ui, si); + + conv_i3 (); + printf ("%lf, %u, %d\n", ID_3, ui, si); + + conv_1 (ID_1); + printf ("%lf, %u, %d\n", ID_1, ui, si); + + conv_1 (ID_2); + printf ("%lf, %u, %d\n", ID_2, ui, si); + + conv_1 (ID_3); + printf ("%lf, %u, %d\n", ID_3, ui, si); + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cp.c new file mode 100755 index 0000000..04b1420 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cp.c @@ -0,0 +1,42 @@ +struct _obstack_chunk +{ + char *limit; + struct _obstack_chunk *prev; + char contents[4]; +}; + +struct obstack +{ + long chunk_size; + struct _obstack_chunk* chunk; + char *object_base; + char *next_free; + char *chunk_limit; + int temp; + int alignment_mask; + struct _obstack_chunk *(*chunkfun) (); + void (*freefun) (); +}; + +struct fooalign {char x; double d;}; +union fooround {long x; double d;}; + +void +_obstack_begin (h, size, alignment, chunkfun, freefun) + struct obstack *h; + int size; + int alignment; + void * (*chunkfun) (); + void (*freefun) (); +{ + register struct _obstack_chunk* chunk; + + if (alignment == 0) + alignment = ((char *)&((struct fooalign *) 0)->d - (char *)0); + if (size == 0) + { + int extra = 4; + if (extra < (sizeof (union fooround))) + extra = (sizeof (union fooround)); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/csebug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/csebug.c new file mode 100755 index 0000000..f49f684 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/csebug.c @@ -0,0 +1,7 @@ + +int +reg0indreg1 (r0, p1) + short r0; short *p1; +{ + return (r0 + *p1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/cvt.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/cvt.c new file mode 100755 index 0000000..716659c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/cvt.c @@ -0,0 +1,9 @@ +foo (p) + unsigned char *p; +{ + unsigned char a = 0; + + if (*p > 0) + return 1; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/d.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/d.c new file mode 100755 index 0000000..5fca120 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/d.c @@ -0,0 +1,19 @@ +long long unsigned +str2llu (str) + char *str; +{ + long long unsigned acc; + long long b = 10; + char d; + acc = *str++ - '0'; + for (;;) + { + d = *str++; + if (d == '\0') + break; + d -= '0'; + acc = acc * 10 + d; + } + + return acc; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dbl_parm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dbl_parm.c new file mode 100755 index 0000000..ce5ba4f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dbl_parm.c @@ -0,0 +1,10 @@ +foo (a, b, c) + double a; + int b; + double c; +{ + if (b) + return a + c; + else + return a - c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dblbug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dblbug.c new file mode 100755 index 0000000..cd13b79 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dblbug.c @@ -0,0 +1,21 @@ +union real_extract +{ + double d; + int i[sizeof (double ) / sizeof (int)]; +}; + +typedef struct +{ + int zzzz; +} *rtx; + +rtx +immed_real_const_1 (d) + double d; +{ + union real_extract u; + register rtx r; + + u.d = d; + foo (&(r->zzzz), &u); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ddd.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ddd.c new file mode 100755 index 0000000..b0b6809 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ddd.c @@ -0,0 +1,7 @@ +int foo; +int bar; + +main () +{ + return foo + bar; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dead.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dead.c new file mode 100755 index 0000000..795f7c7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dead.c @@ -0,0 +1,5 @@ +foo (a) +{ + ++a; + return a == 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/delay.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/delay.c new file mode 100755 index 0000000..c776383 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/delay.c @@ -0,0 +1,11 @@ +foo (a, b) +{ + if (a == 1) + goto foo1; + if (a == 2) + goto foo2; + foo1: + return 2; + foo2: + return 3; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/di.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/di.c new file mode 100755 index 0000000..476bf70 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/di.c @@ -0,0 +1,12 @@ +long long +foo (a, b) + long long a, b; +{ + return a * b; +} + +main () +{ + int a = foo ((long long) 2, (long long) 3); + printf ("%d\n", a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dic.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dic.c new file mode 100755 index 0000000..9c2c9f9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dic.c @@ -0,0 +1,5 @@ +unsigned long long +main () +{ + return (unsigned long long) 7816234 << 671111; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dilayout.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dilayout.c new file mode 100755 index 0000000..4bba661 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dilayout.c @@ -0,0 +1,33 @@ +struct ii +{ + int a; + int b; +}; + +struct foo +{ + int a; + struct ii ab; + int b; +}; + +struct ii +foo (int *p, struct foo a) +{ + p[0] = a.a; + p[1] = a.ab.a; + p[2] = a.ab.b; + p[3] = a.b; + return a.ab; +} + +str (struct ii ab, struct ii *p) +{ + *p = ab; +} + +ll (long long ab, long long *p) +{ + *p = ab; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dimove.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dimove.c new file mode 100755 index 0000000..7caf3fa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dimove.c @@ -0,0 +1,4 @@ +foo (long long *p) +{ + p[0] = p[1]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dimul.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dimul.c new file mode 100755 index 0000000..c852956 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dimul.c @@ -0,0 +1,6 @@ +long long +foo (a, b) + long long a, b; +{ + return a * b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/div.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/div.c new file mode 100755 index 0000000..1f0904a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/div.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a / b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/divdf.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/divdf.c new file mode 100755 index 0000000..5ea89ae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/divdf.c @@ -0,0 +1,5 @@ +double +foo (float a, float b) +{ + return (double)a / (double)b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dm.c new file mode 100755 index 0000000..67c60ee --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dm.c @@ -0,0 +1,24 @@ +struct dm +{ + unsigned q; + unsigned r; +}; + +struct dm +dm (a, b) + unsigned a, b; +{ + struct dm qr; + + qr.q = a / b; + qr.r = a % b; + return qr; +} + +main () +{ + struct dm qr; + + qr = dm (100, 30); + printf ("%u, %u\n", qr.q, qr.r); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/dshift.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/dshift.c new file mode 100755 index 0000000..94750cc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/dshift.c @@ -0,0 +1,10 @@ +foo (b, c) + unsigned b, c; +{ + return (b << 12) | (c >> 20); +} + +main () +{ + printf ("0x%x\n", foo (0x11223344, 0xaabbccdd)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/e.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/e.c new file mode 100755 index 0000000..fa20e00 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/e.c @@ -0,0 +1,10 @@ +foo (short a, int *p, short *s) +{ + int i; + for (i = 10; i >= 0; i--) + { + a = (short) bar (); + p[i] = a; + s[i] = a; + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ex.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ex.c new file mode 100755 index 0000000..f5d90fd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ex.c @@ -0,0 +1,11 @@ +foo (a, b) +{ + if ((a & (1 << b)) == 0) + return 1; + return 0; +} + +main () +{ + printf ("%d\n", foo ()); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ext.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ext.c new file mode 100755 index 0000000..8fa8cd7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ext.c @@ -0,0 +1,13 @@ +struct foo +{ + unsigned b31 : 1; + unsigned b30 : 1; + unsigned b29 : 1; + unsigned b28 : 1; + unsigned rest : 28; +}; +foo(a) + struct foo a; +{ + return a.b30; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/f1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/f1.c new file mode 100755 index 0000000..446acc6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/f1.c @@ -0,0 +1,5 @@ +double +foo () +{ + return 1.2587624368724; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/f2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/f2.c new file mode 100755 index 0000000..8bb3849 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/f2.c @@ -0,0 +1,4 @@ +foo (double *p) +{ + p[0] = p[1]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/fdmul.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/fdmul.c new file mode 100755 index 0000000..711707b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/fdmul.c @@ -0,0 +1,2 @@ +double +foo (float a, float b) { return (double) a * (double) b; } diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/flo.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/flo.c new file mode 100755 index 0000000..2a213b7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/flo.c @@ -0,0 +1,7 @@ +foo (a) + double a; +{ + double b = 0.0; + + return (a == 0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/float.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/float.c new file mode 100755 index 0000000..b678920 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/float.c @@ -0,0 +1,6 @@ +double +foo (a, b, c) + double a, b, c; +{ + return a * b + c * a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/flt_const.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/flt_const.c new file mode 100755 index 0000000..65700ba --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/flt_const.c @@ -0,0 +1,5 @@ +double +foo () +{ + return 3.141592653589793238462643; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/fnul.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/fnul.c new file mode 100755 index 0000000..b0c9816 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/fnul.c @@ -0,0 +1,23 @@ +main () +{ + int i; + int f; + + for (i = 0;; i--) + { + f = 0; + + if ((i & (i - 1)) == 0) + { + printf ("d"); + f = 1; + } + if ((i & -i) == i) + { + printf ("t"); + f = 1; + } + if (f) + printf ("%d\n", i); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/foo.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/foo.c new file mode 100755 index 0000000..762d7e4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/foo.c @@ -0,0 +1,8 @@ +int * +main (s1, s2) + int *s1; int *s2; +{ + while ((*s1++ = *s2++) != '\0') + ; + return s1 - 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/forgetcc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/forgetcc.c new file mode 100755 index 0000000..4105408 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/forgetcc.c @@ -0,0 +1,11 @@ +foo (hp, p, a) + short *hp; + int *p; + int a; +{ + hp[10] = a; + p[0] = 10; + if (hp[10] > 0) + return 1; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/fq.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/fq.c new file mode 100755 index 0000000..c4ac369 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/fq.c @@ -0,0 +1,25 @@ +expand_to_ascii (int *i, int *o) +{ + unsigned x, y, out; + unsigned x1; + + /* Big endian code. */ + + x = *i++; + + y = x >> (32 - 13); + out = (y / 91); + out = (out << 8) | (y % 91); + + x <<= 13; + y = x >> (32 - 13); + out = (out << 8) | (y / 91); + out = (out << 8) | (y % 91); + + *o++ = out + 0x20202020; + + /* 6 bits left in x. */ + + x1 = *i++; + x = (x << 26) | (x1 >> 6); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/g.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/g.c new file mode 100755 index 0000000..e00f124 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/g.c @@ -0,0 +1,9 @@ +foo (a, b) + long long a, b; + +{ + if (a == b) + return 0; + else + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/gen_tst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/gen_tst.c new file mode 100755 index 0000000..5a7a376 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/gen_tst.c @@ -0,0 +1,67 @@ +/* Compiler Test Generator Program. + Copyright (C) 1989 FSF. */ + + +#define E0 ((type *)10000000) +#define reg0 r0 +#define indreg0 (*p0) +#define imm0 22 +#define limm0 ((type)(int)&glob0) +#define adr0 (*E0) +#define adrreg0 (p0[10000000]) +#define adrx0 (E0[x0]) +#define regx0 (p0[x0]) + +#define E1 ((type *)11111111) +#define reg1 r1 +#define indreg1 (*p1) +#define imm1 33 +#define limm1 ((type)(int)&glob1) +#define adr1 (*E1) +#define adrreg1 (p1[1111111/4]) +#define adrx1 (E1[x1]) +#define regx1 (p1[x1]) + +int glob0, glob1; + +#define type double + +char *a0[] = {"reg0", "indreg0", "imm0", "limm0", + "adr0", "adrreg0", "adrx0", "regx0"}; +char *a1[] = {"reg1", "indreg1", "imm1", "limm1", + "adr1", "adrreg1", "adrx1", "regx1"}; + +main_compare () +{ + int i0, i1; + + for (i0 = 0; i0 < 8; i0++) + { + for (i1 = 0; i1 < 8; i1++) + { + printf ("%s%s_cmp (r0, r1, x0, x1, p0, p1)\n", a0[i0], a1[i1]); + printf ("type r0, r1; type *p0, *p1;\n"); + printf ("{if (%s <= %s) return 1; else return 0;}\n\n", + a0[i0], a1[i1], a0[i0]); + } + } +} + +main_assign () +{ + int i0, i1; + + for (i0 = 0; i0 < 8; i0++) + { + if (i0 < 2 || i0 > 3) + for (i1 = 0; i1 < 8; i1++) + { + printf ("%s%s_set (r0, r1, x0, x1, p0, p1)\n", a0[i0], a1[i1]); + printf ("type r0, r1; type *p0, *p1;\n"); + printf ("{%s = %s; }\n\n", + a0[i0], a1[i1]); + } + } +} + +main () {main_assign ();} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/glob.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/glob.c new file mode 100755 index 0000000..e320615 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/glob.c @@ -0,0 +1,12 @@ +typedef int tt; + +tt a1; +tt a2; +tt a3; + +foo () +{ + a1++; + a2++; + a1++; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/gronk.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/gronk.c new file mode 100755 index 0000000..c1bb767 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/gronk.c @@ -0,0 +1,8 @@ +test_opt (a, b) + unsigned a, b; +{ + a = a / b; + if (a == 0) + a++; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/hi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/hi.c new file mode 100755 index 0000000..1624f77 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/hi.c @@ -0,0 +1,5 @@ +foo (a, b) + short a, b; +{ + return a < b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/hibug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/hibug.c new file mode 100755 index 0000000..ad5c826 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/hibug.c @@ -0,0 +1,15 @@ +struct foo +{ + short d; + int a; +}; + +int +bar (d, u) + short d; + struct foo u; +{ + + u.d = d; + return (int) (&u); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/i++.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/i++.c new file mode 100755 index 0000000..01d9ca9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/i++.c @@ -0,0 +1,7 @@ +int main () +{ + int i = 2; + + i = i++; + printf ("%d\n",i); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/i.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/i.c new file mode 100755 index 0000000..3bee8ea --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/i.c @@ -0,0 +1,8 @@ +ase (p) + short *p; +{ + int a; + + a = *p; + *p = a + 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/i386bug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/i386bug.c new file mode 100755 index 0000000..395bfa6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/i386bug.c @@ -0,0 +1,51 @@ +typedef union { + struct { + long RH, LH; + } v; + struct { + unsigned char B1; + } u; +} twohalves; + + +typedef union { + long cint; + twohalves hhfield; + +} memoryword; + + +extern memoryword mem[262]; + +long znewstructure ( p ) +long p; +{ + long q, r; + { + q = mem [ p + 2 ] .hhfield .v.RH; + r = mem [ q + 1 ] .hhfield .v.LH; + do { + q = r; + r = mem [ r ] .hhfield .v.RH; + } while ( ! ( r == p ) ); + r = foo((long) ( 3 )); + mem [ q ] .hhfield .v.RH = r; + mem [ r + 2 ] = mem [ p + 2 ]; + if ( mem [ p + 2 ] .hhfield .v.LH == 0 ) + { + q = mem [ p + 2 ] .hhfield .v.RH + 1; + while ( mem [ q ] .hhfield .v.RH != p ) q = mem [ q ] .hhfield .v.RH; + mem [ q ] .hhfield .v.RH = r; + } + } + mem [ r ] .hhfield .u.B1 = mem [ p ] .hhfield .u.B1; + mem [ r + 1 ] .hhfield .v.LH = p; + + q = foo((long) ( 3 )); + + mem [ r + 1 ] .hhfield .v.RH = q; + mem [ q + 2 ] .hhfield .v.RH = r; + + + return(r); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ic.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ic.c new file mode 100755 index 0000000..150e1e8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ic.c @@ -0,0 +1,7 @@ +foo (int *ip, int a) +{ + a++; + if (a < ip[a]) + return 1; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/icmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/icmp.c new file mode 100755 index 0000000..dc9678e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/icmp.c @@ -0,0 +1,10 @@ +foo (a, b) +{ + b++; + if (a <= b) + if ((int) a < (int) b) + b--; + else + b++; + return b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ifreg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ifreg.c new file mode 100755 index 0000000..9e2f956 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ifreg.c @@ -0,0 +1,12 @@ +union foo +{ + float f; + int i; +}; + +foo (int a, float c) +{ + union foo b; + b.i = a; + return b.f + c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/imm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/imm.c new file mode 100755 index 0000000..c3efba4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/imm.c @@ -0,0 +1,7 @@ +int +imm () + +{ + return 11234; + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/isinf.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/isinf.c new file mode 100755 index 0000000..12a8283 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/isinf.c @@ -0,0 +1,5 @@ +int +isinf () +{ + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/jmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/jmp.c new file mode 100755 index 0000000..474206a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/jmp.c @@ -0,0 +1,20 @@ +foo (a) +{ + if (a) + goto a1; + goto a2; + a1: goto a3; + a2: goto a4; + a3: goto a5; + a4: goto a6; + a5: goto a7; + a6: goto a8; + a7: goto a9; + a8: goto a10; + a9: goto a11; + a10: goto a12; + a11: goto a13; + a12:; + a13:; + return -a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/jumptab.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/jumptab.c new file mode 100755 index 0000000..d86c30e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/jumptab.c @@ -0,0 +1,20 @@ +jumptab (a) +{ + int b; + switch (a) + { + case 0: + b = 6;break; + case 1: + b = 5;break; + case 2: + b = 4;break; + case 3: + b = 3;break; + case 4: + b = 2;break; + case 5: + b = 1;break; + } + return b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/l.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/l.c new file mode 100755 index 0000000..cc23b19 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/l.c @@ -0,0 +1,4 @@ +main (a) +{ + return - 256 + a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/layout.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/layout.c new file mode 100755 index 0000000..04c825d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/layout.c @@ -0,0 +1,13 @@ +struct foo +{ + char a; +}; + +foo () +{ + struct foo bar[3]; + bar[0].a = '0'; + bar[1].a = '1'; + bar[2].a = '2'; + foof (bar); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/lbug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/lbug.c new file mode 100755 index 0000000..0440a0a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/lbug.c @@ -0,0 +1,7 @@ +long long x = 0; +main() +{ + if (x--) + return 255; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ll1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ll1.c new file mode 100755 index 0000000..9009e77 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ll1.c @@ -0,0 +1,5 @@ +long long +foo (long long a) +{ + return a + ((long long) 10230101 << 32) + 7561; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/llbug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/llbug.c new file mode 100755 index 0000000..8c56dfb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/llbug.c @@ -0,0 +1,13 @@ +union foo +{ + long long d; +}; + +int +bar (long long d) +{ + union foo u; + + u.d = d; + return (int) &u; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/lll.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/lll.c new file mode 100755 index 0000000..dee9dc3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/lll.c @@ -0,0 +1,45 @@ + +byte_match_count2 (buf, n, xm, m1, m2, m3, m4) + unsigned *buf; + unsigned n; + unsigned xm; + unsigned m1, m2, m3, m4; +{ + unsigned w, cnt = 0; + unsigned *bp; + + n /= 4; + + bp = buf; + while (bp < buf + n) + { + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + + w = *bp++; + w ^= xm; + cnt += ((m1 & w) == 0); + cnt += ((m2 & w) == 0); + cnt += ((m3 & w) == 0); + cnt += ((m4 & w) == 0); + } + return cnt; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/load8.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/load8.c new file mode 100755 index 0000000..947a816 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/load8.c @@ -0,0 +1,4 @@ +foo () +{ + return *(short *) 126; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/loadhicc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/loadhicc.c new file mode 100755 index 0000000..a754089 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/loadhicc.c @@ -0,0 +1,15 @@ +typedef int xtype; + +foo (p, pc) + xtype *p; + char *pc; +{ + xtype a; + unsigned b = 0; + + a = *p; + p[1] = a; + if ((unsigned) p[1] > 0) + return 1; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/log2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/log2.c new file mode 100755 index 0000000..39b8578 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/log2.c @@ -0,0 +1,6 @@ +log2 (a, b) +{ + int c; + c = ~(~a & ~b); + return c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/logic.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/logic.c new file mode 100755 index 0000000..a9d6e9d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/logic.c @@ -0,0 +1,37 @@ +logic (a, b) + int *a, b; +{ + if (*a & 123) + b = 1; + if (*a & ~222) + b = 2; + if (124 & *a) + b = 3; + if (~111 & *a) + b = 4; + + if (~*a & 23) + b = 1; + if (~*a & ~22) + b = 2; + if (24 & ~*a) + b = 3; + if (~11 & ~*a) + b = 4; + + if (~*a & b) + b = 1; + if (~*a & ~b) + b = 2; + if (*a & ~*a) + b = 3; + return b; +} + +x (a, b, c) +{ + for (a = 0; --a > 0;); + for (b = -1; --b > 0;); + for (c = -65536; --c > 0;); + return a + b + c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/loop-1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/loop-1.c new file mode 100755 index 0000000..e50687a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/loop-1.c @@ -0,0 +1,11 @@ +foo (a) +{ + while ((a -= 1) != -1) + bar (270000); + putchar ('\n'); +} + +main () +{ + foo (5); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/loop386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/loop386.c new file mode 100755 index 0000000..429a320 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/loop386.c @@ -0,0 +1,15 @@ +foo (a) +{ + do + { + puts ("a"); + a -= 1; + } + while (a != 0); +} + +main () +{ + int p[100]; + printf ("%d\n", foo (3)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/lop.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/lop.c new file mode 100755 index 0000000..7246411 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/lop.c @@ -0,0 +1,6 @@ +lop (a) +{ + do + a--; + while (a >= -1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/m1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/m1.c new file mode 100755 index 0000000..8660f60 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/m1.c @@ -0,0 +1,5 @@ +foo (p) + int *p; +{ + *p = 1234; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/m2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/m2.c new file mode 100755 index 0000000..203c855 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/m2.c @@ -0,0 +1,44 @@ +void +store16 (p, a) + short *p; + short a; +{ + *p = a; +} + +signed int +sign_extend16 (p) + signed short *p; +{ + return *p; +} + +unsigned int +zero_extend16 (p) + unsigned short *p; +{ + return *p; +} + +void +store8 (p, a) + char *p; + char a; +{ + *p = a; +} + +signed int +sign_extend8 (p) + signed char *p; +{ + return *p; +} + +unsigned int +zero_extend8 (p) + unsigned char *p; +{ + return *p; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/m5.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/m5.c new file mode 100755 index 0000000..23ad844 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/m5.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a * 5 + 12; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/m68.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/m68.c new file mode 100755 index 0000000..a1ee486 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/m68.c @@ -0,0 +1,14 @@ +foo (a) +{ + return a | 12345; +} + +bar (a) +{ + return a & (0xffff0000 | 12345); +} + +foobar (a) +{ + return a - 128; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mbyte.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mbyte.c new file mode 100755 index 0000000..a8a23ea --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mbyte.c @@ -0,0 +1,14 @@ +foo1 (p) + char *p; +{ + p[0] = p[1]; + return p[0]; +} + +foo2 (p, x) + char *p; +{ + p[0] = x; + return p[0]; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mchar.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mchar.c new file mode 100755 index 0000000..a1b1060 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mchar.c @@ -0,0 +1,11 @@ +int +foo (char *a, char *b) +{ + int x; + *a = *b; + x = *b; + if ((char) x) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mcmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mcmp.c new file mode 100755 index 0000000..6008008 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mcmp.c @@ -0,0 +1,9 @@ +foo (ip, a, x) + int a; + int *ip; + int x; +{ + if (a >= 1) + x++; + return x; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mdouble.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mdouble.c new file mode 100755 index 0000000..992db22 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mdouble.c @@ -0,0 +1,6 @@ +double +foo (double a) +{ + + return 1.123486712; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/memtst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/memtst.c new file mode 100755 index 0000000..b5ef260 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/memtst.c @@ -0,0 +1,26 @@ +#ifdef STACK_SIZE +#define SIZE STACK_SIZE / 8 +#else +#define SIZE 65536 +#endif + +memtst (int *p, int a) +{ + do + { + if (p[a] == 1) + break; + } + while (--a); +} + +main () +{ + int a[SIZE]; + int i; + bzero (a, SIZE * 4); + for (i = 0; i < 100; i++) + { + memtst (a, SIZE); + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/miscomp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/miscomp.c new file mode 100755 index 0000000..0bcb568 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/miscomp.c @@ -0,0 +1,15 @@ +unsigned char foo(unsigned long); +main() +{ + unsigned char AChar; + unsigned long ALong = 0x12345678; + + AChar = foo(ALong); + + printf("AChar = %x\n",(int)AChar); +} +unsigned char +foo( unsigned long TheLong) +{ + return( (unsigned char) (TheLong & 0xff) ); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mm.c new file mode 100755 index 0000000..a8efaae --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mm.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a * 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mod.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mod.c new file mode 100755 index 0000000..c33211d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mod.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a % b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/modcc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/modcc.c new file mode 100755 index 0000000..2574090 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/modcc.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return (a % b) == 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/move.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/move.c new file mode 100755 index 0000000..78e00ff --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/move.c @@ -0,0 +1,9 @@ +typedef char type; + +type +foo (b) +{ + type a; + for (a = 10; a < b; a++) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/move_qhi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/move_qhi.c new file mode 100755 index 0000000..9bc9cb6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/move_qhi.c @@ -0,0 +1,12 @@ +move (a, b) + char a, b; +{ + char s; + s = a; + if (s) + gurka (s); + foo (b, a); + a = bar (); + b = bar (); + gra (s); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mregtst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mregtst.c new file mode 100755 index 0000000..b6bb6c2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mregtst.c @@ -0,0 +1,17 @@ +foo (a, p) + int *p; +{ + int old, new, i; + + old = 0; + for (i = 1; i < 100; i++) + { + new = p[i]; + if (new < old) + a++; + old = new; + if (old == 0) + return 0; + } + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/msp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/msp.c new file mode 100755 index 0000000..c73cedd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/msp.c @@ -0,0 +1,5 @@ +foo () +{ + int a[16384]; + bar (a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mtst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mtst.c new file mode 100755 index 0000000..4f43137 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mtst.c @@ -0,0 +1,17 @@ +foo (int *p, int c) +{ + int a, b; + a = p[0]; + b = p[1]; + c = p[2]; + if (b == 0) + goto foo1; + if (b < 0) + goto foo2;; + + return a + b + c; + foo1: + return 1; + foo2: + return 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mu.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mu.c new file mode 100755 index 0000000..c469a6e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mu.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a * b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mul.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mul.c new file mode 100755 index 0000000..cc5d06b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mul.c @@ -0,0 +1,5 @@ +void +mulqi (char *p, char a, char b) +{ + p[0] = a/b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mword.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mword.c new file mode 100755 index 0000000..873e088 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mword.c @@ -0,0 +1,29 @@ +int +foo (a, b) +int *a, *b; +{ + int x, y; + x++; + *a = *b; + y = *b; + + if ((int) x) + return 1; + else + return y; +} + +foo1 (p) + int *p; +{ + p[0] = p[1]; + return p[0]; +} + +foo2 (p, x) + int *p; +{ + p[0] = x; + return p[0]; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/mword1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/mword1.c new file mode 100755 index 0000000..690703e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/mword1.c @@ -0,0 +1,12 @@ +int +foo (a, b) +int *a, *b; +{ + int x; + *a = (*b + 1); + x = *b; + if ((int) x) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/n.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/n.c new file mode 100755 index 0000000..1a9a869 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/n.c @@ -0,0 +1,6 @@ +char_autoincr (b1, c) + short *b1; + short c; +{ + *b1 = c; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/n1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/n1.c new file mode 100755 index 0000000..dfa93ce --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/n1.c @@ -0,0 +1,10 @@ +foo (a, p) + long long a; + int *p; +{ + int b = (int)-a; + if (b > 32) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/nand.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/nand.c new file mode 100755 index 0000000..8228a3c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/nand.c @@ -0,0 +1,4 @@ +nadn (a, b) +{ + return (~a) | (~b); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/neg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/neg.c new file mode 100755 index 0000000..c005b13 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/neg.c @@ -0,0 +1 @@ +foo (a) {return -a;} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/o.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/o.c new file mode 100755 index 0000000..e8b78e3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/o.c @@ -0,0 +1,12 @@ +foo (a, p) + char a; + int *p; +{ + int b = a; + *p = b; + a = (char) a; + if (a) + return b; + else + return b + 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/omit.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/omit.c new file mode 100755 index 0000000..f59d6ee --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/omit.c @@ -0,0 +1,11 @@ +omit (a, b) + char a; + char *b; +{ + char x; + int i; + x = *b; + b[1] = x; + foo ((int)x); + return x + 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/opout.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/opout.c new file mode 100755 index 0000000..6d3736e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/opout.c @@ -0,0 +1,10 @@ +x () +{} + +y () +{} + +z (a, b) +{ + return (int) &a + (int) &b + (int) x + (int) z; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/opt.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/opt.c new file mode 100755 index 0000000..faad10e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/opt.c @@ -0,0 +1,5 @@ +int +foo (a) +{ + return (a == 2); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/or.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/or.c new file mode 100755 index 0000000..2a2e3b6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/or.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a | 0xffff0101; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/or386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/or386.c new file mode 100755 index 0000000..ad49f35 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/or386.c @@ -0,0 +1,13 @@ +typedef int xtype; + +xtype +foo (a) + xtype a; +{ + return a | 0x7f; +} + +main () +{ + printf ("%08x\n", foo (-1)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/p.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/p.c new file mode 100755 index 0000000..465e741 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/p.c @@ -0,0 +1,6 @@ +foo (a, b, p) + short *p; +{ + p[0] = a; + p[1] = b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/parms.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/parms.c new file mode 100755 index 0000000..26c2c70 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/parms.c @@ -0,0 +1,7 @@ +#define alloca __builtin_alloca + +x (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, x, y) +{ + foo (alloca (8)); + return a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+x+y; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pass.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pass.c new file mode 100755 index 0000000..6b66382 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pass.c @@ -0,0 +1,13 @@ +int +foo (a, b, c) +{ + return a + b + c; +} + +int +bar () +{ + int q, w, e, r, t, y; + + return foo ((int) & q, q, w, e, q, (int) &w); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pmt.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pmt.c new file mode 100755 index 0000000..b6aced6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pmt.c @@ -0,0 +1,6 @@ +long long +foo (a, b) + long long a, b; +{ + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/poor.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/poor.c new file mode 100755 index 0000000..66d584a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/poor.c @@ -0,0 +1,34 @@ +typedef struct +{ + char c[510]; +} s510; + +typedef struct +{ + char c[511]; +} s511; + +s510 G510, s1; +s511 G511; +int I, J; +double D; + +void main(void); +void f0(double D, ...); +s510 f1(double D, ...); +void f2a(s510 S); +void f2b(s511 S); + + +void main(void) +{ + + f0(D, I, J); + + s1 = f1(D, I, D); + + f2a(G510); + + f2b(G511); + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pp.c new file mode 100755 index 0000000..7d38d53 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pp.c @@ -0,0 +1,9 @@ +foo (a, b, c, d, e, i0, f, i1) + double a, b, c, d, e, f; + int i0, i1; +{} + +main () +{ + foo (1.0, 2.0, 3.0, 4.0, 5.0, 1, 6.0, 2); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pret-arg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pret-arg.c new file mode 100755 index 0000000..a7fa856 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pret-arg.c @@ -0,0 +1,5 @@ +foo (a, b, c, d, e, f, g, h, i, j, xx) + double xx; +{ + return xx + 1.2345; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr.c new file mode 100755 index 0000000..d25b2a9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr.c @@ -0,0 +1,11 @@ +foo (char *a) +{ + char b; + int c; + b = *a; + c = b; + if (c < 0) + return 1; + a[1] = b; + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr2.c new file mode 100755 index 0000000..12e2ccd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/pyr2.c @@ -0,0 +1,4 @@ +foo (a) +{ + return ((int *)0)[a]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/q.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/q.c new file mode 100755 index 0000000..fa08e75 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/q.c @@ -0,0 +1,7 @@ + +unsigned +reg0indreg1 (r0, p1) + unsigned short r0; unsigned short p1; +{ + return (r0 + p1); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/r.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/r.c new file mode 100755 index 0000000..19eeda7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/r.c @@ -0,0 +1,7 @@ +r (a, b) +{ + if (a < b) + return 1; + else + return 2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/r1.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/r1.c new file mode 100755 index 0000000..0b277b0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/r1.c @@ -0,0 +1,29 @@ +void assert (a) {if (a != 1) abort ();} + +int h1 (int *p) {return *p & 255;} + +void p1 () {int a = 0x01020304; assert (h1 (&a) == 0x04);} + + +int h2 (a) {return a > 0;} + +p2 () {assert (h2 (1));} + +h3 (int *p) +{ + *p |= 255; +} + +p3 () +{ + int *p; + h3 (p); +} + +main () +{ + p1 (); + p2 (); + p3 (); + puts ("Compiler test passed."); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/rel.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/rel.c new file mode 100755 index 0000000..54d3605 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/rel.c @@ -0,0 +1,8 @@ +foo (int *c, int b) +{ + int a; + + a = *c + b; + c[1] = a; + return b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/rmsc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/rmsc.c new file mode 100755 index 0000000..5c97c6d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/rmsc.c @@ -0,0 +1,46 @@ + +cc1 (x, y) + int x, y; +{ + int z; + z = x - y; + if (x >= y) + return z + 1; + else + return z + 0; +} + +cc2 (x, y) + int x, y; +{ + int z; + + z = x - y; + if (z >= 0) + return z + 1; + else + return z + 0; +} + +cc3 (x, y) + unsigned x, y; +{ + unsigned z; + z = x - y; + if (x >= y) + return z + 1; + else + return z + 0; +} + +cc4 (x, y) + unsigned x, y; +{ + unsigned z; + + z = x - y; + if (z >= 0) + return z + 1; + else + return z + 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/round.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/round.c new file mode 100755 index 0000000..5233e65 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/round.c @@ -0,0 +1,13 @@ +foo (a) + double a; +{ + printf ("%d\n", (int) a); +} + +main () +{ + foo (1.6); + foo (1.4); + foo (-1.4); + foo (-1.6); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/run.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/run.c new file mode 100755 index 0000000..40892f6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/run.c @@ -0,0 +1,11 @@ +main () +{ + typedef short int xtype; + + xtype i; + xtype ii; + + for (i = 0; i < 100; i++) + for (ii = 65535; --ii;) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/s.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/s.c new file mode 100755 index 0000000..e0c8426 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/s.c @@ -0,0 +1,24 @@ +struct foo +{ + int a, b, c, d; + double doubl; +} s1, s2; + +struct foo +structret (s1, i1, i2, s2) + struct foo s1, s2; + int i1, i2; +{ + if (i1 != i2) + { + if (i1 < i2) + return s1; + else + return s2; + } + s2.a = 11; + s2.b = 22; + s2.c = s1.c; + s2.d = s1.d; + return s2; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sar.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sar.c new file mode 100755 index 0000000..9bf9bec --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sar.c @@ -0,0 +1,10 @@ +struct foo +{ + char a; +} foo[100]; + +main () +{ + foo[1].a = '1'; + foo[2].a = '2'; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sc.c new file mode 100755 index 0000000..84dc60f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sc.c @@ -0,0 +1,5 @@ +foo (a, b) + int a, b; +{ + return (a < 0) | (a <= 0) | (a == 0) | (a != 0) | (a >= 0) | (a > 0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/scal.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/scal.c new file mode 100755 index 0000000..94e22aa --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/scal.c @@ -0,0 +1,19 @@ +int g1, g2; + +void +write_at (addr, off, val) + int *addr; + int off; + int val; +{ + g2 = 1; + addr[off] = val; + g2++; +} + +main () +{ + g2 = 12; + write_at (&g1, &g2 - &g1, 12345); + printf ("%d\n", g2); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/scc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/scc.c new file mode 100755 index 0000000..79ae4e1 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/scc.c @@ -0,0 +1,11 @@ +foo (a, b) +{ + if (a < 0) + goto ret1; + if (a == 0) + return 2; + return 3; + ret1: + return 1; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/scond.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/scond.c new file mode 100755 index 0000000..087b0a6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/scond.c @@ -0,0 +1,4 @@ +scond (a, b, c, d) +{ + return (a > b) & (c < d); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/selfrec.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/selfrec.c new file mode 100755 index 0000000..c7aaca5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/selfrec.c @@ -0,0 +1,5 @@ +int +foo (a) +{ + return foo (a - 1) * a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/seq.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/seq.c new file mode 100755 index 0000000..0793228 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/seq.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a < 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/set386.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/set386.c new file mode 100755 index 0000000..c16ae8d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/set386.c @@ -0,0 +1,5 @@ +foo (a, p) + int *p; +{ + *p = a > 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/set88.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/set88.c new file mode 100755 index 0000000..8069ea6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/set88.c @@ -0,0 +1,9 @@ +foo (a) +{ + return -1 << a; +} + +bar (a, b) +{ + return b | (-1 << a); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sh.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sh.c new file mode 100755 index 0000000..8d3265f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sh.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a << b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/shand.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/shand.c new file mode 100755 index 0000000..5a40196 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/shand.c @@ -0,0 +1,11 @@ +int +foo (x, c) + int x; +{ + return x >> 24 & 0xff; +} + +bar (x) +{ + return (int)(x & 0xfffff) << 13; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/shft.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/shft.c new file mode 100755 index 0000000..7d318c8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/shft.c @@ -0,0 +1,15 @@ +foo (a) + int a; +{ + int b = 8; + + if ((a << b) >= 0) + return 1; + return a; +} + +main () +{ + if (foo (0x00ffffff) == 1) + puts ("y"); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/shift.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/shift.c new file mode 100755 index 0000000..1ed1879 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/shift.c @@ -0,0 +1,7 @@ +foo (a) +{ + if (a >= 0) + return (unsigned) a << 10; + else + return (int) a << 10; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/shloop.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/shloop.c new file mode 100755 index 0000000..f4c9366 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/shloop.c @@ -0,0 +1,7 @@ +main () +{ + int volatile p; + int i; + for (i = 10000000; i > 0; i--) + p = i >> 10; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/shm.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/shm.c new file mode 100755 index 0000000..b667b26 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/shm.c @@ -0,0 +1,5 @@ +foo (int *p) +{ + int a = *p; + return a >> 24; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/signext.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/signext.c new file mode 100755 index 0000000..2724098 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/signext.c @@ -0,0 +1,27 @@ +void longprint (x) + long long x; +{ + printf (" %d, %d\n", (unsigned) ((unsigned long long) x >> 32), + (unsigned) x); +} + +void +k_min (p, qa, d) + int d; +{ + int s = 1; + long long x; + + if (s >= d) + s -= d; + + x = ((long long)((8 * s) % 3) + qa) % d; + longprint (x); +} + +int +main () +{ + k_min (100003, -600017, 3); + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/signext2.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/signext2.c new file mode 100755 index 0000000..d2eb637 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/signext2.c @@ -0,0 +1,11 @@ +long long +foo (a) + int a; +{ + return a; +} + +main () +{ + printf ("%d\n", (int) (foo (-1) >> 32)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sim.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sim.c new file mode 100755 index 0000000..e8c4fb4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sim.c @@ -0,0 +1,7 @@ +main () +{ + int i; + + for (i = 1; i < 10000; i++) + ; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/simple.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/simple.c new file mode 100755 index 0000000..614acba --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/simple.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sne.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sne.c new file mode 100755 index 0000000..6844a6e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sne.c @@ -0,0 +1,4 @@ +foo (double a) +{ + return (a != 0); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sound.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sound.c new file mode 100755 index 0000000..be727e3 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sound.c @@ -0,0 +1,13 @@ + +main () +{ + char audio[8192]; + int i; + + for (i = 0; i < 4095; i += 1) + audio[i] = i / 8, + audio[8191 - i] = i / 8; + + for (;;) + write (1, audio, 8192); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sparcbug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sparcbug.c new file mode 100755 index 0000000..cd42a86 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sparcbug.c @@ -0,0 +1,5 @@ +foo (a) +{ + int b = a; + return b + 8762345; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/speed.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/speed.c new file mode 100755 index 0000000..d61407e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/speed.c @@ -0,0 +1,8 @@ +main () +{ + int i; + + for (i = 5000000; i >=0; i--) + { + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/stor.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/stor.c new file mode 100755 index 0000000..57981ef --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/stor.c @@ -0,0 +1,12 @@ +#define C 1 + +foo (p) + int *p; +{ + p[0] = C; + p[1] = C; + p[2] = C; + p[3] = C; + p[4] = C; + p[5] = C; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/store0.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/store0.c new file mode 100755 index 0000000..3b7b16e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/store0.c @@ -0,0 +1,4 @@ +foo (int *p) +{ + p[10] = 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/storecc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/storecc.c new file mode 100755 index 0000000..1163469 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/storecc.c @@ -0,0 +1,6 @@ +foo (char *p, int a) +{ + *p = a; + if ((char) a) + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/str.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/str.c new file mode 100755 index 0000000..d2dec4b --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/str.c @@ -0,0 +1,13 @@ +typedef struct +{ + char a; + char b; +} foo; + +bar () +{ + foo foobar[100]; + foobar[1].a = 'a'; + foobar[2].a = 'b'; + barfoo (foobar); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/stru.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/stru.c new file mode 100755 index 0000000..042c522 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/stru.c @@ -0,0 +1,9 @@ +struct foo +{ + int a, b, c; +}; + +foo (struct foo *a) +{ + a[0] = a[1]; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/structret.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/structret.c new file mode 100755 index 0000000..9c705d4 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/structret.c @@ -0,0 +1,69 @@ +struct foo +{ + int a, b, c, d; + double doubl; +} s1, s2; + +#ifndef ONLY2 + +struct foo +structret (s1, i1, i2, s2) + struct foo s1, s2; + int i1, i2; +{ + if (i1 != i2) + { + if (i1 < i2) + return s1; + else + return s2; + } + s2.a = 11; + s2.b = 22; + s2.c = s1.c; + s2.d = s1.d; + return s2; +} + +#endif + +#ifndef ONLY1 + +struct foo +mani (a, b) +{ + return structret (s1, a, b, s2); +} + +init () +{ + s1.a = 1; + s1.b = 2; + s1.c = 3; + s1.d = 4; + s1.doubl = 3.1415; + s2.a = -1; + s2.b = -2; + s2.c = -3; + s2.d = -4; + s2.doubl = 2.71818; +} + +main () +{ + struct foo s; + + init (); + s = mani (1, 1); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); + + init (); + s = mani (2, 1); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); + + init (); + s = mani (1, 2); + printf ("%d, %d, %d, %d : %f\n", s.a, s.b, s.c, s.d, s.doubl); +} + +#endif diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/stuct.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/stuct.c new file mode 100755 index 0000000..deb838d --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/stuct.c @@ -0,0 +1,22 @@ +#ifdef STACK_SIZE +#define SIZE STACK_SIZE / 8 +#else +#define SIZE 10000000 +#endif + +struct foo +{ + int a, b, c; + int arr[SIZE]; +}; + +struct foo s, ss; + +main () +{ + + s.b = 2; + s.c = 3; + ss.b = 2; + ss.c = 3; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sub32.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sub32.c new file mode 100755 index 0000000..93114d9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sub32.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a + 32; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/subcc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/subcc.c new file mode 100755 index 0000000..d50114e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/subcc.c @@ -0,0 +1,31 @@ +foo (a, c) +{ + int b; + + if (a + c >= 0) /* b < 0 ==== a < 10? */ + return a | 0x80000000; + return 0; +} + +bar (a) +{ + if (foo (a, 10) & 0x80000000) + printf ("y"); + else + printf ("n"); +} + +main () +{ + bar (0); + bar (1); + bar (-1); + bar (10); + bar (-10); + bar (11); + bar (-11); + bar (0x7fffffff); + bar (-0x7fffffff); + + puts (""); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/subcse.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/subcse.c new file mode 100755 index 0000000..0a10991 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/subcse.c @@ -0,0 +1,6 @@ +foo (a, b, p) + int *p; +{ + p[0] = 1230 - a; + p[1] = 1230 - b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/sym.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/sym.c new file mode 100755 index 0000000..8a0fe32 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/sym.c @@ -0,0 +1,4 @@ +foo () +{ + return (int) &foo; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/symconst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/symconst.c new file mode 100755 index 0000000..7add218 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/symconst.c @@ -0,0 +1,4 @@ +foo () +{ + return (int)foo; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/t.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/t.c new file mode 100755 index 0000000..48095e7 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/t.c @@ -0,0 +1,18 @@ +#define B 95 + +foo (a, b, p) + unsigned a, b; + int *p; +{ + p[1] = a % B; + p[0] = a / B; +} + +bar (a, b, p) + unsigned a, b; + int *p; +{ + p[0] = a / B; + p[1] = a % B; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/test-flow.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/test-flow.c new file mode 100755 index 0000000..01ec724 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/test-flow.c @@ -0,0 +1,12 @@ +foo (a, b, c, d) +{ + if (a < 0) + { + b = c; + } + else + { + b = d; + } + return b + 75; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/test-loop.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/test-loop.c new file mode 100755 index 0000000..d441dde --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/test-loop.c @@ -0,0 +1,7 @@ +main () +{ + int i; + for (i = 100; i >= -1; i--) + foo (); + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/test.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/test.c new file mode 100755 index 0000000..46e830a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/test.c @@ -0,0 +1,6 @@ +foo (a) +{ + if (a & 38) + return 1; + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/time.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/time.c new file mode 100755 index 0000000..7e22681 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/time.c @@ -0,0 +1,7 @@ +main () +{ + int i; + for (i = 3000000; --i;) + { + } +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/tmp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/tmp.c new file mode 100755 index 0000000..463d9fb --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/tmp.c @@ -0,0 +1,5 @@ +foo (a, b) +{ + return (a - b) == 0; +} + diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/trivial.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/trivial.c new file mode 100755 index 0000000..e9665cd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/trivial.c @@ -0,0 +1 @@ +foo () {} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/trunc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/trunc.c new file mode 100755 index 0000000..dee0e15 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/trunc.c @@ -0,0 +1,11 @@ +main () +{ + printf ("%x, %x\n", (unsigned char) main, main); +} + +foo (p) + char *p; +{ + p[0] = (char)foo; + p[1] = (char)foo; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/u.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/u.c new file mode 100755 index 0000000..7fc0dda --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/u.c @@ -0,0 +1 @@ +foo (a, b) { return a % b; } diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/udconvert.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/udconvert.c new file mode 100755 index 0000000..31b494f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/udconvert.c @@ -0,0 +1,30 @@ +double +unsigned_to_double1 (u) + unsigned u; +{ + double d; + d = (int) u; /* convert as from a *signed* integer */ + return ((int) u < 0) + ? d + 4294967296.0 + : d; +} + +/* Alternatively */ + +double +unsigned_to_double2 (u) + unsigned u; +{ + double d; + u -= 2147483648; /* complement sign bit */ + d = (int) u; /* convert as from a *signed* integer */ + return d + 2147483648.0; +} + +unsigned +double_to_unsigned (d) + double d; +{ + d += 2147483648.0; + return ((int) d) - 2147483648; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/udivmod4.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/udivmod4.c new file mode 100755 index 0000000..40d2fa8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/udivmod4.c @@ -0,0 +1,56 @@ +long long +xlrandom () +{ + long long x; + unsigned a; + int bits = 64; + unsigned b; + + do + { + a = random (); + b = (a & 15) + 1; + x <<= b; /* shift up 1-16 steps */ + a = (a >> 18) & 1; + if (a) + x |= (unsigned) (1 << b) - 1; + bits -= b; + } + while (bits >= 0); + return x; +} + + +unsigned long long __udivmoddi4(); + +main () +{ + int i; + unsigned long long n, d, q, r, rr; + + for (i = 0; ;i++) + { + n = xlrandom (); + d = xlrandom (); + if (d == 0) + continue; + + q = __udivmoddi4 (n, d, &r); + + if (i % 1000000 == 0) + printf ("Testing udivmoddi4: %d iterations made\n", i); + + rr = n - q * d; + if (rr != r || r >= d) + { + printf ("Testing udivmoddi4: failure after %d iterations\n", i); + printf ("n=%lX%08lX\n", (unsigned) (n >> 32), (unsigned) n); + printf ("d=%lX%08lX\n", (unsigned) (d >> 32), (unsigned) d); + printf ("q=%lX%08lX\n", (unsigned) (q >> 32), (unsigned) q); + printf ("r=%lX%08lX\n", (unsigned) (r >> 32), (unsigned) r); + printf ("rr=%lX%08lX\n", (unsigned) (rr >> 32), (unsigned) rr); + abort (); + } + } + +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/uns.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/uns.c new file mode 100755 index 0000000..314704f --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/uns.c @@ -0,0 +1,5 @@ +foo (a) +{ + if ((unsigned) a < 234) + return 1; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/uns_tst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/uns_tst.c new file mode 100755 index 0000000..e34ffaf --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/uns_tst.c @@ -0,0 +1,19 @@ +a (c) + unsigned char c; +{ + unsigned u = c; + if ((int)u < 0) + return 1; + else + return 0; +} + +b (x, y) + unsigned x, y; +{ + x /= y; + if ((int)x < 0) + return 1; + else + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/unsorted.exp b/gcc_arm/testsuite/gcc.c-torture/unsorted/unsorted.exp new file mode 100755 index 0000000..a586170 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/unsorted.exp @@ -0,0 +1,54 @@ +# +# Expect driver script for GCC Regression Tests +# Copyright (C) 1993, 1997 Free Software Foundation +# +# This file is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# +# Written by Jeffrey Wheat (cassidy@cygnus.com) +# + +# +# These tests come from Torbjorn Granlund's (tege@cygnus.com) +# C torture test suite, and other contributors. +# + +if $tracelevel then { + strace $tracelevel +} + +# load support procs +load_lib c-torture.exp + +# +# This loop will run c-torture on any *.c file found in this directory. +# If a *.c has a corresponding *.exp file, then the test is skipped as +# as the *.exp will drive the test itself. It is done this way so that +# generic tests do not need a seperate .exp for it. Only the tests that +# require unique options need their own .exp file. +# + +foreach testcase [glob -nocomplain $srcdir/$subdir/*.c] { + if [file exists [file rootname $testcase].exp] then { + verbose "INFO:\"[file rootname $testcase].exp\" exists, skipping test" 3 + continue + } + + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $testcase] then { + continue + } + + c-torture $testcase +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/uuarg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/uuarg.c new file mode 100755 index 0000000..8928b3e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/uuarg.c @@ -0,0 +1,4 @@ +foo (a, b, c, d, e, f, g, h, i) +{ + return foo () + i; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/v.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/v.c new file mode 100755 index 0000000..87ac00a --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/v.c @@ -0,0 +1,11 @@ +main (int *p) +{ + int a; + + a = 0; + p[1] = a; + a = 0; + p[2] = a; + a = 123456; + p[3] = a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/w.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/w.c new file mode 100755 index 0000000..1acfe15 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/w.c @@ -0,0 +1 @@ +int foo (unsigned short a, unsigned short b) { return a + b; } diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/ww.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/ww.c new file mode 100755 index 0000000..657f8c6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/ww.c @@ -0,0 +1,7 @@ +foo (p) + short *p; +{ + static int *foo; + *p = 1234; + *foo = 1234; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/x.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/x.c new file mode 100755 index 0000000..baf9896 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/x.c @@ -0,0 +1 @@ +f(m){int i,s=0;for(i=0;i<m;i++)s+=i;return s;} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xb.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xb.c new file mode 100755 index 0000000..09087cc --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xb.c @@ -0,0 +1,17 @@ +foo (a, b) +{ + unsigned x = 1; + + a += b; + a += x; + if (a <= 0) + return 1; + return 0; +} + +main () +{ + printf ("%d\n", foo (1, ~0)); + printf ("%d\n", foo (0, ~0)); + printf ("%d\n", foo (-1, ~0)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xbg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xbg.c new file mode 100755 index 0000000..b600964 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xbg.c @@ -0,0 +1,14 @@ +typedef short type; + +short +foo (type *sp, int a) +{ + type t; + int i; + + t = sp[a]; + i = (int)(type)sp[a]; + if (i) + return 0; + return t; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xc.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xc.c new file mode 100755 index 0000000..aed06a0 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xc.c @@ -0,0 +1,11 @@ +foo (a, p) + int *p; +{ + int b; + + a++; + b = *p; + if (a) + return 1; + return b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xcsebug.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xcsebug.c new file mode 100755 index 0000000..614a6e8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xcsebug.c @@ -0,0 +1,14 @@ +int g1; +int g2; + +foo () +{ + int i = 1; + int x; + + x = g1; + (*(&g1 + i - 1)) = x + 1; + x = g1; + (*(&g1 + i - 1)) = x + 1; + g1++; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xdi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xdi.c new file mode 100755 index 0000000..413dd6c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xdi.c @@ -0,0 +1,15 @@ +foo (long long *p, int a, int b) +{ + *(p + a + b) = 876243243874343LL; +} + +bar (p, pp) + long long *p, *pp; +{ + long long a; + *p++ = a; + fee (*p); + *p++ = *pp--; + *p++ = *pp--; + return (int) p; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xfoo.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xfoo.c new file mode 100755 index 0000000..da879d2 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xfoo.c @@ -0,0 +1,4 @@ +foo (a) +{ + return (a & ~0xfff) == 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xi.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xi.c new file mode 100755 index 0000000..54b42c5 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xi.c @@ -0,0 +1,7 @@ +foo (a) +{ + int r = 0; + if (a) + r = 1; + return r; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xlop.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xlop.c new file mode 100755 index 0000000..6506bfd --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xlop.c @@ -0,0 +1,11 @@ +foo (a) +{ + int b; + do + { + b = bar (); + a = b - 10; + } + while (a > 10); + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xmtst.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xmtst.c new file mode 100755 index 0000000..ca78fca --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xmtst.c @@ -0,0 +1,26 @@ +p1 (int b, int *p, int a) +{ + p[0] = p[1]; + return p[0]; +} +p2 (int b, int *p, int a) +{ + p[0] = p[1]; + return p[0] == 0; +} +p3 (int b, int *p, int a) +{ + p[0] = p[1]; + a = p[0]; + if (a) + return 0; + return a; +} +p4 (int b, int *p, int a) +{ + a = p[1]; + p[0] = p[1]; + if (a) + return 0; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xneg.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xneg.c new file mode 100755 index 0000000..ff5b850 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xneg.c @@ -0,0 +1,5 @@ +foo (a) + double a; +{ + return -a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xopt.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xopt.c new file mode 100755 index 0000000..b1a50f8 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xopt.c @@ -0,0 +1,35 @@ +proc1 (a) + unsigned a; +{ + return (a >> 20) & 0x010fffff; +} + +proc2 (a) + unsigned a; +{ + return (a << 17) & 0xfffff001; +} + +proc3 (a) + unsigned a; +{ + return (a & 0xff00000a) >> 25; +} + +proc4 (a) + unsigned a; +{ + return (a & 0x100000ff) << 25; +} + +proc5 (a) + unsigned a; +{ + return (unsigned char) (a >> 24); +} + +proc6 (a) + unsigned a; +{ + return ((unsigned char) a) << 30; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xor.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xor.c new file mode 100755 index 0000000..435f223 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xor.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return ~(a ^ ~123); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xorn.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xorn.c new file mode 100755 index 0000000..d7b75f9 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xorn.c @@ -0,0 +1,31 @@ +int +xorn (a, b) + int a, b; +{ + return a ^ ~b; +} + +int +not (a) + int a; +{ + return ~a; +} + +int +xor (a, b) + int a, b; +{ + return a ^ b; +} + +main () +{ + int i, j; + + for (i = 0; i <= 1; i++) + for (j = 0; j <= 1; j++) + printf ("%d op %d = %d = %d?\n", i, j, + 1 & xor (i, not (j)), + 1 & xorn (i, j)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xp.c new file mode 100755 index 0000000..139335c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xp.c @@ -0,0 +1,4 @@ +foo (a) +{ + return a & 255; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xpp.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xpp.c new file mode 100755 index 0000000..daf3399 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xpp.c @@ -0,0 +1,12 @@ +foo (a) +{ + a++; + if (a < 10) + return 1; + return a; +} + +main () +{ + printf ("%d\n", foo ((1 << 31) - 1)); +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xs.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xs.c new file mode 100755 index 0000000..24f773e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xs.c @@ -0,0 +1,9 @@ +foo (a, b) +{ + for (b = 0; b < 10; b++) + ; + for (a = 0; a < 10; a++) + ; + a = b << 1; + return a; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xsh.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xsh.c new file mode 100755 index 0000000..9ba0b6c --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xsh.c @@ -0,0 +1,7 @@ +foo (a, b) +{ + a = b + b; + if (a) + return a; + return b; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xxs.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xxs.c new file mode 100755 index 0000000..1757f97 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xxs.c @@ -0,0 +1,202 @@ +void *malloc (); +struct timeval { + long tv_sec; + long tv_usec; +}; +struct timezone { + int tz_minuteswest; + int tz_dsttime; +}; +struct itimerval { + struct timeval it_interval; + struct timeval it_value; +}; +typedef int sigset_t; +typedef unsigned int speed_t; +typedef unsigned long tcflag_t; +typedef unsigned char cc_t; +typedef int pid_t; +typedef unsigned short mode_t; +typedef short nlink_t; +typedef long clock_t; +typedef long time_t; +typedef int size_t; +typedef int ptrdiff_t; +typedef unsigned short wchar_t; +struct tm { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + char *tm_zone; + long tm_gmtoff; +}; +extern struct tm *gmtime(), *localtime(); +extern char *asctime(), *ctime(); +extern void tzset(), tzsetwall(); +extern int dysize(); +extern time_t timelocal(), timegm(); +struct rusage { + struct timeval ru_utime; + struct timeval ru_stime; + long ru_maxrss; + long ru_ixrss; + long ru_idrss; + long ru_isrss; + long ru_minflt; + long ru_majflt; + long ru_nswap; + long ru_inblock; + long ru_oublock; + long ru_msgsnd; + long ru_msgrcv; + long ru_nsignals; + long ru_nvcsw; + long ru_nivcsw; +}; +struct rlimit { + int rlim_cur; + int rlim_max; +}; +unsigned long +cputime () +{ + struct rusage rus; + getrusage (0, &rus); + return (((rus.ru_utime.tv_sec + rus.ru_stime.tv_sec) * 1000000) + + rus.ru_utime.tv_usec + rus.ru_stime.tv_usec) / 1000; +} +int +do_assoc_test (mem, start, cc) + register char *mem; + register int start; + register int cc; +{ + register int j; + register int ind = start; + register int x; + for (j = 0x100000; --j >= 0; ) + { + int x = ((volatile char *) mem)[ind]; + ind -= cc; + if (ind < 0) + ind = start; + } + return x; +} +int +determine_assoc (size) +{ + register char *mem = malloc (size * (1 << 5 )); + int cc = size; + int lbsets; + int times[5 + 1]; + for (lbsets = 0; lbsets <= 5; lbsets++) + { + int t = cputime (); + do_assoc_test (mem, (cc << lbsets) - cc, cc); + t = cputime () - t; + times[lbsets] = t; + printf ("sets = %2u: %u ms\n", 1 << lbsets, t); + } + free (mem); + { + int max = 1000 * times[1] / times[0]; + int maxindex = 0; + int min = 1000 * times[1] / times[0]; + int minindex = 0; + for (lbsets = 1; lbsets < 4; lbsets++) + { + int x = 1000 * times[lbsets + 1] / times[lbsets]; + if (x > max) + { + max = x; + maxindex = lbsets; + } + if (x < min) + { + min = x; + minindex = lbsets; + } + } + if (min * 100 > max * 75) + return 0; + return 1 << maxindex; + } +} +do_size_test(mem, size, reps) + register int *mem; + register int size; + register int reps; +{ + register int j, i, x; + mem += size; + for (j = reps; --j >= 0;) + for (i = -size; i < 0; i++) + x = ((volatile int *) mem)[i]; +} +int +determine_size() +{ + register int *mem = malloc (1 << 20 ); + int lbsize; + int times[20 ]; + for (lbsize = 12; lbsize < 20; lbsize++) + { + int t = cputime (); + do_size_test (mem, (1 << lbsize) / sizeof (int) - 64, + 0x1000000 >> lbsize); + t = cputime () - t; + times[lbsize] = t; + printf ("size = %2u: %u ms\n", 1 << lbsize, t); + } + free (mem); + { + int max = 1000 * times[12 + 1] / times[12 ]; + int maxindex = 0; + int min = 1000 * times[12 + 1] / times[12 ]; + int minindex = 0; + for (lbsize = 12; lbsize < 20 - 1; lbsize++) + { + int x = 1000 * times[lbsize + 1] / times[lbsize]; + if (x > max) + { + max = x; + maxindex = lbsize; + } + if (x < min) + { + min = x; + minindex = lbsize; + } + } + if (min * 100 > max * 75) + return 0; + return 1 << maxindex; + } +} +int +main() +{ + int size, assoc; + size = determine_size(); + if (size) + printf ("I guess this cache is %d bytes.\n", size); + else + printf ("I can't determine the size from this run.\n"); + if (size == 0) + size = 65536; + assoc = determine_assoc(size); + if (assoc > 1) + printf ("I guess this cache is %d-way set associative.\n", assoc); + else if (assoc == 1) + printf ("I guess this cache is direct mapped.\n"); + else + printf ("I can't determine the associativity from this run.\n"); + return 0; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xz.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xz.c new file mode 100755 index 0000000..97a1d1e --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xz.c @@ -0,0 +1,4 @@ +foo (int *p) +{ + *p = (unsigned short) *p; +} diff --git a/gcc_arm/testsuite/gcc.c-torture/unsorted/xzz.c b/gcc_arm/testsuite/gcc.c-torture/unsorted/xzz.c new file mode 100755 index 0000000..f1972b6 --- /dev/null +++ b/gcc_arm/testsuite/gcc.c-torture/unsorted/xzz.c @@ -0,0 +1,4 @@ +foo (a, b) +{ + return a >> (char) b; +} |