Initial revision

git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@14840 138bc75d-0d04-0410-961f-82ee72b054a4

2559 files changed, 93270 insertions, 0 deletions

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
new file mode 100644
index 00000000000..b30226a14e0
--- /dev/null
+++ b/gcc/testsuite/ChangeLog
@@ -0,0 +1,1928 @@
+Thu Jul 31 12:17:24 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture/execute/920501-9.c: Fix to work on targets with
+	32bit or larger longs.
+
+	* gcc.c-torture/execute/961017-2.c: Fix to work on targets which
+	have either a 32bit long or 32bit int.
+
+Wed Jul  9 15:15:40 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* gcc.prms/5403.c: Allow CRLFs to occur at the start of the output
+	too.
+
+Mon Jun 16 15:27:06 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp(g++_init): Use g++_include_flags instead of making
+	up the includes ourselves.
+
+Wed Jun 11 17:33:21 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/plumhall.exp: Remove random include, and add a few
+	verbose messages for debugging.
+
+Fri Jun  6 14:23:24 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp: Use g++_link_flags from libgloss.exp, instead
+	of trying to do it ourselves.
+
+Wed Jun  4 18:43:55 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* gcc.prms/5403.c: Made regexp a bit less strict.
+
+Tue Jun  3 15:12:39 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/mike-gcc.exp: Don't use global exec_output anymore. Output
+	is returned from remote_load instead.
+	* lib/plumhall.exp: Ditto.
+	* lib/mike-g++.exp: Ditto.
+	* lib/old-dejagnu.exp: Ditto.
+	* lib/c-torture.exp: Ditto.
+
+Fri May 30 23:15:15 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp: Use build_wrapper procedure.
+	* lib/gcc.exp: Ditto.
+
+Tue May 20 15:23:27 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture/execute/*.c: Include stdlib.h instead of using
+	an old-style decl for malloc.  Fixes tests to work when
+	sizeof (int) != sizeof (size_t).
+
+Thu May 15 14:10:39 1997  Mike Meissner  <meissner@cygnus.com>
+
+	* lib/gcc.exp (gcc_target_compile): If gcc,no_varargs, define
+	NO_VARARGS when compiling.
+
+Thu May  1 14:49:19 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/plumhall.exp(ph_includes): New procedure.
+	(ph_make): Use it.
+	(ph_compiler): Ditto.
+
+	* lib/g++.exp: Rename test-glue.c to testglue.c.
+	* lib/gcc.exp: Ditto.
+
+Thu Apr 10 14:50:26 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp(g++init): Don't try to be smart, always run g++_init
+ 	to completion when it's called.
+
+Thu Mar 20 09:50:32 1997  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/plumhall.exp (ph_make): Comment out errorCode=NONE test
+	for object files.
+	(ph_summary): Mark skipped testcases as untested, not unresolved.
+
+	* lib/plumhall.exp (ph_make): If unresolved because of bad
+	errorCode, record errorCode in log file.
+	(*): Replace send_log/verbose with verbose -log.
+
+Thu Mar 13 16:09:28 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/plumhall.exp: Use incr_count.
+
+Wed Mar 12 10:01:33 1997  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.45.
+
+Sun Feb 23 18:12:04 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/gcc.exp(gcc_init): Add args parameter (which will contain
+ 	the name of the expect testcase file).
+	
+	* lib/g++.exp(g++_init): Ditto.
+
+Thu Feb 20 13:53:05 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp(g++_exit): $gluefile lives on the build, not
+	the host.
+
+	* lib/gcc.exp(gcc_exit): New procedure.
+
+Wed Feb 19 15:16:16 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* g++.old-deja/g++.rfg/*: Added "Build don't link" and ERROR
+	specs where appropriate.
+
+	* g++.old-deja/g++.arm/*: Added additional ERROR checks
+	because of new "candidates are" messages, and removed a few
+
+	* Converted all non-old-style g++ testcases to old-style, and
+	moved into g++.old-deja.
+
+Fri Feb 14 11:46:46 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/old-dejagnu.exp(old-dejagnu): Add various "skip if"
+	options.
+
+	* lib/gcc.exp(gcc_init): Don't set gluefile unless the compile
+	succeeded.
+
+	* lib/g++.exp(g++_init): Don't unset gluefile unless it exists.
+
+Thu Feb 13 17:30:46 1997  Michael Meissner  <meissner@cygnus.com>
+
+	* lib/gcc.exp (gcc_target_compile): Add support for defining
+	NO_TRAMPOLINES and NO_LABEL_VALUES if the baseboard file indicates
+	the machine doesn't have those features.
+
+Tue Feb 11 12:57:11 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* g++.law/operators4.exp: Don't use LIBS.
+
+Sat Feb  8 14:45:55 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* g++.law/virtual1.exp: Don't use CXX_FLAGS.
+	
+	* lib/mike-g++.exp: Don't set the compiler to be tested here.
+	* lib/g++.exp: Set it here instead. Also, allow use of the
+	--tool_exec and --tool_opt options. Change CXX to
+	GXX_UNDER_TEST.
+	
+	* g++.old-deja/old-deja.exp: Change CXX to GXX_UNDER_TEST.
+	
+	* lib/gcc.exp: Allow use of --tool_exec and --tool_opt.
+
+Fri Feb  7 12:55:45 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/old-dejagnu.exp: Use prune_warnings instead of
+ 	prune_system_crud.
+	* lib/mike-g++.exp: Ditto.
+	* lib/gcc.exp: Ditto.
+	* lib/g++.exp: Ditto.
+
+	* lib/g++.exp: Include both libstdc++ and libstdc++/stl.
+
+Fri Feb  7 10:41:53 1997  Jeffrey A Law  (law@cygnus.com)
+
+        * 941014-2.c: Include stdlib.h
+        * 960327-1.c: Include stdio.h
+        * dbra.c, index-1.c: Don't assume ints are 32bits.
+
+Tue Feb  4 12:51:09 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/gcc.exp: Add gcc,stack_size target feature.
+
+	* lib/g++.exp(g++_target_compile): Add the include and link 
+	paths here, not in two other places. And, it's $options, not
+	options.
+
+	* lib/mike-g++.exp(postbase): Remove the code that determines
+	the correct include and link paths.
+	* g++.old-deja/old-deja.exp: Ditto.
+
+Mon Feb  3 19:00:07 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/g++.exp(g++_init): target_compile no longer returns the
+	filename of the result.
+
+Sun Feb  2 14:42:34 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* gcc.misc-tests/gcov.exp: Add -nocomplain to the
+	call to glob.
+
+	* gcc.c-torture/special/special.exp: Change call to
+ 	gcc_target_compile to include the object file.
+
+Sun Feb  2 17:11:50 1997  Ian Lance Taylor  <ian@cygnus.com>
+
+	* gcc.c-torture/special/special.exp: Correct misspelling in last
+	change.
+
+Sat Feb  1 12:34:23 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/plumhall.exp(ph_summary): Log the entire output of the
+ 	executable. Return -1 if there were any failures, 0 otherwise.
+	(ph_execute): Return -1 if there were any failures, 0 otherwise.
+	(ph_make): Clean up objects and executables that were built
+	if the tests succeeded.
+
+Thu Jan 30 13:45:56 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* g++.old-deja/old-deja.exp: Add -L and -I flags so we include
+	libraries and includes in the build tree as appropriate.
+
+Wed Jan 29 17:19:34 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/c-torture.exp: Instead of looking for the global variable
+	NO_LONG_LONG, check to see if that's a feature of the target.
+
+Wed Jan 29 00:36:25 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+	* config/default.exp: Minimize. Delete the remainer of the files in
+	config;	this functionality is now in devo/dejagnu/config.
+
+	g++.*/*: Pass any additional flags used to compile to postbase;
+	delete CXXFLAGS.
+	
+	gcc.c-torture/*: Remove calls to gcc_init and gcc_finish; this
+	is now done by runtest.exp. Use gcc_target_compile instead of
+	compile.
+
+	lib/c-torture.exp: Use gcc_target_compile instead of compile.
+	Remove references to CFLAGS. Use remote_file instead of
+	calling rm -f.
+	(c-torture): Take a list of arguments to use to compile this
+	testcase.
+
+	lib/g++.exp: Simplify. Use target_compile instead of compile.
+	lib/gcc-dg.exp: Ditto.
+	lib/gcc.exp: Ditto.
+	lib/mike-{gcc,g++}.exp: Ditto.
+	lib/old-dejagnu.exp: Ditto.
+	lib/plumhall.exp: Ditto.
+	
+Wed Jan  8 14:43:07 1997  Jim Wilson  <wilson@cygnus.com>
+
+	* lib/plumhall.exp (ph_make): Use CFLAGS and ANSICFLAGS when linking.
+	(ph_linker): Likewise.
+
+Wed Nov 13 16:04:19 1996  Joern Rennecke <amylaar@cygnus.com>
+
+        * gcc.c-torture/execute/{loop-2e.c,loop-2f.c}: Only use
+	MAP_ANON / MAP_ANONYMOUS if defined;
+	else try to map from /dev/zero .
+
+Tue Nov 12 23:30:12 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture/execute/{loop-2e.c,loop-2f.c}:  If MAP_ANON
+	isn't defined, then define it to MAP_ANONYMOUS.
+
+Tue Nov 12 11:57:49 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.42 release.
+
+Mon Nov 11 12:45:31 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.41 release.
+
+Sun Oct 27 18:56:18 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture/execute/enum-1.c: New test.  Will be in next
+	c-torture release.
+
+Thu Aug 15 11:09:36 1996  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/gcc.exp (gcc_init): Always append the target_info to CFLAGS
+	and LDFLAGS.  Fix second case to append the target_info ldflags
+	onto LDFLAGS, not CFLAGS.
+	* lib/g++.exp (g++_init): Add target_info stuff.
+	* lib/old-dejagnu.exp (old-dejagnu-init): Likewise.  Add inclusion
+	of libgloss and newlib flags for !native.
+
+	* config/proelf.exp: Load remote.exp and do `push_target hppro'.
+	(GDB): Fix relative path to go up another dir for finding gdb.
+
+Thu Aug  8 17:03:27 1996  Rob Savoye  <rob@chinadoll.cygnus.com>
+
+	* lib/gcc.exp(gcc_init): Set CFLAGS and LDFLAGS to their new
+	versions in the target_info array, if they don't exist.
+
+Fri Aug  2 15:39:03 1996  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* config/vx.exp (${tool}_load): Fix syntax of `$shell_id < 0'.
+
+Mon Jul  8 15:45:58 1996  Jim Wilson  <wilson@cygnus.com>
+
+	* lib/g++.exp: Change all uses of $base_dir/ to $base_dir/../.
+	* lib/gcc.exp, lib/old-dejagnu.exp: Likewise.
+
+Mon Jul  1 15:53:00 1996  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/old-dejagnu.exp: Don't remove the output file before we've
+	actually tested it. Don't append pwd to the path of the executable
+	we're testing.
+
+Sun Jun 30 14:37:50 1996  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/g++.exp (default_g++_start): Don't pass LDFLAGS, LIBS if -c.
+
+Wed Jun 26 14:15:55 1996  Bob Manson  <manson@charmed.cygnus.com>
+
+	* lib/old-dejagnu.exp (old-dejagnu): Add $tmpdir to specify a
+ 	temporary directory for compiler files, and set it to a default
+ 	value of /tmp. Set $output as the name of the output file from
+ 	compiling the testcase. Add a -o option to $cflags_var so the
+ 	compiler writes the final output file as $output. Set $executable
+ 	to $output.
+
+	* lib/mike-g++.exp (postbase): Add $tmpdir to specify a temporary
+ 	directory for compiler files, and set it to /tmp if it doesn't
+ 	already have a value. Set $output_file to the name of the output
+ 	file from compiling the testcase. Add a -o option to CXXFLAGS so
+ 	the compiler writes the final output file as $output. Use $output
+ 	as the executable to be tested.
+
+Mon Jun 24 17:12:16 1996  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp: Also add -Wl,-rpath,... for linux.
+
+Sat Jun  8 15:12:24 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture/execute/pending-1.c: New test.  Still
+	pending in Tege's queue.
+
+Wed Apr 24 18:13:45 1996  Jim Wilson  <wilson@chestnut.cygnus.com>
+
+	* lib/plumhall.exp (ph_summary): Add arguments name and exec_status.
+	Add variables local_failcnt and local_unresolvedcnt.  Call gcc_fail
+	if there were failures.  Call unresolved if there were unresolved
+	testcases.  Call gcc_fail if program did not run to completion.
+	(ph_make): Pass additional argument name to ph_execute.
+	(ph_execute): Add new argument.  Pass additional arguments to
+	ph_summary.  Call gcc_fail is there is no execution output.
+
+Wed Apr 24 13:39:23 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* lib/plumhall.exp (proc_summary): Output relavent summary
+	lines into the log so specific failures in plumhall can be
+	investigated.
+
+Wed Apr 10 13:23:45 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* lib/c-torture.exp: Provide a default value for $NO_LONG_LONG.
+	(c-torture-execute): Don't try to execute tests which use
+	"long long" types if $NO_LONG_LONG is nonzero.
+
+Mon Apr  8 08:52:29 1996  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/execute/ieee/ieee.exp: Run c-torture-execute,
+	not c-torture.
+
+	* gcc.ieee: Move from here.
+	* gcc.c-torture/execute/ieee: To here.
+
+Tue Mar 26 23:41:18 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.41 release.
+
+Fri Mar 22 15:49:24 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* lib/c-torture.exp (c-torture-execute): Remove "$executable",
+	not "$output".
+
+Thu Mar  7 12:37:08 1996  Doug Evans  <dje@charmed.cygnus.com>
+
+	* lib/gcc.exp (default_gcc_start): Don't pass $LDFLAGS $LIBS if
+	-c present.
+
+Sat Mar  2 22:36:37 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* config/proelf.exp: Handle connecting to a simulator.
+
+Wed Jan 31 00:58:15 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* config/proelf.exp: New file.  Enough framework that we can
+	run c-torture tests on the proelf targets (or any other target
+	that gdb can connect to for that matter).
+
+Mon Jan 29 08:57:46 1996  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/special/special.exp: Delete libs arg to dg-runtest.
+	* gcc.ph/testing/limits/limits.exp: Likewise.  Don't pass $CFLAGS.
+
+	* lib/plumhall.exp (ph_execute): Always call ph_summary if
+	exec_output exists.
+
+Sun Jan 28 11:28:43 1996  Doug Evans  <dje@charmed.cygnus.com>
+
+	* config/sim.exp (SIM_TIME_LIMIT): New user settable variable.
+	(${tool}_load): Use 240 seconds if SIM_TIME_LIMIT not set.
+
+	* config/*.exp: Update FSF address.  Change result of ${tool}_load
+	to pass/fail/unresolved/unsupported/untested.  Caller must now
+	call unresolved/unsupported/untested.
+	* lib/*.exp: Update FSF address.  Update to handle new results of
+	${tool}_load.
+	* lib/chill.exp (verbose): Delete.
+
+Sat Jan 27 12:28:07 1996  Doug Evans  <dje@charmed.cygnus.com>
+
+	* lib/gcc.exp (default_gcc_start): Change order of args to
+	$LDFLAGS $CFLAGS $LIBS.
+	* lib/gcc-dg.exp (gcc-dg-test): Arguments have changed, update.
+	Save/set/restore CFLAGS.  Pass single arg to gcc_start.
+	* gcc.dg/dg.exp: Delete libs arg in call to dg-runtest.
+	(CC,CFLAGS,LIBS): Delete references. Don't pass $CFLAGS to dg-runtest.
+	* gcc.misc-tests/dg-test.exp: Likewise.
+	* gcc.misc-tests/msgs.exp: Likewise.
+	* gcc.prms/prms.exp: Likewise.
+	* gcc.misc-tests/gcov.exp: Delete libs arg in call to dg-runtest.
+	(CFLAGS,LIBS): Delete references.  Don't pass $CFLAGS to dg-runtest.
+
+	* lib/dg.exp: Deleted, moved to dejagnu/lib.
+
+Wed Jan 24 18:37:00 1996  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* g++.old-deja/old-deja.exp: Add passing of $mathlib to old-dejagnu.
+
+	* g++.old-deja/old-deja.exp: Move setting of runshlib from here...
+	* lib/old-dejagnu.exp (old-dejagnu-init): ...to here.
+
+	* lib/g++.exp (g++_init): Take out use of -rpath for the sun4, not
+	necessary.
+
+Sat Jan 20 17:22:08 1996  Brendan Kehoe  <brendan@cygnus.com>
+
+	* g++.old-deja/old-deja.exp: Move setting of runshlib out of the
+	global for loop; add use of $mathlib.
+	* lib/old-dejagnu.exp (old-dejagnu-init): Put the runshlib
+	settings here; set mathlib for anything but VxWorks.
+
+Mon Jan 22 16:31:57 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.40 release.
+
+Wed Jan  3 00:54:33 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.ph/testing/limits/limits.exp: Load ${tool}-dg.exp, not
+	dg.exp.
+
+Sun Dec  3 16:17:42 1995  Jeffrey A. Law  <law@sethra.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-execute): Declare "output" as
+	global.
+
+Fri Nov 17 20:01:19 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/g++.exp (LIBS): Define if not already.
+	* lib/gcc-dg.exp (gcc-dg-test): Set executable file as a.out.
+	(gcc-dg-prune): Call prune_gcc_output.
+	* lib/gcc.exp (prune_gcc_output): New proc.
+	* gcc.c-torture/special (921210-1.c): Call prune_system_crud and
+	prune_gcc_output.
+
+Thu Nov 16 09:15:40 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-compile): Fix calls to `unsupported'.
+	(c-torture-execute): Likewise.	Rename `name' to `testcase'.
+
+Wed Nov 15 23:04:36 1995  Jeffrey A Law  (law@cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.39 release.
+
+Sat Nov  4 12:52:05 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-execute): Don't return if one option
+	fails, try others as well.
+
+Thu Nov  2 09:28:35 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-execute): This proc's result is `void'.
+	If compilation fails, mark execute tests as `untested'.
+	If test is marked as unsupported, don't mark compilation and
+	execute tests as failed.
+
+Wed Oct 25 20:57:55 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp (g++_init): Don't link in libg++, and look to
+	libstdc++ for whether or not we want to be doing shared
+	libraries.  Delete link_curses since we don't need it anymore.
+	* lib/mike-g++.exp (postbase): Don't link in libg++.
+	* g++.old-deja/old-deja.exp: Likewise.
+
+Mon Oct 23 13:05:11 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp (CXX): Default to run `c++' instead of `g++'.
+
+Tue Oct 17 15:24:47 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp (g++_init): Also check for libg++.sl for the hppa.
+	For that, add `-Wl,-a,shared_archive'.
+	* g++.old-deja/old-deja.exp: Likewise.
+
+Tue Oct 17 13:09:06 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-execute): Ensure CFLAGS restored.
+
+Mon Oct 16 23:13:32 1995  Brendan Kehoe  <brendan@cygnus.com>
+
+	* lib/mike-g++.exp (postbase): Pay attention to the status of
+	g++_load.
+
+Mon Oct 16 19:28:32 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+        * g++.old-deja/old-deja.exp: Add $LIBS at the end of the args.
+
+Mon Oct 16 13:48:58 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/gcc.exp (default_gcc_start): No longer need to log program
+	being executed or its output, execute_anywhere does that now.
+	* lib/g++.exp (default_g++_version): Call execute_anywhere.
+	(default_g++_start): Likewise.  Delete calls to verbose/send_log.
+
+Thu Oct 12 10:34:58 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* g++.old-deja/old-deja.exp: Updated the shared libg++ tests to be
+	the same as those in lib/g++.exp.
+
+Tue Oct 10 13:47:27 1995  Jeff Law  (law@hurl.cygnus.com)
+
+	* gcc.c-torture: Update to c-torture-1.38 release.
+	* gcc.ieee: Related changes.
+
+Fri Oct  6 12:39:17 1995  Rob Savoye  <rob@darkstar.cygnus.com>
+
+	* mike-gcc.exp, mike-g++.exp: Use "execute_anywhere" rather than
+	"exec". Minor reformatting changes.
+
+	* config/rom68k.exp (${tool}_load): Make it work in a canadian
+	cross. This means all "exec" calls now work on a remote host as
+	well.
+	* lib/c-torture.exp (c-torture-compile): Make work for a canadian
+	cross. Filter out the extra "\r\n" stuff that expect puts in.
+	(c-torture-execute): Filter out the bogus warnings like
+	c-torture-compile does. Add support for canadian cross.
+	* lib/gcc.exp (default_gcc_version, default_gcc_start)
+	Use execute_anywhere rather than calling exec directly. Now it
+	works for canadian cross testing.
+
+Thu Oct  5 10:06:45 1995  Brendan Kehoe  <brendan@rtl.cygnus.com>
+
+	* lib/g++.exp: Add -nocomplain flag to glob.  Use catch to put the
+	results into a variable, and check that rather than using file exists.
+
+Wed Oct  4 16:31:02 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp: Use glob to see libg++.so.2.7.0, since sun4 doesn't
+	create a libg++.so.  For sunos4.1.*, also add -ltermcap.
+
+Tue Sep 26 10:15:14 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* g++.old-deja/old-deja.exp: Create and pass runshlib and
+	lib_curses if there's a shared libg++ in the build tree.
+
+Fri Sep 22 10:47:24 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/mike-{gcc,g++}.exp (postbase): Restore CFLAGS, CXX_FLAGS, LIBS
+	if not supported target.
+
+Fri Sep 22 09:22:07 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp (g++_init): Move empty setting of runshlib and
+	link_curses up to always happen, not just for native builds.
+
+Thu Sep 21 10:23:32 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.c-torture: Update to c-torture-1.36 release.
+	* gcc.failure: Related changes.
+
+Wed Sep 20 10:56:26 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/plumhall.exp (PHSRC, PHDST): Allow config files to override.
+
+Tue Sep 19 17:26:07 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/g++.exp (g++_init): Put the shared and math lib stuff in here.
+	* lib/mike-g++.exp (postbase): Not in here.  Still reference
+	runshlib, link_curses, and mathlib for link and run.
+
+	* lib/mike-g++.exp (postbase): If we've built a libg++.so, then
+	pass the runtime shared library options for Solaris, OSF/1, and
+	Irix5, and link with -lcurses to avoid unresolved references.
+	
+Wed Sep 13 15:28:10 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/gcc.exp (gcc_init): Return if gcc_initialized is 1, so we
+	only run once.
+
+Wed Sep 13 10:51:52 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-compile): Don't alter CFLAGS.
+
+Mon Sep 11 11:02:03 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.c-torture: Update to c-torture-1.35 release.  Note we
+	do not have a framework for the "compat" tests yet.
+
+Sat Sep  9 16:15:20 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/mike-g++.exp (postbase): New local variable `mathlib',
+	set to null if we're testing vxworks5.1.  Use that instead of
+	`-lm' in the setting of LIBS for link and run.
+
+Fri Sep  8 13:53:38 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* config/rom68k.exp (${tool}_load): Major changes to make it
+	work.  Verified that it does in fact return the stuff in
+	exec_output properly.  Catch any Emul or any TRAP other than 0.
+
+Thu Sep  7 23:04:06 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* lib/mike-g++.exp (prebase): Call g++_init at the end to set
+	LDFLAGS properly for targets that need stuff from libgloss.
+	* lib/g++.exp (g++_init): Return if gpp_initialized is 1, so we
+	only run once.
+	(gpp_initialized): New variable.
+
+Wed Sep  6 21:56:13 1995  Rob Savoye  <rob@darkstar.cygnus.com>
+
+	* config/rom68k.exp: Load libgloss.exp.
+	* lib/gcc.exp (gcc_init): get proper flags for newlib and libgloss
+	so we can produce a fully linked binary.
+	* lib/g++.exp (g++_init): get proper flags for newlib and libgloss
+	so we can produce a fully linked binary.
+
+Sun Sep  3 13:25:26 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/plumhall.exp (ph_section): Watch for expected failures.
+	Add missing `else'.
+
+	* lib/c-torture.exp (c-torture-execute): Look for .cexp files to
+	run the testcase.
+	(c-torture): Likewise.
+
+Mon Aug 28 11:23:38 1995  Doug Evans  <dje@cygnus.com>
+
+	* gcc.dg/dg.exp (scan-assembler, scan-assembler-not): New procs.
+
+	* lib/mike-g++.exp (mike_cleanup): New proc.
+	(prebase): New globals compiler_result, not_compiler_result,
+	target_regexp.
+	(postbase): Likewise.  Call mike_cleanup.  Pass "--" to regexp to
+	allow leading "-" in pattern.  Watch for unsupported tests.
+	If $compiler_result is set, pattern match assembler code,
+	and ditto for $not_compiler_result.
+	* lib/mike-gcc.exp: Likewise.
+
+	* lib/plumhall.exp (ph_execute): Only call ph_summary if
+	execution "succeeded".
+
+Mon Aug 14 14:03:53 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* config/win32.exp: New file.
+	* lib/c-torture.exp (c-torture-execute): Handle $exe_ext.
+
+Fri Aug  4 15:39:54 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/gcc-dg.exp (gcc-dg-prune): Mark testcases that fill ram as
+	unsupported.
+	* lib/mike-{gcc,g++}.exp (postbase): Likewise.
+	* lib/{c-torture.exp,old-dejagnu.exp}: Likewise.
+	* lib/{gcc,g++}.exp (${tool}_check_untested_p): New proc.
+
+	* lib/mike-g++.exp (postbase): Delete alpha-*-* checking of
+	"... without exceptions was ...".  That is now handled by
+	prune_system_crud.
+	* lib/old-dejagnu.exp (old-dejagnu): Likewise.
+
+Tue Aug  1 11:09:33 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.misc-tests/{acker1.c,dhry.c,dhry.h,matrix1.c,optbench.c,
+	sieve.c,sort2.c}: New files.
+	* gcc.misc-tests/{acker1.exp,dhry.exp,matrix1.exp,optbench.exp,
+	sieve.exp,sort2.exp}: Drivers for them.
+
+	* lib/mike-gcc.exp (program_output): New user settable variable.
+	(postbase): Call prune_system_crud.  Also prune extraneous compiler
+	messages.
+	* lib/mike-g++.exp (program_output): New user settable variable.
+
+	* gcc.misc-tests/mg.exp (compiler_output): Handle multiple lines.
+
+	* config/sh.exp: Deleted (use sim.exp instead).
+
+Fri Jul 28 11:33:46 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* config/vx.exp: Declare CHECKTASK as global.
+	* config/vxworks29k.exp: Reduce to only set CHECKTASK, and load vx.exp.
+	* lib/mike-g++.exp: Load [pwd]/a.out, not `./a.out'.
+	* lib/old-dejagnu.exp: Load [pwd]/$executable.
+
+Wed Jul 26 19:45:39 1995  Brendan Kehoe  <brendan@lisa.cygnus.com>
+
+	* config/vxworks29k.exp: New file, for the a29k-vxworks5.1
+	target. Like vx.exp, only includes `vx29k.exp' instead of
+	`vxworks.exp'.
+
+Sun Jul 23 17:38:52 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+	* config/sim.exp: Increase time limit from 120 seconds to 240.
+
+Thu Jul  6 11:07:38 1995  Jeffrey A. Law  <law@rtl.cygnus.com>
+
+	* gcc.c-torture/execute/950628-1.c: New test.
+
+Sat Jun 10 18:51:41 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.c-torture: Update with changes/additions from
+	c-torture-1.34.
+
+Mon Jun  5 17:58:07 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.prms/prms.exp: Pass LDFLAGS to dg-test.
+
+Sun Jun  4 05:13:57 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.c-torture/compile/funcptr-1.c: Test case for 7107.
+
+Thu Jun  1 00:06:19 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.c-torture/compile/950512-1.c: New test.
+	* gcc.c-torture/execute/strct-pack-4.c, strct-pack-5.c}: Likewise.
+	* gcc.dg/struct-ret-1.c: Likewise.
+
+Wed May 31 14:25:13 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/execute/{920410-1.c,921113-1.c,921208-2.c,
+        930106-1.c,memcpy-1.c}: Use STACK_SIZE if defined.
+
+Tue May 30 11:19:54 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/special/920411-1.c: Deleted.
+	* gcc.c-torture/special/special.exp: Delete 920411-1.c.
+
+Mon May 22 16:55:11 1995  Doug Evans  <dje@chestnut.cygnus.com>
+
+	* config/sim.exp (${tool}_load): Hack in call to bash to get a
+	cpu limit.
+
+Fri May 12 18:57:54 1995  Torbjorn Granlund  <tege@rtl.cygnus.com>
+
+	* gcc.c-torture/execute/{950511-1.c,950512-1.c}: New tests.
+
+Thu May  4 14:23:54 1995  Torbjorn Granlund  <tege@adder.cygnus.com>
+
+	From kenner;
+	* gcc.c-torture/execute/va-arg-2.c (f[0-9], f1[0-5]): Verify format
+	is the proper length.
+	* va-arg-3.c: Likewise.
+
+Sun Apr 30 16:02:59 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp: Moved to dejagnu/lib.  Copy kept here (for awhile).
+	* lib/gcc-dg.exp: New file, gcc interface to dg.exp.
+
+	* lib/gcc.exp (default_gcc_start): Delete old cruft.  Delete result.
+	* lib/g++.exp (default_g++_start): Delete old cruft.
+
+Tue Apr 25 17:20:18 1995  Torbjorn Granlund  <tege@cygnus.com>
+
+	* gcc.c-torture/execute/memcpy-1.c: Decrease stack requirements from
+	(2 * (1 << 18)) to (2 * (1 << 17)).
+
+	* gcc.c-torture/execute/arith-rand.c: Avoid -0x80000000/-1.
+
+Thu Apr 20 12:21:13 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+	* config/rom68k.exp: Renamed from config/idp.exp
+
+Tue Apr 18 13:33:26 1995  Torbjorn Granlund  <tege@rtl.cygnus.com>
+
+	* c-torture/compile/921109-2.c
+
+Tue Apr 18 10:45:12 1995  Mike Stump  <mrs@cygnus.com>
+
+	* lib/old-dejagnu.exp: We expect Execution test failure if we expected
+	excess errors.
+
+Sat Apr 15 11:16:58 1995  Doug Evans  <dje@chestnut.cygnus.com>
+
+	* lib/gcc.exp (default_gcc_start): Handle leading "-" in compiler
+	output.
+	* lib/g++.exp (default_g++_start): Likewise.
+
+Wed Mar 29 16:34:03 1995  Torbjorn Granlund  <tege@adder.cygnus.com>
+
+	* gcc.c-torture/compile/950329-1.c: New test.
+
+Tue Mar 28 16:10:33 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+        * config/bug.exp (${tool}_load): Updated to use new remote_open
+	  and remote_close procs.
+	* config/idp.exp: New file.
+
+Wed Mar 22 15:01:58 1995  Torbjorn Granlund  <tege@rtl.cygnus.com>
+
+	* gcc.c-torture/execute/950322-1.c: New test.
+
+Tue Mar 21 21:24:49 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* config/vx.exp (${tool}_load): Clean up testing of return code from
+	vxworks_ld and vxworks_spawn.
+
+Tue Mar 21 17:01:42 1995  Doug Evans  <dje@deneb.cygnus.com>
+
+	* lib/c-torture.exp (c-torture-execute): Pass same text to pass/fail.
+
+Mon Mar 13 14:49:42 1995  Mike Stump  <mrs@cygnus.com>
+
+	* lib/old-deja.exp: Add `excess errors test - ' error, now one
+	can mark excess errors on a machine by machine basis.  Note, the
+	default is to not expect any excess errors, even when excess
+	errors test - is given, so you will want to put an XFAIL ... on
+	these lines.  For example, // excess errors test - XFAIL hppa*-*-*
+	mips-*-* alpha-*-* m68k-*-* is how to expect excess errors on
+	those 4 machines, but no others.
+
+Fri Mar 10 12:33:04 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+	* gcc.c-torture/execute/execute.exp (c-torture-execute): from here.
+	* lib/c-torture.exp: to here.
+
+Fri Mar 10 10:38:15 1995  Torbjorn Granlund  <tege@adder.cygnus.com>
+
+	* gcc.c-torture/execute/950221-1.c: New test.
+	* gcc.c-torture/execute/struct-ret-1.c: New test.
+	* gcc.c-torture/compile/950221-1.c: New test.
+
+	* gcc.c-torture/execute/941101-1.c (f): Fix typo, == was !=.
+
+Fri Mar  3 16:28:35 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/execute/arith-1.c (main): Return 0.
+	* gcc.c-torture/execute/arith-rand.c (main): Return 0.
+
+Wed Mar  1 02:08:29 1995  Gerald Baumgartner  (gb@lorenzo.cs.purdue.edu)
+
+	* g++.gb: New directory of tests, derived from my signature and
+	class scoping tests.
+
+	* g++.gb/{sig01.C, sig02.C, sig03.C, sig04.C}: New tests.
+	* g++.gb/{sig05.C, sig06.C, sig07.C, sig08.C}: Likewise.
+	* g++.gb/{sig09.C, sig10.C, sig11.C, sig12.C}: Likewise.
+	* g++.gb/{sig13.C, sig14.C, sig15.C, sig16.C}: Likewise.
+	* g++.gb/{sig17.C, sig18.C, sig19.C, sig20.C}: Likewise.
+	* g++.gb/{sig21.C, sig22.C, sig23.C, sig24.C}: Likewise.
+	* g++.gb/sig25.C: Likewise.
+
+	* g++.gb/{sig01.exp, sig02.exp, sig03.exp, sig04.exp}: Run them.
+	* g++.gb/{sig05.exp, sig06.exp, sig07.exp, sig08.exp}: Likewise.
+	* g++.gb/{sig09.exp, sig10.exp, sig11.exp, sig12.exp}: Likewise.
+	* g++.gb/{sig13.exp, sig14.exp, sig15.exp, sig16.exp}: Likewise.
+	* g++.gb/{sig17.exp, sig18.exp, sig19.exp, sig20.exp}: Likewise.
+	* g++.gb/{sig21.exp, sig22.exp, sig23.exp, sig24.exp}: Likewise.
+	* g++.gb/sig25.exp: Likewise.
+
+	* g++.gb/{scope01.C, scope02.C, scope03.C, scope04.C}: New tests.
+	* g++.gb/{scope05.C, scope06.C, scope07.C, scope08.C}: Likewise.
+	* g++.gb/{scope09.C, scope10.C, scope11.C, scope12.C}: Likewise.
+	* g++.gb/scope13.C: Likewise, this test still fails.
+
+	* g++.gb/{scope01.exp, scope02.exp, scope03.exp, scope04.exp}: Run 'em.
+	* g++.gb/{scope05.exp, scope06.exp, scope07.exp, scope08.exp}: Ditto.
+	* g++.gb/{scope09.exp, scope10.exp, scope11.exp, scope12.exp}: Ditto.
+	* g++.gb/scope13.exp: Ditto.
+
+	* g++.gb/README: New file, explains what these tests are about.
+
+Tue Feb 28 10:37:52 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp (dg-do): Support `preprocess'.
+	(dg-test): Likewise.
+
+Mon Feb 13 15:18:10 1995  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+	* config/udi.exp: change "continue -expect" to "exp_continue".
+
+Sat Feb 11 00:25:20 1995  Torbjorn Granlund  (tege@tiny.cygnus.com)
+
+	* gcc.c-torture/execute/{921025-1.c, 930525-1.c}:
+	Delete redundant tests.
+
+	* gcc.c-torture/execute/{941014-1.c, 941014-2.c}: New tests.
+	* gcc.c-torture/execute/{941015-1.c, 941021-1.c}: New tests.
+	* gcc.c-torture/execute/{941025-1.c, 941031-1.c}: New tests.
+	* gcc.c-torture/execute/{941101-1.c, 941110-1.c}: New tests.
+	* gcc.c-torture/execute/{941202-1.c, arith-1.c}: New tests.
+	* gcc.c-torture/execute/{arith-rand.c, complex-3.c}: New tests.
+	* gcc.c-torture/execute/{inst-check.c, loop-1.c}: New tests.
+	* gcc.c-torture/execute/{memcpy-1.c, va-arg-2.c}: New tests.
+
+	* gcc.c-torture/execute/920302-1.c: Use void * instead of long for
+	storing label pointers.
+	* gcc.c-torture/execute/921019-1.c: Likewise.
+	* gcc.c-torture/execute/920501-8.c: Add prototype for sprintf.
+	* gcc.c-torture/execute/930513-1.c: Provide full declaration for
+	parameter fp.
+	* gcc.c-torture/execute/va-arg-1.c (main): Add L suffix to all
+	constants.
+
+	* gcc.c-torture/compile/{920501-14.c, 931127-1.c}:
+	Delete obsolete tests.
+
+	* gcc.c-torture/compile/{940409-1.c, 940718-1.c}: New tests.
+	* gcc.c-torture/compile/{941014-1.c, 941014-2.c}: New tests.
+	* gcc.c-torture/compile/{941014-3.c, 941014-4.c}: New tests.
+	* gcc.c-torture/compile/{941019-1.c, 941111-1.c}: New tests.
+	* gcc.c-torture/compile/{941113-1.c, 950122-1.c}: New tests.
+	* gcc.c-torture/compile/950124-1.c: New test.
+
+	* gcc.c-torture/compile/920902-1.c: Delete 2:nd parameter.
+
+Wed Feb  8 15:30:17 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* lib/mike-g++.exp: Add -lm to LIBS.
+
+Tue Feb  7 17:09:50 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/c-torture.exp (c-torture): Allow relative pathname in $srcdir.
+
+Mon Jan 30 14:33:25 1995  Jason Merrill  <jason@phydeaux.cygnus.com>
+
+	* lib/mike-g++.exp: Add -lstdc++ to LIBS.
+
+Thu Jan 12 16:41:34 1995  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.misc-tests/dg-test.exp: Only run if $DG_TEST=yes.
+
+Mon Jan  2 11:50:10 1995  Jeff Law  (law@snake.cs.utah.edu)
+
+	* g++.law/{arg9.C, arg10.C, arg11.C, arm15.C, arm16.C}: New tests.
+	* g++.law/{bad-error3.C, bad-error4.C, bad-error5.C}: Likewise.
+	* g++.law/{bad-error6.C, bad-error7.C}: Likewise.
+	* g++.law/{bit-fields3.C, casts2.C, casts3.C}: Likewise.
+	* g++.law/{enum8.C, enum9.C, friend5.C}: Likewise.
+	* g++.law/{nest2.C, nest3.C, nest4.C, nest5.C}: Likewise.
+	* g++.law/{nest6.C, next7.C, operators30.C}: Likewise.
+	* g++.law/{operators31.C, operators32.C, 
+	* g++.law/{operators33.C, operators34.C}: Likewise.
+	* g++.law/{pic1.C, refs2.C}: Likewise.
+	* g++.law/{refs3.C, refs4.C, static-mem3.C}: Likewise.
+	* g++.law/{static-mem4.C, static-mem5.C, typeck4.C}: Likewise.
+	* g++.law/{vbase1.C, visibility27.C, visibility28.C}: Likewise.
+	* g++.law/{vtable2.exp, vtable3.exp}: Likewise.
+
+	* g++.law/{arg9.exp, arg10.exp, arg11.exp, arm15.exp}: Run them.
+	* g++.law/{arm16.exp, bad-error3.exp, bad-error4.exp: Likewise.
+	* g++.law/{bad-error5.exp, bad-error6.exp}: Likewise.
+	* g++.law/{bad-error7.exp, bit-fields3.exp}: Likewise.
+	* g++.law/{casts2.exp, casts3.exp, enum8.exp}: Likewise.
+	* g++.law/{enum9.exp, friend5.exp}: Likewise.
+	* g++.law/{nest3.exp, nest4.exp}: Likewise.
+	* g++.law/{nest5.exp, nest6.exp, nest7.exp}: Likewise.
+	* g++.law/{operators30.exp, operators31.exp}: Likewise.
+	* g++.law/{operators32.exp, operators33.exp}: Likewise. 
+	* g++.law/{operators34.exp}: Likewise.
+	* g++.law/{pic1.exp, refs2.exp, refs3.exp refs4.exp}: Likewise.
+	* g++.law/{static-mem3.exp, static-mem4.exp}: Likewise.
+	* g++.law/{static-mem5.exp, typeck4.exp, vbase1.exp}: Likewise.
+	* g++.law/{visibility27.exp, visibility28.exp}: Likewise.
+	* g++.law/{vtable2.exp, vtable3.exp}: Likewise.
+
+	* g++.law/{union4.exp, visibility17.exp}: Fix expected output.
+	No longer expected to fail.
+	* g++.law/missed-error3.C: Tweak for recent bool changes.
+
+Sun Dec  4 20:54:33 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* config/emb-unix: Deleted.
+	* config/unix.exp (${tool}_load): Use new proc rsh_exec to perform
+	remote execution.  Do final link on remote host if REMOTE_LINK is set.
+
+Thu Dec  1 08:43:05 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp (dg-test): Fix typo in last patch.
+
+Wed Nov 30 13:25:32 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp (dg-test): Fix pattern that searches for expected output
+	(handles multiple occurrences).
+
+Thu Nov 24 19:48:38 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/*/*.exp: Pass full pathname to c-torture.
+	* gcc.c-torture/execute/execute.exp (c-torture-execute): Remove
+	$srcdir from pathname in pass/fail messages (but ensure $subdir *is*
+	printed).
+	* lib/c-torture.exp (c-torture-compile): Likewise.
+	(c-torture): Prepend full path if missing.
+	* lib/gcc.exp (gcc_pass): Pass entire pathname of testcase.
+	(gcc_fail): Likewise.
+	* lib/dg.exp (dg-test): Don't delete $subdir from pathname in messages.
+
+Wed Nov 23 13:56:00 1994  J.T. Conklin  <jtc@rtl.cygnus.com>
+
+	* lib/netware.exp: Only attach to NetWare i386 systems.
+
+Wed Nov 16 11:27:00 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp (dg-test): Don't print $subdir (or above) in pass/fail
+	messages.  Add test name to "output pattern match" pass/fail message.
+
+Sat Nov 12 22:11:52 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.dg: New testsuite.
+	* gcc.dg/dg.exp: New file.
+
+	* gcc.misc-tests/{misc.exp,inst-check.c,test-ior.c,test-consts.c,
+	test-switch.c}: Deleted.
+
+	* gcc.misc-tests/msgs.exp: New testcase driver.
+
+Wed Nov  9 14:23:09 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.c-torture/execute/execute.exp (c-torture_execute): New proc.
+	Watch for illegal return values from ${tool}_load.
+	* config/unix.exp (${tool}_load): Fix pass/fail detection for
+	cross targets.  Coerce return value >0 to 1.
+
+Tue Nov  8 14:10:33 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* config/unix.exp (${tool}_load): Call program rsh, not proc.
+
+	* config/emb-unix.exp: New file.
+
+	* config/sim.exp: Error if variable $SIM not defined.
+	(${tool}_load): Mark test as "untested" if simulator missing.
+
+	* config/unix.exp: Load remote.exp to get rcp_download.
+	* lib/c-torture.exp: Use different option lists for testcases with
+	and without loops.
+	* gcc.c-torture/execute/execute.exp: Likewise.
+
+Wed Nov  2 14:47:58 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* config/*.exp: Clarify return code from ${tool}_load.
+	Call `unresolved' or `untested' instead of `warning' or `perror'
+	(sometimes you still want to call both though).
+	Add comment that `shell_id' is local to each file.
+	* config/udi.exp (timeout): Set to 30.
+	Don't print warning if connection fails, $connectmode has already
+	printed an error.
+	(${tool}_load): Move verbose messages to level 2.
+	Rework pattern for "Process started" message.
+	Pass `shell_id' to ${connectmode}_download.
+	Retry twice upon timeout.  Make resetting of target more robust.
+	(${tool}_exit): Remove /tmp/soc_name. if connected ok (bug in mondfe).
+	Pass `shell_id' to exit_$connectmode.
+	Only call exit_$connectmode if connected.
+	* config/unix.exp (${tool}_load): Check return codes better.
+	* config/vrtx.exp (${tool}_load): Likewise.
+	* config/vx.exp (${tool}_load): Likewise.
+	Delete unneeded global's.
+	* lib/dg.exp (dg-test): Update to reflect clarified return codes
+	from ${tool}_load.
+	(dg-stat): Delete.
+	(dg-init): Delete recording of pass/fail counts.
+	* lib/old-dejagnu.exp (old-dejagnu): Likewise.
+	(old-dejagnu-init): Likewise.
+	(old-dejagnu-stat): Delete contents, empty proc now.
+	* lib/c-torture.exp (TORTURE_OPTIONS): New global.
+	(c-torture): Delete references to lcnt, lpass, lfail.
+	Get option list from TORTURE_OPTIONS.
+	Delete -funroll[-all]-loops if no loops.
+	* lib/g++.exp (g++_init): Delete references to lcnt, lpass, lfail.
+	(g++_stat): Delete contents (empty proc now).
+	* lib/gcc.exp (gcc_init): Delete references to pass/fail counts.
+	(gcc_finish): Likewise.
+	(gcc_stat): Deleted.
+	* lib/mike-gcc.exp (postbase): Delete references to lcnt, lpass, lfail.
+	* gcc.*/*.exp: Delete calls to gcc_stat, dg-stat.
+	* gcc.c-torture/execute/execute.exp: Likewise.
+	Split tests into two parts: compile, execute.
+	Get option list from TORTURE_OPTIONS.  Delete -funroll[-all]-loops if
+	no loops.  Update to reflect clarified return codes from ${tool}_load.
+
+Fri Oct 21 23:10:16 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/old-dejagnu.exp (process-option): Append ".*" to pattern
+	to grep for.
+	(old-dejagnu): Likewise (where necessary).
+
+Fri Oct 14 17:54:58 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* gcc.misc-tests/gcov.exp: New file, for gcov testing.
+
+	* lib/dg.exp (dg-process-target): Fix processing of selector.
+	Add comment regarding use of `error'.
+
+	* lib/gcc.exp (prune_system_crud): Define if missing.
+	* lib/g++.exp (prune_system_crud): Likewise.
+
+	* lib/{c-torture.exp,dg.exp,mike-g++.exp,old-dejagnu.exp}:
+	Call prune_system_crud.
+	* lib/dg.exp (dg-runtest): New proc.
+	Use perror instead of send_user for tcl errors in testcase.
+	Don't return any value, it's never used.
+	Don't clobber previous definition of `unknown'.
+	Print tcl errors in `dg-final'.
+
+Wed Oct 12 13:05:37 1994  Doug Evans  <dje@canuck.cygnus.com>
+
+	* lib/dg.exp (dg-process-target): Improve syntax error messages.
+	(dg-test): Don't print errorInfo, it contains stack backtrace.
+
+Mon Sep 26 12:18:53 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/g++.exp (runtest_file_p): Define if missing.
+
+Sat Sep 24 15:29:23 1994  Doug Evans  (dje@cygnus.com)
+
+	* lib/mike-g++.exp: Comment out loading of g++.exp.
+	* lib/g++.exp: Update copyright.  Test for existence of $CXX at start.
+	(default_g++_version): Always print something.
+	(default_g++_start): Comment out call to `which'.
+	(g++_start, g++_load): Deleted (must be defined in config file).
+	* lib/gcc.exp: Test for existence of $CC at start.
+	Delete check for tmpdir (done in gcc_init).
+	(default_gcc_version): Always print something.
+	(default_gcc_start): Comment out call to `which'.
+	* config/*.exp: Major cleanup - make cross targets work at least a
+	little better for g++ (by not being "--tool gcc" specific).
+	Rename gcc_xxx to ${tool}_xxx.
+	* g++.old-deja/old-deja.exp: utils.exp is loaded by runtest.exp.
+	* lib/old-dejagnu.exp: ${tool}.exp is loaded by config file.
+
+Thu Sep 22 11:39:17 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/c-torture.exp (c-torture-compile): Rework compiler
+	message processing.
+
+	* gcc.c-torture/compile/initbug1.{c,exp}: Deleted, not part of
+	c-torture.
+
+Wed Sep 21 09:49:43 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* gcc.wendy/wendy.dis: Renamed from wendy.exp to disable the testsuite.
+
+	* lib/dg.exp (dg-process-target): Support { target native }.
+
+Tue Sep 20 17:16:55 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/dg.exp (dg-test): Clean up some comments.  Delete code that
+	looked for "... program xxx got fatal signal".
+	Correct regsub munging of `comp_output'.
+	Ignore compiler messages "path prefix not used" and "linker input
+	file unused".
+
+Wed Sep 14 11:44:40 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp (runtest_file_p): Define if missing.
+	* gcc.prms/template.c: Example to work from.
+
+Tue Sep 13 10:30:48 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp (gcc_finish): Delete code to update `testcnt'.
+	* lib/dg.exp (dg-test): Call unsupported testcases as such.
+
+	* gcc.prms/{3324.c,3565.c}: Moved from compile/940713-[12].c.
+	* gcc.prms/1883.c: Moved from compile/940714-1.c.
+	* gcc.prms/{5012.c,4453.c,4723.c,2541.c}: Moved from
+	execute/{940712-1.c,940712-2.c,940713-1.c,940714-1,c}.
+
+	* lib/dg.exp (user option docs): Clean up docs on target/xfail option.
+	(dg-process-target): No longer a varargs proc.
+	Return S/N for target, P/F for xfail.  All callers changed.
+	(user option procs): More argument checking.
+	(dg-do): `dg-do-what' now contains 3 elements {what flag P/F}.
+	(dg-output): `dg-output-text' now contains 2 elements {P/F text}.
+	(dg-test): Skip test if not running on selected target in `dg-do'.
+	Update handling of `dg-do-what', `dg-output-text'.
+	Separate execution pass/fail from output pattern match pass/fail.
+	Delete BUILD/XBUILD support (duplicate of LOSE/XLOSE).
+
+Mon Sep 12 13:47:35 1994  Jim Wilson  (wilson@sphagnum.cygnus.com)
+
+	* gcc.c-torture/special/special.exp: Don't expect failure for mips
+	target for 920510-1.c.
+
+Mon Sep 12 12:44:39 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp (gcc_init): Move initialized message to verbose level 3.
+	Clean up comment regarding use of passcnt, etc.
+	(gcc_stat): Don't update `testcnt' here.
+	(gcc_finish): Do it here.
+	Might as well reset `but_id' here too.
+	* gcc.c-torture/code_quality/code_quality.exp: Call `runtest_file_p'
+	to determine if the file should be tested.
+	* gcc.c-torture/compile/compile.exp: Likewise.
+	* gcc.c-torture/execute/execute.exp: Likewise.
+	* gcc.c-torture/unsorted/unsorted.exp: Likewise.
+	* gcc.misc-tests/dg-test.exp: Likewise.
+	* gcc.prms/prms.exp: Likewise.
+	* gcc.wendy/wendy.exp: Likewise.
+	* g++.old-deja.exp: Likewise.
+	Move "Testing file" message to verbose level 1.
+
+Fri Sep  9 10:21:18 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* gcc.wendy/t.c: Add DEJAGNU_CFLAGS:"-DNOPAUSE".
+
+Thu Sep  8 16:52:43 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp: Ensure CFLAGS, LIBS, and LDFLAGS are set.
+	(default_gcc_start): Accept optional second list element
+	of compiler flags.  Print compiler output at verbosity level 2.
+	Remove setting of CFLAGS, LIBS, LDFLAGS from here.
+	(gcc_init): Delete globals lcnt, lpass, lfail, lxpass, lxfail.
+	Save current values of framework globals passcnt, failcnt, xpasscnt,
+	and xfailcnt in gcc_passcnt, gcc_failcnt, gcc_xpasscnt, and
+	gcc_xfailcnt.  Set global `tmpdir' to /tmp if it doesn't exist.
+	(gcc_stat): Use framework globals passcnt, failcnt, xpasscnt, and
+	xfailcnt to compute stats.  Update framework global `testcnt' from
+	pass/fail counts.
+	(gcc_finish): New proc.  Clean up test environment.
+	(gcc_cpass, gcc_cfail): Rename to gcc_pass/gcc_fail.
+	(gcc_epass, gcc_efail): Delete.
+	* lib/dg.exp (dg-error, dg-warning, dg-bogus): Accept optional 5th
+	argument of line number.
+	(dg-init): If the tool has an init routine, call it.
+	(dg-test): Remove args `cflags_var' and `libs_var'.
+	Pass all compiler options to ${tool}_start.
+	Handle missing line number.
+	(dg-finish): New function.
+	* gcc.c-torture/code_quality/code_quality.exp: Add support for testing
+	particular files.  Call gcc_finish at end.  Move "skipping test"
+	message to verbosity level 3.
+	* gcc.c-torture/compile/compile.exp: Likewise.
+	* gcc.c-torture/unsorted/unsorted.exp: Likewise.
+	* gcc.c-torture/execute/execute.exp: Likewise.
+	Delete setting of prms_id, bug_id, lcnt, lfail, lpass.
+	Print testcase being tried at verbosity level 1.
+	* gcc.c-torture/special/special.exp: Unset xfail.
+	Delete setting of prms_id, bug_id, lcnt, lfail, lpass.
+	* gcc.c-torture/compile/initbug1.exp: Call gcc_finish.
+	* gcc.c-torture/noncompile/noncompile.exp: Likewise.
+	* gcc.failure/failure.exp: Likewise.
+	* gcc.ieee/ieee.exp: Likewise.
+	* gcc.misc-tests/dg-test.exp: Delete LDFLAGS.
+	Update call to dg-test.  Call dg-finish at end.
+	* gcc.misc-tests/mg.exp: Call gcc_finish at end.  Unset orig_flags.
+	Delete setting of prms_id, bug_id, lcnt, lfail, lpass.
+	* gcc.misc-tests/misc.exp: Call gcc_finish at end.
+	* gcc.prms/prms.exp: Delete loading of utils.exp (redundant).
+	Delete LDFLAGS.  Update call to dg-test.  Call dg-finish at end.
+	* gcc.wendy/wendy.exp: Add copyright.
+	Delete setting of tmpdir (done by gcc_init).
+	Call gcc_pass/gcc_fail instead of gcc_[ce]pass/fail.
+	Pass compiler flags to gcc_start.  Call gcc_finish at end.
+	* lib/c-torture.exp: Call gcc_pass/gcc_fail instead of
+	gcc_[ce]pass/fail.
+
+Wed Sep  7 11:09:08 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/g++.exp (g++_start): Rename arg to `prog' to avoid varargs
+	confusion.
+	(g++_load): Likewise.
+
+	* config/*.exp (gcc_load): Some were varargs fns and some were not.
+	Rename argument to `prog' to remove the confusion.
+	Varargs fns behave differently too!
+	(g++_load): Likewise.
+
+	* lib/dg.exp (dg-stat): Correct calculation of npass, nfail.
+
+	* config/unix.exp (gcc_load): Rename `args' to `prog' because that's
+	what it is.  Delete (always) printing of status value for !native.
+	Simplify verbose code, and include status and exec_output.
+	(g++_load): Use gcc_load.
+
+Sun Sep  4 13:59:27 1994  Jim Wilson  (wilson@sphagnum.cygnus.com)
+
+	* gcc.c-torture/noncompile/920928-1.c: Delete obsolete file.
+	* gcc.c-torture/noncompile/noncompile.exp: Delete support for
+	920928-1.c, 921017-1.c, 940712-1.c, 940714-1.c, 940714-2.c,
+	940714-3.c as these testcases don't exist anymore.  Make
+	va-arg-1.c expected to pass.
+
+Fri Aug 19 12:27:07 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* gcc.misc-tests/misc.exp: Only run specific testcases.
+	* gcc.misc-tests/dg-test.exp: New file.  Tests dg.exp.
+	* gcc.misc-tests/dg-[1-9].c: New files.
+
+	* lib/dg.exp: New testsuite driver.
+	* gcc.prms/prms.exp: Use it.
+
+	* README.gcc: New file.
+
+	* lib/gcc.exp (gcc_init): Delete srcdir, no longer referenced.
+	Document and reset `lxpass' and `lxfail'.
+	Simplify "initialized" message.
+	(gcc_stat): Clean up comments a little.
+
+Tue Aug 16 11:16:46 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* gcc.prms/prms.exp: New driver for gcc.prms testsuite directory.
+
+Mon Aug 15 21:20:36 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/old-dejagnu.exp (process-option): New proc.
+	(old-dejagnu-init, old-dejagnu-stat): Likewise.
+	(old-dejagnu): Simplify.
+	* g++.old-deja/old-deja.exp: Update to new version of old-dejagnu.
+
+Sun Aug 14 09:23:53 1994  Jeff Law  (law@snake.cs.utah.edu)
+
+	* lib/c-torture.exp (c-torture): Only call setup_xfail if $xfail
+	exists and is not an empty string.
+
+	* gcc.c-torture/special/special.exp (920520-1.c, 930510-1): Set
+	$xfail rather than calling setup_xfail.  Clear $xfail when test is
+	finished.
+	(920717-x.c): Add $srcdir/$subdir as "gcc_start" does not do it
+	automatically.
+
+	* gcc.c-torture/noncompile/noncompile.exp (940712-1 test): No
+	longer expected to fail.
+
+	* gcc.c-torture/execute/strct-pack-3.c: Add missing argument to 
+	"f" function call.
+
+	* gcc.misc-tests/mg.exp: Call gcc_stat when finished.
+
+	* gcc.c-torture/execute/{920202-1.c, 931208-1.c, 931228-1.c,
+	940115-1.c, 940122-1.c, bf-pack-1.c, bf64-1.c, comp-goto-1.c,
+	complex-2.c, packed-1.c, strct-pack-2.c	strct-pack-3.c,
+	struct-ini-2.c, struct-ini-3.c, va-arg-1.c}: Import from
+	c-torture-1.29.
+
+	* gcc.c-torture/execute/{nest-stdar-1.c, struct-ini-1.c,
+	strct-pack-1.c, strct-varg-1.c}: Renamed to match c-torture-1.29.
+
+	* gcc.c-torture/execute/920612-2.c: Update to c-torture-1.29.
+
+	* gcc.c-torture/noncompile/{931203-1.c, 940112-1.c, 940227-1.c,
+	940510-1.c, init-1.c, init-2.c}: Import from c-torture-1.29
+
+	* gcc.c-torture/compile/{920928-6.c, 931203-1.c, 940611-1.c,
+	940712-1.c, calls.c, combine-hang.c, goto-1.c, init-2.c,
+	labels-1.c, packed-1.c, zero-strct-1.c}: Import from c-torture-1.29.
+
+Tue Jul 12 12:49:44 1994  Jim Kingdon  (kingdon@lioth.cygnus.com)
+
+	* gcc.execute/{940712-1.c, 940712-2.c, 940713-1.c, 940714-1.c},
+	gcc.noncompile/{940712-1.h, 940712-1a.h, 940712-1b.h, 940712-1.c,
+	940714-1.c, 940714-2.c, 940714-3.c},
+	gcc.compile/{940713-1.c, 940713-2.c, 940714-1.c},
+	gcc.misc-tests/{mg.c,mg.exp}:
+	New tests.
+	* gcc.noncompile/noncompile.exp: Change accordingly.
+
+Thu Jul  7 14:20:33 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* config/sim.exp, lib/c-torture.exp, lib/gcc.exp:
+	Undo previous clobberage.
+
+Mon Jul  4 17:00:59 1994  Jeff Law  (law@snake.cs.utah.edu)
+
+	* gcc.compile/{931102-1.c, 931102-2.c, 931031-1.c}:
+	* gcc.special/{930510-1.c, special.exp}:
+	* gcc.execute/{931031-1.c, 931110-1.c, 931110-2.c, 931102-1.c,
+	931102-2.c, struct-pack-1.c, divmod-1.c, complex-1.c,
+	struct-varargs-1.c}: New tests from c-torture-1.26.
+
+Tue Jun 28 17:39:42 1994  J.T. Conklin  (jtc@phishhead.cygnus.com)
+
+	* gcc.wendy/wendy.exp: add --'s so that -1 isn't parsed as an
+	  argument to switch.
+
+Sat May 21 10:39:38 1994  Bill Cox  (bill@rtl.cygnus.com)
+
+	* Revert the previous changes.  Please see Rob's directory
+	  (/lisa/test/rob/progressive/gcc/testsuite) for testing
+	  fixes.
+
+Thu May 19 18:00:03 1994  Bill Cox  (bill@rtl.cygnus.com)
+
+	* config/sim.exp, config/udi.exp, config/unix.exp, config/vx.exp, 
+          g++.brendan/alignof.exp, g++.brendan/arm3.exp, g++.brendan/code-gen5.exp,
+          g++.brendan/crash29.exp, g++.brendan/crash5.exp, g++.brendan/cvt3.exp,
+          g++.brendan/delete1.exp, g++.brendan/nest12.exp, g++.brendan/nest13.exp,
+          g++.brendan/overload3.exp, g++.brendan/redecl1.exp, g++.brendan/visibility2.exp,
+          g++.jason/cond.exp, g++.jason/hmc1.exp, g++.jason/report.exp,
+          g++.law/access1.exp, g++.law/access2.exp, g++.law/arg6.exp, 
+          g++.law/arg7.exp, g++.law/arg8.exp, g++.law/arm1.exp, 
+          g++.law/arm10.exp, g++.law/arm4.exp, g++.law/arm5.exp,
+          g++.law/ctors15.exp, g++.law/ctors19.exp, g++.law/cvt1.exp,
+          g++.law/cvt12.exp, g++.law/cvt13.exp, g++.law/cvt18.exp, 
+          g++.law/cvt22.exp, g++.law/cvt3.exp, g++.law/cvt5.exp, 
+          g++.law/cvt6.exp, g++.law/cvt8.exp, g++.law/dtors3.exp, 
+          g++.law/except1.exp, g++.law/except3.exp, g++.law/except4.exp,
+          g++.law/except5.exp, g++.law/except6.exp, g++.law/init5.exp, 
+          g++.law/init8.exp, g++.law/inline4.exp, g++.law/memoized1.exp,
+          g++.law/missing1.exp, g++.law/operators14.exp, g++.law/operators18.exp,
+          g++.law/operators9.exp, g++.law/scope2.exp, g++.law/temps2.exp,
+          g++.law/temps3.exp, g++.law/temps5.exp, g++.law/typeck2.exp, 
+          g++.mike/misc4.exp, g++.mike/misc6.exp, g++.niklas/t118.exp,
+          g++.niklas/t128.exp, g++.niklas/t138.exp, g++.niklas/t139.exp,
+          g++.niklas/t140.exp, g++.niklas/t141.exp, gcc.code_quality/code_quality.exp,
+          gcc.compile/compile.exp, gcc.dje/dje.exp, gcc.execute/execute.exp, 
+          gcc.failure/failure.exp, gcc.ieee/ieee.exp, gcc.noncompile/noncompile.exp,
+          gcc.special/special.exp, gcc.unsorted/unsorted.exp, lib/c-torture.exp,
+          lib/chill.exp, lib/g++.exp, lib/gcc.exp, lib/mike-g++.exp, lib/mike-gcc.exp,
+          lib/old-dejagnu.exp: Checkin Rob's 94Q1 testing changes.
+
+Tue May 17 14:55:09 1994  Bill Cox  (bill@rtl.cygnus.com)
+
+	* config/udi.exp, gcc.execute/execute.exp, gcc.wendy/wendy.exp,
+          lib/g++.exp, lib/old-dejagnu.exp: Replace error proc calls
+	  with perror calls.
+
+Mon May  2 17:41:13 1994  Jason Merrill  (jason@deneb.cygnus.com)
+
+	* config/unix.exp (g++_load): Fix syntax.
+
+Thu Apr 14 12:22:10 1994  Jim Wilson  (wilson@sphagnum.cygnus.com)
+
+	* gcc.compile/initbug1.exp (CFLAGS): Add space at beginning.
+	* gcc.noncompile/921017-1.c: Deleted obsolete test.
+	* gcc.noncompile/noncompile.exp: Remove code for deleted test.
+	Don't expect va-arg-1.c to fail.  Correct expected output for
+	920928-1.c.
+	* gcc.wendy/d.c, msgs.c, prolog.c, subs.c, z.c: Deleted.
+	* gcc.wendy/hbm4.c: Correct typo.
+	* gcc.wendy/tad1.c, tad2.c: Correct expected output.
+
+Mon Mar 28 13:29:37 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp (gcc_[ce]{pass,fail}): Remove output/executable argument.
+	* gcc.wendy/wendy.exp (wendy_try): Remove `output' argument of
+	gcc_[ce]{pass,fail}.  Explicitly remove executable if test passes.
+	* lib/c-torture.exp (c-torture-compile): Ditto.
+
+	Reduce volume of output (remove all the -I's and such).
+	* lib/c-torture.exp (c-torture-compile): New argument OPTION.
+	Call gcc_cpass, gcc_cfail.
+	(c-torture): Pass testing option to c-torture-compile.
+
+Mon Mar 21 12:40:33 1994  Doug Evans  (dje@cygnus.com)
+
+	Bring patches over from progressive.
+	* config/default.exp: Exit remote shell cleanly.
+	(g++_exit, g++_start): Add default versions.
+	* config/sim.exp (gcc_load): Use perror, not error.
+
+Sun Mar 20 12:05:32 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* lib/gcc.exp: Don't set CFLAGS if CC not set.  It clobbers the	value
+	set in site.exp.
+
+Mon Mar 14 19:30:28 1994  Doug Evans  (dje@cygnus.com)
+
+	* gcc.wendy/wendy.exp (wendy_first_line): New proc to fetch
+	DEJAGNU_OUTPUT and DEJAGNU_CFLAGS.
+	(wendy_try): New proc to run testcase.
+	(main loop): Call 'em.
+	* gcc.wendy/*.c: Clean up pass to correct expected output.
+
+	* lib/gcc.exp: Minor cleanup work.
+	(gcc_cpass, gcc_cfail, gcc_epass, gcc_efail): New procs.
+
+Wed Mar  9 15:22:54 1994  Doug Evans  (dje@canuck.cygnus.com)
+
+	* config/sim.exp (gcc_load): Document return codes better.
+	Don't pass -v to simulator.
+
+Thu Feb 24 07:15:18 1994  Jeffrey A. Law  (law@snake.cs.utah.edu)
+
+        * gcc.special/920717-x.c: Fix typo.
+        * gcc.special/special.exp (920717-x.c): Use $srcdir/$subdir to
+        get at sources.
+
+	* lib/mike-gcc.exp: Fix typo.
+
+Tue Feb 15 15:41:47 1994  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* lib/gcc.exp: Minor cleanup work. Find the proper gcc or g++
+	binary to use, transform the name.
+	* config/*.exp: rename everything. Nuke any g++ specific files,
+	it's now a special case of gcc that requires no special support.
+	Add a default.exp for unsupported targets.
+
+Fri Feb 11 12:59:54 1994  Rob Savoye  (rob@poseidon.cygnus.com)
+
+	* g++.jason/report.exp, g++.old-deja/old-deja.exp,
+	lib/old-dejagnu.exp: Fix a few patterns to work with the new
+	version of Tcl.
+
+Wed Feb  9 21:35:47 1994  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* lib/c-torture.exp: Made "file prefix*never used a pass, rather
+	than a warning.
+
+Sun Feb  6 16:52:13 1994  Jeffrey A. Law  (law@snake.cs.utah.edu)
+
+	* lib/mike-gcc.exp: Add in recent changes from mike-g++.exp.
+
+Mon Jan  3 17:28:25 1994  Jim Wilson  (wilson@sphagnum.cygnus.com)
+
+	* gcc.execute/execute.exp: Combine opt_list and foption_list into
+	option_list.  Compile every file with only 4/6 option choices
+	(same as C torture) instead of with 12/18 different option
+	choices.
+	* lib/c-torture.exp: Likewise.
+
+	* lib/gcc.exp: Set LIBS, CFLAGS, and LDFLAGS to empty strings if
+	not already set.
+
+Thu Dec 30 17:17:07 1993  Mike Stump  (mrs@rtl.cygnus.com)
+
+	* lib/old-deja.exp: Add `excess errors test fails' error, now one
+	can put an XFAIL *-*-* on excess errors.
+
+Sun Dec 19 21:45:34 1993  Jeffrey A. Law  (law@snake.cs.utah.edu
+
+	* g++.law: Add more tests derived from g++-bugs snapshots.
+
+	* g++.law/init11.{c,exp}: Delete test.  Brendan sez it's 
+	equivalent to g++.law/init9.
+
+	* lib/mike-gcc.exp (postbase): Delete the .o file after we've
+	compiled it, and the a.out file after we've run it.
+
+Fri Dec 17 11:29:56 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* lib/mike-g++.exp (postbase): Delete the .o file after we've
+	compiled it, and the a.out file after we've run it.
+
+Fri Dec 17 10:18:16 1993  Jeffrey A. Law  (law@snake.cs.utah.edu)
+
+	* g++.law/*.exp: Avoid losing arguments added via "append" commands.
+
+Wed Dec 15 20:36:40 1993  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* lib/gcc.exp, lib/g++.exp: Use catch rather than exec to get the
+	version number. 
+
+Sun Dec 12 21:10:04 1993  Jeffrey A. Law  (law@snake.cs.utah.edu)
+
+	* g++.law: New directory of g++ tests derived from the g++-bugs
+	snapshots.
+
+Thu Dec 09 16:50:41 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* gcc.compile: initbug1.c initbug1.exp testcase added
+
+Mon Dec 06 11:09:52 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* gcc.dje/sizetype-1.exp, dje.exp: minor clean ups
+	* gcc.execute/execute.exp: minor cleanups. added gcc_stat calls. added
+	  fixes submitted by Jeff Law (law@cs.utah.edu)
+	* gcc.noncompile/noncompile.exp, lib/mike-gcc.exp: new files from
+	  Jeff Law (law@cs.utah.edu)
+
+
+Tue Nov 30 16:34:07 1993  Mike Stump  (mrs@cygnus.com)
+
+	* config/unix-g++.exp: Follow the gcc way of doing things.
+	* g++.old-deja/old-deja.exp: Minor updates.
+	* lib/g++.exp: New file, follow the gcc way of doing things.
+	* lib/old-dejagnu.exp: Minor updates.
+	* lib/mike-g++.exp: Always unset errorInfo.
+
+Sat Nov  6 11:34:51 1993  Mike Stump  (mrs@cygnus.com)
+
+	* lib/gcc.exp: Fix some errors with the below change, CC and
+	CFLAGS should be global when setting, not local.
+
+Wed Nov  3 11:16:26 1993  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* lib/gcc.exp: Transform tool name.
+
+Wed Oct 27 23:57:29 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* gcc.*/*.exp: Fixd some de-stablizing changes. Sorry.
+
+Wed Oct 27 14:45:50 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* lib/gcc.exp: change gcc_done to gcc_stat
+
+Wed Oct 27 09:57:51 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* Upgraded gcc testsuite to c-torture version 1.25
+
+Sun Oct 24 10:58:03 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* lib/gcc.exp: added reporting code. Changed verbose compile message.
+	* lib/c-torture: added hooks for new reporting code.
+
+Thu Oct 21 18:45:32 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* config/sh-gcc.exp: check if sh-sim exists in the path
+
+Mon Oct 18 11:13:22 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* gcc.code_quality/code_quality.exp: Initial changes for new logic.
+	* gcc.compile/compile.exp: Initial changes for new logic.
+	* gcc.dje/dje.exp, sizetype-1.exp: Initial changes for new logic.
+	* gcc.failure/failure.exp: Initial changes for new logic.
+	* gcc.ieee/ieee.exp: Initial changes for new logic.
+	* gcc.misc-tests/misc.exp: Initial changes for new logic.
+	* gcc.noncompile/non_compile.exp: Initial changes for new logic.
+	* gcc.unsorted/unsorted.exp: Initial changes for new logic.
+	* lib/c-torture.exp: Initial changes for new logic.
+	* lib/gcc.exp: Initial changes for new logic.
+
+Fri Oct 15 00:19:42 1993  Mike Stump  (mrs@cygnus.com)
+
+	* lib/mike-g++.exp, lib/old-dejagnu.exp: Make the message not
+	depend upon failure or success.  Fully qualify names in failure
+	and success messages.  Always remove a.out before starting
+	compile, just in case.  Pay more attention to error text output by
+	the compiler.  Handle testcases with no known past errors just
+	like all others, so that things are uniform.  Other miscellaneous
+	improvements.
+
+Wed Oct 13 15:04:51 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* gcc.cpp: new directory for cpp tests
+
+Mon Oct  4 09:03:41 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* lib/chill.exp: Code reformatted, removed unused code.
+	* config/unix-chill.exp: Code reformatted, removed unused code.
+	* chill.execute/execute.exp: Code reformatted, removed unused code.
+	* chill.execute/oe/orient.exp: Code reformatted, removed unused code.
+
+Mon Oct  4 06:19:26 1993  Ian Lance Taylor  (ian@cygnus.com)
+
+	* config/mips-gcc.exp, config/mips-g++.exp: New files.  Execution
+	routines not written.
+
+Mon Sep 27 21:07:44 1993  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* config/bug-gcc.exp: Use new procs from bug.exp.
+
+Tue Sep 21 18:21:12 1993  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* config/vx-gcc.exp: Use new vxworks_ld proc, so files get loaded
+	via ftp, rather than depending on NFS.
+	* config/vx-gcc.exp: Use new vxworks_spawn proc to execute test
+	case.
+
+Thu Sep  9 23:09:15 1993  Rob Savoye  (rob@darkstar.cygnus.com)
+
+	* config/bug-gcc.exp: Use new download proc.
+
+Tue Sep 14 19:23:58 1993  Jeffrey Wheat  (cassidy at deneb.cygnus.com)
+
+	* chill.execute/execute.exp: cleanups, handles errors better
+	* chill.compile/compile.exp: rewrite, based on execute.exp
+	* chill.noncompile/noncompile.exp: rewrite, based on execute.exp
+	* lib/chill.exp: major changes to diff proc and compile and link
+	  procs. added chill_fail and chill_pass wrappers to pass and
+	  fail. added more comments, and handle error codes better. 
+	  Added a hack to capture stderr from exec, so noncompile tests
+	  can work.
+	  
+Sat Sep 11 15:30:10 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* chill.execute/execute.exp: rewrite of testsuite driver
+	* lib/chill.exp: rewrite of testsuite driver
+	* config/unix-chill.exp: rewrite of testsuite driver
+
+Wed Aug 25 14:11:13 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+    In chill.execute:
+	* iexpr.ch: Standardize uppercase.
+	* tuples.dat: Standardize uppercase.
+	* vary.ch: standardize.  Correct varying string assignments.
+	* vary.dat: Add new output lines.
+
+Tue Aug 24 13:45:49 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+    In chill.execute:
+	* chprintf.ch: Standardize use of uppercase.
+	* tuples.ch: Standardize and turn arr2 into a DCL,
+	  rather than a SYN.
+	* pinits.ch: Standardize.
+
+Mon Aug 23 17:26:58 1993  Per Bothner  (bothner@kalessin.cygnus.com)
+
+	* rts.c:  Get malloc() from <stdlib.h>, not <malloc.h>.
+	* Makefil: Renamed to Makefile.in.
+	* configure.in: New.
+
+Mon Aug 23 14:24:13 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+    In chill.execute:
+	* .cvsignore: Add result/output files.
+	* Makefile: Fix up variables at start.  Use MFLAGS
+	  everywhere.  Correct bool_loc, built_ins entries.
+	  Add entry for vary1.ch.
+	* bitarray.ch: Standardize upper-case usage.
+	* bitexpr.ch: Standardize, add output of b1.
+	* params.ch: Use arrayt in along PROC parameters, to
+	  avoid novelty problems.
+	* sets.ch: Tiny cleanup.
+	* vary1.ch: Re-indent.
+
+Tue Aug 17 15:42:07 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+        * Add PR-related files to Makefiles, .cvsignore files, etc.
+
+Mon Aug  2 15:46:05 PDT 1993  Jeff Wheat  (cassidy@cygnus.com)
+
+	* gcc.unsorted: flow.c and loop.c - renamed to avoid conflicts
+	  with compiler objects. New names are test-flow.c and test-loop.c
+
+Tue Jul 27 10:08:08 PDT 1993  Jeff Wheat  (cassidy@cygnus.com)
+
+	* Upgraded c-torture tests from 1.19 to 1.20
+
+	* new files:
+	* gcc.compile: 930609-1.c 930611-1.c 930618-1.c 930621-1.c 
+	* gcc.compile: 930623-1.c 930623-2.c 
+	* gcc.noncompile: 930622-1.c 930622-2.c
+	* gcc.failure: 920411-1.c 920627-2.c
+	* gcc.ieee: 920518-1.c 920810-1.c 930529-1.c
+
+Tue Jul 20 15:19:44 PDT 1993  Jeff Wheat  (cassidy@cygnus.com)
+
+	* chill.compile/compile.exp chill.execute/execute.exp lib/chill.exp
+	  More changes to get testsuite working properly. Needs more work.
+	  Added some support for POSIX IEEE Std 1003.3-1991 error messages.
+
+Mon Jul 19 18:40:31 PDT 1993  Jeff Wheat  (cassidy@cygnus.com)
+
+	* chill.compile/compile.exp chill.execute/execute.exp lib/chill.exp
+	  More changes to get testsuite working properly. Needs more work.
+
+Tue Jul 13 18:38:56 PDT 1993 Jeff Wheat  (cassidy@cygnus.com)
+
+	* chill.compile/compile.exp: Added for Dejagnu support
+	* chill.execute/execute.exp: Added for Dejagnu support
+	* lib/chill.exp config/unix-chill.exp  : Added for Dejagnu support
+
+Sat Jun 19 07:13:05 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+    This should complete moving the CHILL test files.
+	* chill.noncompile(.cvsignore printf.grt 
+          in-printf.grt chprintf.grt chprintf.ch):
+          Added test-support files.
+	  (Makefile): Modified further.
+	* chill.compile (emptymod.ch gdbme.ch neg_range.ch
+          signal.ch): Added test files.
+        * chill.execute (.cvsignore printf.grt printr.c
+          in-printf.grt rts.c chprintf.grt rts.h): Added
+	  test-support files.
+          (Makefile): More corrections.
+
+Fri Jun 18 23:40:54 1993  Bill Cox  (bill@rtl.cygnus.com)
+
+	* chill.compile, chill.execute, chill.nocompile: Add CHILL
+	  test cases, ready for DejaGnu.
+
+Thu Jun 17 19:14:40 MDT 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* Upgraded c-torture tests from 1.18 to 1.19
+
+	* gcc.compile: added test(s):
+	  930607-1.c
+	* gcc.execute: added test(s):
+	  930603-1.c 930603-2.c 930603-3.c 930608-1.c conversion.c inst-check.c
+
+	* added new subdirectory for misc tests: gcc.misc-tests
+	* gcc.misc-test(s): added tests:
+	  inst-check.c test-consts.c test-ior.c test-switch.c
+
+Wed Jun  9 16:53:26 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+
+	* lib/mike-g++.exp: Load `./a.out', not `a.out'.
+
+Mon Jun  7 16:18:40 1993  Ian Lance Taylor  (ian@cygnus.com)
+
+	* g++.old-deja/old-deja.exp: Don't delete all the .o files.
+
+Thu Jun  3 13:13:36 MDT 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* Upgraded c-torture tests from 1.17 to 1.18
+
+Wed Jun  2 19:02:40 MDT 1993  Jeffrey Wheat  (cassidy@cygnus.com)
+
+	* Upgraded c-torture tests from 1.12 to 1.17
+
+Fri Apr 30 09:38:41 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib/old-dejagnu.exp:
+	  Fixed handling of XFAIL target triplets to correctly
+	  recognize wildcard characters.  Removed code that
+	  appended a unique id tag to the end of the file name
+	  printed out by the result of the testcases within a
+	  given test file.
+
+Thu Apr 29 19:06:29 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib/old-dejagnu.exp:
+	  Reworked expected failure handling to trigger off of XFAIL
+	  keyword in keyphrase embeded in testcase source code. The
+	  XFAIL keyword must be at the end of the keyphrase line. It
+	  may optionally be followed by one or more target triplets.
+	  It has just occured that the handling of wildcards in the
+	  target triplet may not be correct.
+
+Fri Apr 23 13:16:20 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* g++.old-deja/tests:
+	  Moved all subdirectories up one level into g++.old-deja .
+
+	* lib/old-dejagnu.exp:
+	  Fixed problem with CXXFLAGS not being properly reset, and being
+	  corrupted with extraneous "-c" compiler option.  This was
+	  causing binaries to not be generated for test that needed them.
+	  Modified strings passed to "pass" and "fail" so that individual
+	  tests from the same test file would be distinguished by an
+	  identifier appended to the test file name in the summary logs;
+	  this corrected a problem with erroneous diff logs.  Added code
+	  to search testcases for expected fail and unexpected pass keywords.
+
+Tue Apr 20 18:27:58 1993  Rob Savoye  (rob at darkstar.cygnus.com)
+
+	* lib/c-torture.exp: Ignore "file path prefix*unused" message.
+
+Thu Apr 15 11:01:59 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* g++.old-deja/tests/g++.sun/g++.frag/1045608.C:
+	  Removed extraneous text from end of "Special g++ Options"
+	  keyphrase.
+
+	* lib/old-dejagnu.exp: Added pattern matching to look for new
+	  keywords, embedded in testcases comments, which will trigger
+	  calls to xpass and xfail.
+
+Wed Apr 14 14:28:01 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib/old-dejagnu.exp: Cleaned up pattern matching for keyphrase
+	  comments embedded in the testcases, especially the one looking for
+	  special compiler options, as well as the pattern matching for the
+	  compiler output again.
+
+Mon Apr 12 15:15:37 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib/old-dejagnu.exp: Do a proper check of the return value for
+	  execute tests. Fixed several problems with the pattern matching
+	  of the compiler output which gave erroneous test results.
+	  Changed several of the test result messages to be more descriptive.
+	* config/unix-g++.exp: Proc g++_load now actually works and
+	  executes the tests passed to it and returns a usable return
+	  value. 
+
+Sun Apr 11 17:22:37 1993  Rob Savoye  (rob at darkstar.cygnus.com)
+
+        * lib/gcc.exp: Exits gracefully if $CC is bogus.
+
+Fri Apr  9 09:41:59 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib/old-dejagnu.exp , g++.old-deja/old-deja.exp:
+	  Modified both files to properly execute the old style
+	  dejagnu tests. The previous versions of these files were
+	  experimental and did not function anything near correctly.
+
+Mon Apr  5 21:08:24 1993  Rob Savoye  (rob@cygnus.com)
+
+	* Removed all Makefile.in and configure.in files. No configuration
+	needed now.
+
+Fri Apr  2 12:15:17 1993  Mike Werner  (mtw@deneb.cygnus.com)
+
+	* lib: relocated old-dejagnu.exp from devo/dejagnu/lib
+
+Sun Mar 28 11:17:48 1993  Ken Raeburn  (raeburn@kr-pc.cygnus.com)
+
+	* gcc.compile/configure.in, gcc.unsorted/configure.in,
+	gcc.special/configure.in, gcc.noncompile/configure.in,
+	gcc.execute/configure.in, gcc.code_quality/configure.in,
+	g++.other/configure.in, g++.old-deja/configure.in,
+	g++.niklas/configure.in, g++.mike/configure.in: Remove extra quote
+	in srcname setting.
+
+Thu Mar 25 20:07:55 1993  Rob Savoye  (rob at darkstar.cygnus.com)
+
+	* lib/udi.exp:  Fixed mondfe and mondfe_download.
+	* config/udi-gcc.exp: Fixed misc bugs, works with expect 4.x.
+	* config/abug-gcc.exp: Fixed misc bugs, works with expect 4.x.
+
+Thu Mar 25 13:06:41 1993  Ian Lance Taylor  (ian@cygnus.com)
+
+	* config/udi-gdb.exp: Check $shell_id after connecting to target.
+	(gdb_exit): Don't remove *_soc files.
+
+Mon Mar 22 14:28:46 1993  Ian Lance Taylor  (ian@cygnus.com)
+
+	* lib/c-torture.exp: Don't look for main; instead always use -w
+	-c.  This is how the c-torture tests work.  Remove the object
+	file if the compilation succeeds.
+	* gcc.execute/execute.exp: Remove executable if test passes.
+	* gcc.noncompile/noncompile.exp: Every test is an expected
+	failure.
+	* gcc.special/special.exp: Added tests from c-torture 1.11,
+	corrected use of existing test.
+	* gcc.execute/920302-1.c, gcc.execute/920501-8.c,
+	gcc.execute/920625-1.c: Updated to c-torture 1.11.
+	* gcc.compile/921103-1.c, gcc.compile/921109-1.c,
+	gcc.compile/921109-2.c, gcc.compile/921109-3.c,
+	gcc.compile/921111-1.c, gcc.compile/921116-2.c,
+	gcc.compile/921118-1.c, gcc.compile/921126-1.c,
+	gcc.compile/921202-1.c, gcc.compile/921202-2.c,
+	gcc.compile/921203-1.c, gcc.compile/921203-2.c,
+	gcc.compile/921206-1.c, gcc.execute/921029-1.c,
+	gcc.execute/921104-1.c, gcc.execute/921110-1.c,
+	gcc.execute/921112-1.c, gcc.execute/921113-1.c,
+	gcc.execute/921117-1.c, gcc.execute/921123-1.c,
+	gcc.execute/921123-2.c, gcc.execute/921124-1.c,
+	gcc.execute/921202-1.c, gcc.execute/921202-2.c,
+	gcc.execute/921204-1.c, gcc.execute/921207-1.c,
+	gcc.execute/921208-1.c, gcc.execute/921208-2.c,
+	gcc.execute/921215-1.c, gcc.execute/921218-1.c,
+	gcc.execute/921218-2.c, gcc.noncompile/921102-1.c,
+	gcc.noncompile/921116-1.c, gcc.unsorted/x.c: Added from
+	c-torture 1.11.
+	* gcc.noncompile/921021-1.c, gcc.unsorted/x11bug.c: Removed to
+	correspond to c-torture	1.11.
+
+	* New file.
+
diff --git a/gcc/testsuite/README.g++ b/gcc/testsuite/README.g++
new file mode 100644
index 00000000000..833d5ed603b
--- /dev/null
+++ b/gcc/testsuite/README.g++
@@ -0,0 +1,64 @@
+This file needs a little updating, but is pretty close.  Here are some
+random last minute notes:
+
+make check and make check-g++ aren't in FSF's gcc yet, I am planning
+on getting this work into the tree some time...
+
+> and the command
+
+>       runtest --tool g++ --srcdir ./testsuite
+
+> doesn't work.  I got it to work by explicitly setting CXX and CXXFLAGS
+> on the command line, e.g.
+
+> runtest --tool g++ --srcdir ./testsuite CXX=g++ CXXFLAGS=""
+
+site.exp updated to have right CXXFLAGS and CXX, but not at the FSF yet.
+
+
+  This is a collection of tests for g++, the FSF's C++ compiler. The
+driver that runs the testsuite is called DejaGnu.  If you do not have
+DejaGnu yet, you will need to get it (ftp://ftp.cygnus.com/pub/dejagnu).
+You will need a snapshot of DejaGnu of 02/21/97 or later.  The tests
+were developed and/or collected by Cygnus Support. These tests are
+included "as is". If any of the tests fail, don't report a bug.  Bug
+reports for DejaGnu can go to bug-dejagnu@prep.ai.mit.edu.  Discussion
+and comments about this testsuite can be sent to me, at the address
+below.
+
+  Since these are part of the development source tree at Cygnus, this
+tar file is supposed to be untarred so that the testsuite directory is
+in the gcc source tree. Most of the time DejaGnu is run by hand using
+"runtest", but as we believe in solid testing, we've integrated it
+into the Makefile as a target. We normally use the testsuite by doing
+a "make all; make check-g++" at the top level and building and testing
+our whole tree.  If you have both the gcc testsuite and the g++
+testsuite, you can check both with the "make check" command.
+
+  DejaGnu can be run either installed, or uninstalled. Usually it gets
+installed so that anyone can just run the tests without having to
+configure or build DejaGnu.
+
+  To run the tests, first change to the gcc-2.7.1 directory, then type:
+
+	runtest --tool g++ --srcdir ./testsuite
+
+Here's a brief explanation.
+
+runtest         - Is the name used to invoke DejaGnu.   If DejaGnu is not
+		  install this will be the relative path name for runtest.
+
+--tool          - This tells DejaGnu which tool you are testing. It is
+                  mainly used to find the testsuite directories for a
+                  particular tool when several testsuites are in the
+                  same directory. (like the gcc and g++ testsuites)
+
+--srcdir        - This points to the top level of the directory
+                  containing the sources of the testsuite. This is
+                  ./testsuite if you are in the directory that has the
+                  testsuite directory.
+
+
+					Mike Stump
+					mrs@cygnus.com
+					FSF C++ developer
diff --git a/gcc/testsuite/README.gcc b/gcc/testsuite/README.gcc
new file mode 100644
index 00000000000..74285058595
--- /dev/null
+++ b/gcc/testsuite/README.gcc
@@ -0,0 +1,71 @@
+This file contains a list of notes for those writing testcases and those
+writing expect scripts.  At present, they're in random order.
+
+Verbosity Levels
+
+- each level adds verbosity so level 2 prints all level 1 and level 2 stuff.
+
+1) Print a one-liner indicating the testcase being run (and maybe special
+   compiler options).
+
+2) Print compiler and program invocation including arguments and their output.
+   Proc's gcc_load and gcc_start handle the latter two.
+
+3) Print detailed testcase analysis like "Looking for pattern ...", etc.
+
+4) Maximum verbosity.  Print anything else of interest.
+
+send_log conventions
+
+Various messages are stored in gcc.log by the testing framework and we
+try to augment them with some of our own.  The format of the framework
+messages are:
+
+PASS: blah blah ...
+FAIL: blah blah ...
+
+so we use
+
+XXXX: blah blah ...
+
+Current messages are:
+
+EXEC: program being executed (so compiler path and args are recorded)
+STAT: intermediate pass/fail statistics
+
+DO NOT PUT NON-PORTABLE TESTCASES IN gcc.c-torture.
+
+ANY TARGET SPECIFIC TESTCASE MUST HAVE APPROPRIATE CODE TO PREVENT IT FROM
+CAUSING A `FAILURE' ON UNSUPPORTED PLATFORMS.
+
+Test scripts must ignore the compiler messages "path prefix never used"
+and "linker input file unused".  Don't let their appearance cause a testcase
+to fail.  See lib/dg.exp for the exact regsub to use.
+
+If you're unclear about which directory a testcase should be installed in,
+ask gcc-local.
+
+Always use abort() for runtime failures, and exit(0) for success.
+The testing harness is set up to watch for these and do something appropriate
+(when necessary) for target boards.
+
+Have the text of a fail message be the same as that for pass.
+IE: have
+
+        if ...success...
+                pass "pr 1234"
+        else
+                fail "pr 1234"
+
+not
+
+        if ...success...
+                pass "pr 1234 passed"
+        else
+                fail "pr 1234 failed"
+
+
+This lets test-tool (which drives the nightly tests) do a better job
+at tracking which tests have digressed or been fixed.
+
+Add more notes here.
\ No newline at end of file
diff --git a/gcc/testsuite/config/default.exp b/gcc/testsuite/config/default.exp
new file mode 100644
index 00000000000..9ae55bc6a76
--- /dev/null
+++ b/gcc/testsuite/config/default.exp
@@ -0,0 +1,20 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+load_lib "standard.exp"
diff --git a/gcc/testsuite/g++.old-deja/Makefile.in b/gcc/testsuite/g++.old-deja/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/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/testsuite/g++.old-deja/configure.in b/gcc/testsuite/g++.old-deja/configure.in
new file mode 100644
index 00000000000..c6cacc6757d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/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=old-deja.exp
+srcname="DejaGnu"
+
+# per-host:
+
+# per-target:
+
+target_makefile_frag=../config/mt-${target_alias}
+
+# post-target:
diff --git a/gcc/testsuite/g++.old-deja/g++.benjamin/.cvsignore b/gcc/testsuite/g++.old-deja/g++.benjamin/.cvsignore
new file mode 100644
index 00000000000..7abff1dbead
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.benjamin/.cvsignore
@@ -0,0 +1,2 @@
+Makefile
+config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.benjamin/p12475.C b/gcc/testsuite/g++.old-deja/g++.benjamin/p12475.C
new file mode 100644
index 00000000000..fecbd576b79
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.benjamin/p12475.C
@@ -0,0 +1,5 @@
+// Build don't link:
+// prms-id: 12475
+
+enum huh { start =-2147483648, next };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/array1.C b/gcc/testsuite/g++.old-deja/g++.bob/array1.C
new file mode 100644
index 00000000000..2e86f6ff105
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/array1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+char *stuff() {
+   char array[10]; // WARNING - 
+
+   return array;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/array2.C b/gcc/testsuite/g++.old-deja/g++.bob/array2.C
new file mode 100644
index 00000000000..8ddeba8c83d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/array2.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+extern const int a[];
+extern const int a[];
+extern const int a[];
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/case1.C b/gcc/testsuite/g++.old-deja/g++.bob/case1.C
new file mode 100644
index 00000000000..a8e5f7b7621
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/case1.C
@@ -0,0 +1,13 @@
+// prms-id: 9028
+class Foo;
+
+int main()
+{
+  int i=0;
+  switch (i) 
+    {
+    case ((Foo *)0): // ERROR - 
+    case ((Foo *)1): // ERROR - 
+      break;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/cond1.C b/gcc/testsuite/g++.old-deja/g++.bob/cond1.C
new file mode 100644
index 00000000000..d6f1165061a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/cond1.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// prms-id: 9866
+class TChar 
+	{ 
+public: 
+	explicit inline TChar(unsigned int aChar); 
+	inline operator unsigned int() const; 
+private: 
+	unsigned int iChar; 
+   }; 
+inline TChar::TChar(unsigned int aChar) 
+	: iChar(aChar) 
+	{} 
+inline TChar::operator unsigned int() const 
+	{return(iChar);} 
+ 
+class TDes8 
+   { 
+public: 
+   inline const unsigned char &operator[](int anIndex) const; 
+	const unsigned char &AtC(int anIndex) const; 
+   }; 
+ 
+inline const unsigned char &TDes8::operator[](int anIndex) const 
+	{return(AtC(anIndex));} 
+ 
+ 
+void doExponent(TDes8 &aDigBuf) 
+            { 
+            2 ? TChar(aDigBuf[2]) : '0';
+            } 
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/delete1.C b/gcc/testsuite/g++.old-deja/g++.bob/delete1.C
new file mode 100644
index 00000000000..d4fc3210d67
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/delete1.C
@@ -0,0 +1,22 @@
+// prms-id: 7330
+#include <stddef.h>
+int size = 0; 
+
+struct X {
+    int x;
+    void *operator new[](size_t sz)   {
+         size = sz;
+         return 0;  
+    }
+    void operator delete[] (void *vp) { ::delete[] vp; }  
+};
+int main()
+{
+     X (*px) [10];
+
+     px = new X[5][10];
+
+     delete [] px;
+
+     return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/extern_C.C b/gcc/testsuite/g++.old-deja/g++.bob/extern_C.C
new file mode 100644
index 00000000000..6b91adc36e3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/extern_C.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+extern "C" {
+  class A {
+  public:
+    void a();
+  };
+};
+
+void A::a() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/friend1.C b/gcc/testsuite/g++.old-deja/g++.bob/friend1.C
new file mode 100644
index 00000000000..1782f08913a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/friend1.C
@@ -0,0 +1,4 @@
+class C {
+public:
+  static friend int f(); // ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/incomplete-cast1.C b/gcc/testsuite/g++.old-deja/g++.bob/incomplete-cast1.C
new file mode 100644
index 00000000000..fb08c63e9c3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/incomplete-cast1.C
@@ -0,0 +1,16 @@
+// prms-id: 5274
+class VHDLIdentifier;
+
+class VHDLPackageProtoRep {
+public:
+    int thing();
+private:
+    virtual VHDLIdentifier &actual_name() ;
+};
+extern void form(const char *format, ... );
+int
+VHDLPackageProtoRep::thing()
+{
+    form("package `%s'", (char *)actual_name()); // ERROR - can't convert from incomplete type
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/inherit1.C b/gcc/testsuite/g++.old-deja/g++.bob/inherit1.C
new file mode 100644
index 00000000000..4e77de34884
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/inherit1.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+class A {
+char str[10];
+public:
+    char* m1 () { return str;};
+};
+
+class C : public A {
+public:
+};
+
+class B : public A {
+public:
+    char* m1 () { C::m1(); return ""; } // ERROR - 
+};
+
+main () {
+A a;
+B b;
+C c;
+
+a.m1();
+c.m1();
+b.m1();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/inherit2.C b/gcc/testsuite/g++.old-deja/g++.bob/inherit2.C
new file mode 100644
index 00000000000..52d35b0462c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/inherit2.C
@@ -0,0 +1,22 @@
+// Build don't link:
+class A {
+public:
+  void z();
+  A(void) {}
+private:
+  A(const A &) { abort(); } // ERROR - 
+  const A& operator =(const A &) { abort(); }
+};
+
+class B : public A {
+public:
+  B(void) {}
+};
+
+void f(B b) {
+};
+
+void g() {
+  B h;
+  f(h); // ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/nested1.C b/gcc/testsuite/g++.old-deja/g++.bob/nested1.C
new file mode 100644
index 00000000000..b5b7a762e0f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/nested1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+  class A {
+    class B {
+      typedef long T;
+      int i;
+    };
+  };
+  class C {
+    class B {
+      typedef float T;
+      int i;
+    };
+  };
+
+C::B::T a;
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/packed1.C b/gcc/testsuite/g++.old-deja/g++.bob/packed1.C
new file mode 100644
index 00000000000..27ae03e4a05
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/packed1.C
@@ -0,0 +1,16 @@
+main() {
+  struct s
+    {
+      int a;
+      short b;
+    } __attribute__((packed)) t;
+
+  if (sizeof (t) != (sizeof(int)+sizeof(short))) 
+    {
+      return 1;
+    }
+  else 
+    {
+      return 0;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/protected1.C b/gcc/testsuite/g++.old-deja/g++.bob/protected1.C
new file mode 100644
index 00000000000..e83f3e40b73
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/protected1.C
@@ -0,0 +1,41 @@
+// Build don't link: 
+class A {
+public:
+  int i;
+  A(int j) : i(j){}
+};
+
+class B : protected A {
+public:
+  B(int j) : A(j){}
+  void f(){
+    A k(*this);
+  }
+};
+
+class C : protected B {
+public:
+  C(int j) : B(j){}
+  void f();
+
+  void g(){
+    A k(i); 
+  }
+};
+
+
+class D : public C {
+public:
+   D(int w) : C(i) {}
+   void j() { A k(*this); }
+   void h() { i=3; }
+};
+
+void C::f() {
+   A k(*this);
+}
+
+B b(3);
+main() {
+ A *z = &b; // ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/static1.C b/gcc/testsuite/g++.old-deja/g++.bob/static1.C
new file mode 100644
index 00000000000..a8e6b88bd93
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/static1.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+class A {
+  public:
+    static int a;
+};
+
+class B : public A {
+  public:
+    static int b;
+};
+
+int B::a; // ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/template1.C b/gcc/testsuite/g++.old-deja/g++.bob/template1.C
new file mode 100644
index 00000000000..4a22f086130
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/template1.C
@@ -0,0 +1,27 @@
+// Build don't link:
+// prms-id: 10038
+template < class Referencee >
+class Referencer
+{
+public:
+    Referencer (Referencee const * pReferencee);
+};
+
+template <class T>
+class Array
+{
+public:
+    int addElement (T const & e);
+    int addElement ();
+};
+
+class ScenarioGroup;
+
+class ScenarioSet : public Array< Referencer<ScenarioGroup> >
+{
+    typedef Array< Referencer<ScenarioGroup> > arrayBase;
+    void addElement(ScenarioGroup *group)
+	{
+	    arrayBase::addElement(group);
+	}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/template2.C b/gcc/testsuite/g++.old-deja/g++.bob/template2.C
new file mode 100644
index 00000000000..5663da84be2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/template2.C
@@ -0,0 +1,49 @@
+// Build don't link:
+// prms-id: 10046
+template <class T>
+class Array
+{
+public:
+    T const & operator[] (int i) const;
+};
+
+class Referenceable {};
+
+template < class Referencee >
+class Referencer
+{
+public:
+    operator Referencee *() const { return i_referencee; }
+
+protected:
+    Referencee* i_referencee;
+};
+
+class ScenarioGroup {};
+
+class ScenarioSpace;
+
+class ScenarioSet : public Referenceable,
+		    public Array< Referencer<ScenarioGroup> >
+{
+public:
+    ScenarioSet& operator=(ScenarioSet const & s);
+};
+
+class ScenarioSpace : public Referenceable,
+		      public Array< Referencer<ScenarioSet> >
+{
+};
+
+class ScenarioSetNameSelector
+{
+public:
+    bool operator () (ScenarioSpace &space)
+    {
+	int idx;
+	i_set = space[idx];
+	return false;
+    }
+private:
+    ScenarioSet *i_set;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/template3.C b/gcc/testsuite/g++.old-deja/g++.bob/template3.C
new file mode 100644
index 00000000000..17378425a26
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/template3.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// prms-id: 9979
+
+template < class Referencee >
+class Referencer
+{
+public:
+    Referencer() {}
+};
+
+template <class T>
+class List
+{
+public:
+    List() {}
+};
+
+template<class T, class KEY>
+class Dictionary
+{
+public:
+    Dictionary() : i_buckets (new List<T>[1234]) {}
+    ~Dictionary() { delete [] i_buckets; }
+
+    List<T> *		i_buckets;
+};
+
+class Exchangeable {};
+class ExchangeableHandle {};
+
+class ExchangeableList
+    : public Dictionary<Referencer<Exchangeable>, ExchangeableHandle>
+{
+public:
+    ExchangeableList(int size=0);
+};
+
+class ObjectExchange
+{
+public:
+    ObjectExchange() {};
+
+    ExchangeableList	i_theWatchList; // Instruments being monitored
+};
+
+main()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bob/template4.C b/gcc/testsuite/g++.old-deja/g++.bob/template4.C
new file mode 100644
index 00000000000..8d86fa37ab6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bob/template4.C
@@ -0,0 +1,20 @@
+// prms-id: 10166
+
+template <class A>
+class B {
+  public:
+    int f() {
+      for(int x=0;x<10;x++) {
+        continue;
+        return 1;
+     }
+     return 0;
+   }
+  private:
+    A w;
+};
+
+main() {
+  B<int> c;
+  return c.f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/README b/gcc/testsuite/g++.old-deja/g++.brendan/README
new file mode 100644
index 00000000000..81119572caa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/README
@@ -0,0 +1,41 @@
+Note: nest4 misses a syntax error
+
+abstract	- abstract functions
+alignof		- gcc alignof builtin
+ambiguity	- diagnosing ambiguities
+arm		- ARM cases
+array-refs	- arrays of references
+bit-fields	- bit fields
+chainon		- deaths cuz we call chainon() incorrectly
+copy		- copy constructors
+crash		- old compiler crashes/aborts
+cvt		- user-defined conversions
+def-fns		- default function generation (in add'n to copy)
+enum-clash	- int vs enum
+enum		- enumerated types
+err-msg		- error messages
+friend		- dealing with friend functions and classes
+groff		- crashes derived from groff code
+init		- initialization bugs
+label		- handling labels
+line		- line numbers in error messages
+misc		- miscellaneous tests that didn't fit another category
+nest		- nested types
+new-array	- doing new of an array
+new		- generic operator new bugs
+operators	- tests for various overloaded operators
+parse		- parser bugs
+prepost		- prefix/postfix operator ++/--
+ptolemy		- bugs derived from ptolemy
+recurse		- infinite recursion in the compiler
+redecl		- handling redeclarations
+scope		- managing scopes
+shadow		- shadowing of params, etc
+sizeof		- ARM compliance w/ sizeof operator
+sorry		- old "sorry, not implemented" messages
+static		- handling static data
+template	- template bugs
+union		- handling unions
+visibility	- access control and visibility checking
+warnings	- warning messages
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C b/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C
new file mode 100644
index 00000000000..b9cd9c5733b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/abstract1.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed abstract-functions
+class O
+{
+public:
+   virtual int c()=0;
+};
+
+class I: public O
+{
+};
+
+class S: public virtual I
+{
+public: 
+  int c();
+  virtual int v()=0;
+};
+
+class D: public S
+{
+   int v();
+};
+
+D *p=new D();
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/access1.C b/gcc/testsuite/g++.old-deja/g++.brendan/access1.C
new file mode 100644
index 00000000000..0272c7ae1a9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/access1.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed access-control
+class Base
+{
+protected:
+  virtual void DoSomething() = 0;
+};
+
+class Fibber : public Base
+{
+public:
+  void DoBP() {
+    DoSomething();
+  }
+};
+
+class Flat : public virtual Fibber
+{
+public:
+  void DoIt() {
+    DoSomething();
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C b/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C
new file mode 100644
index 00000000000..1449aded826
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/alignof.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed extensions
+struct bar { int bit : 1; };
+
+void foo (int *r, bar t)
+{
+  // doing alignof on a bit-field should be illegal
+  __alignof__ (t.bit);// ERROR - .*
+
+  // both of these (a regular ref and an INDIRECT_REF) should work
+  __alignof__ (r);
+  __alignof__ (*r);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C
new file mode 100644
index 00000000000..c6d6fcbd4ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ambiguity1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed ambiguity
+struct A {
+  A (int);
+};
+
+struct B {
+  B (int);
+};
+
+void myfunc (const A& t0); // ERROR - 
+void myfunc (const B& t0); // ERROR - 
+
+int main ()
+{
+   myfunc(1);   // ERROR - ambiguous call
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C b/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C
new file mode 100644
index 00000000000..86b7ce3fabc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/anon-union1.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed anonymous-unions
+static union {
+        char*   uC;
+private:
+        int     uI;// ERROR - .*private member.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C
new file mode 100644
index 00000000000..74091f8cce5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm1.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed ARM-compliance
+// ARM $5.7, it's illegal to do math on a `void*'.
+
+main()
+{
+  void *p;
+  ++p;// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C
new file mode 100644
index 00000000000..62bdc3d2a39
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// ARM 9.4 ``There cannot be a static and a nonstatic member function
+//	     with the same name and the same argument types.''
+//
+// The trick is to make sure it's caught with both orders (static,
+// then normal, and vice-versa.
+
+class X {
+public:
+   int foo();
+  static int foo();	// error: redeclaration// ERROR - .*
+};
+
+class Y {
+public:
+   static int foo();
+  int foo();		// error: redeclaration// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C b/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C
new file mode 100644
index 00000000000..c352bfa57f0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/arm3.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed initialization
+// ARM $11.4: A function first declared in a friend decl is equivalent
+// to an extern decl, so the below is illegal.
+
+class X {
+      friend g(); // ERROR - previous declaration
+};
+static g() { return 1; }// ERROR - previously declared
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C b/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C
new file mode 100644
index 00000000000..0eaa45c7f1d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/array-refs.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed arm
+int a, b;
+
+// declaring an array of references should be illegal
+int & v[ 2] = { a, b};// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/array1.C b/gcc/testsuite/g++.old-deja/g++.brendan/array1.C
new file mode 100644
index 00000000000..64924639f6f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/array1.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -fconserve-space -fcommon
+// GROUPS passed array-bindings
+// excess errors test - XFAIL sparc64-*-* 
+extern "C" void printf (char *, ...);
+char array[(unsigned) 0x90000000];// ERROR -  overflow in array dimension.* , XFAIL sparc64-*-* alpha*-*-*
+int main () { printf ("PASS\n"); return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C b/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C
new file mode 100644
index 00000000000..a388a61d944
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/asm-extn1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// Special g++ Options: -S
+// GROUPS passed asm-extension
+// excess errors test - XFAIL a29k-*-*
+// This used to crash because c_expand_asm_keyword didn't know what to
+// do with this.  The parser rules were changed to accept an expr, instead
+// of a stmt.
+
+extern void traptable(void);
+
+main()
+{
+  asm("wr    %0,%%tbr" : : "r" (traptable));
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C
new file mode 100644
index 00000000000..76f4ac33ac2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+struct bar {
+  int : 2 = 1;// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C
new file mode 100644
index 00000000000..dae2726b89c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bit-fields2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+	struct {
+	    char c;
+	    int i:8;
+	} s;
+	
+	main()
+	{
+	    int &ir = s.i;
+	    int *ip = &s.i;// ERROR - .* , XFAIL *-*-*
+	    ir = 10;
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C b/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C
new file mode 100644
index 00000000000..bab925521ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/bool1.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed boolean
+main()
+{
+    typedef char Boolean; // Instrinsic.h
+    Boolean c = false;
+    bool b = true;
+
+    if (!c != !b)
+	;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C
new file mode 100644
index 00000000000..84dd634d9cf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen1.C
@@ -0,0 +1,40 @@
+// GROUPS passed code-generation
+// Check that sub-word sized structs/classes are passed correctly
+// if the struct/class has a constructor (i.e. ANY constructor).
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	unsigned int f1 : 8;
+	unsigned int f2 : 8;
+
+	base (int ii)
+	{
+	}
+};
+
+base global_base (7);
+
+int test2 (base formal_base);
+
+int main ()
+{
+	global_base.f1 = 0x55;
+	global_base.f2 = 0xee;
+
+	if (test2 (global_base) == 0)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+
+	return 0;
+}
+
+int test2 (base formal_base)
+{
+	if (formal_base.f1 != global_base.f1)
+		return -1;
+	if (formal_base.f2 != global_base.f2)
+		return -1;
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C
new file mode 100644
index 00000000000..133755e894d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen2.C
@@ -0,0 +1,18 @@
+// GROUPS passed code-generation
+// Check that declarations with initializations are executed
+// correctly.
+
+extern "C" void printf (char *, ...); 
+
+int main ()
+{
+	char buff[40] ;
+	char *tmp = &buff[0];	// also fails for char *tmp = buff;
+
+	if ((unsigned int) tmp != (unsigned int) &buff[0])
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C
new file mode 100644
index 00000000000..6d73bd2336e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen3.C
@@ -0,0 +1,34 @@
+// GROUPS passed code-generation
+// Check that passing things which are not a multiple of
+// 4 bytes in size doesn't mess up other subsequent parameters.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1 : 8;
+	int f2 : 8;
+};
+
+base global_base;
+
+int val1;
+
+int test2 (struct base formal_base, int v1);
+
+int main ()
+{
+	val1 = 0x5e5e;
+	return test2 (global_base, val1);
+}
+
+int test2 (struct base formal_base, int v1)
+{
+	formal_base.f1 = formal_base.f2;	// prevent warnings
+
+	if (v1 != 0x5e5e)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C
new file mode 100644
index 00000000000..e29b16a2b09
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen4.C
@@ -0,0 +1,31 @@
+// Special g++ Options: -O
+// GROUPS passed code-generation
+// Options: -O
+//
+// Check that when an int value is assigned to a short int, the proper
+// half of the int (i.e. the low order half) ends up in the short.
+//
+// This fails with 1.32.0 with -O and f1() is inline.
+//
+// Workaround - declare "f1_arg" as type "short int".
+
+extern "C" void printf (char *, ...); 
+
+short int v2;
+
+long v1 = 0x11117777;
+
+inline void f1 (long f1_arg)
+{
+	v2 = f1_arg;
+}
+
+int main ()
+{
+	f1 (v1);
+
+	if (v2 != 0x00007777)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C
new file mode 100644
index 00000000000..0d59b5685af
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen5.C
@@ -0,0 +1,57 @@
+// Special g++ Options: -fthis-is-variable
+// GROUPS passed code-generation
+// Check that the "this" pointer is zero when a method is
+// called for an object pointed to by a null pointer.
+
+// Normally, the "__builtin_new" operation which actually
+// allocates objects in heap space is *not* called at the
+// actual point of the "new" keyword.  Rather, a check is
+// made within each constructor and if the "this" pointer
+// value passed in is zero, then the actual allocation of
+// memory (via __builtin_new) is done at that point (i.e.
+// at the very beginning of the constructor).
+
+// A special trick allows one to subvert this mechanism.
+// Specifically, if a given constructor contains a statement
+// like: "this = this", then no attempt will be made to
+// implicitly call __builtin_new within that constructor.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int member;
+
+	base ();
+	void member_function ();
+};
+
+base *base_pointer_1 = 0;
+base *base_pointer_2 = 0;
+
+int errors = 0;
+
+int main ()
+{
+	//base_pointer_2 = new base();
+	base_pointer_1->member_function ();
+
+	if (errors)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+base::base ()
+{
+	this = this;
+	if ((int) this != 0)
+		errors++;
+}
+
+void base::member_function ()
+{
+	if ((int) this != 0)
+		errors++;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C
new file mode 100644
index 00000000000..ea5d730949d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/code-gen6.C
@@ -0,0 +1,54 @@
+// GROUPS passed code-generation
+// Check that type float parameters can be correctly passed to
+// methods.
+
+extern "C" void printf (char *, ...); 
+
+class tres_floats {
+	float ff1;
+	float ff2;
+	float ff3;
+public:
+	tres_floats (float f1, float f2, float f3);
+	float get_f1 ();
+	float get_f2 ();
+	float get_f3 ();
+};
+
+float v1 = 1.2345;
+float v2 = 3.14159;
+float v3 = 0.707;
+
+int main ()
+{
+	tres_floats tf (v1, v2, v3);
+
+	if ((tf.get_f1() != v1) || (tf.get_f2() != v2) || (tf.get_f3() != v3))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+tres_floats::tres_floats (float f1, float f2, float f3)
+{
+	ff1 = f1;
+	ff2 = f2;
+	ff3 = f3;
+}
+
+float tres_floats::get_f1 ()
+{
+	return ff1;
+}
+
+float tres_floats::get_f2 ()
+{
+	return ff2;
+}
+
+float tres_floats::get_f3 ()
+{
+	return ff3;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C
new file mode 100644
index 00000000000..38242fbb8be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy1.C
@@ -0,0 +1,21 @@
+// GROUPS passed copy-ctors
+extern "C" void printf (char *, ...);
+int count = 0;
+
+class C {
+public:
+  C (int) { count++; }
+  operator int () { return 0; }
+};
+
+
+main ()
+{
+  C c1 (1);
+  C c2 (c1);
+
+  if (count != 1)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C
new file mode 100644
index 00000000000..9f93755dae4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy2.C
@@ -0,0 +1,79 @@
+// GROUPS passed copy-ctors
+/*
+The old g++ output is
+
+Item()
+Compound()
+Pre foo
+foo
+~Compound()
+~Item()
+Post foo
+~Compound()
+~Item()
+
+The output should be something like (produced from ATT 2.1)
+
+Item()
+Compound()
+Pre foo
+Item(const Item& i)    <------ missing above
+foo
+~Compound()
+~Item()
+Post foo
+~Compound()
+~Item()
+
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+  
+
+class Item {
+ public:
+  Item() { die (1); }
+  Item(const Item& i) { die (4); }
+  ~Item() { count++; if (count != 7 && count != 10) die (-1); }
+};
+
+
+class Compound {
+  Item i;
+ public:
+  Compound() { die (2); }
+  ~Compound() { count++; if (count != 6 && count != 9) die (-1); }
+};
+
+
+void foo(Compound a)
+{
+  die (5);
+}
+
+
+main()
+{
+  Compound a;
+
+  die (3);
+  foo(a);
+
+  die (8);
+
+  printf ("PASS\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C
new file mode 100644
index 00000000000..28b3306433b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy3.C
@@ -0,0 +1,57 @@
+// GROUPS passed copy-ctors
+/*
+
+If I compile it with cfront (AT&T C++ Translator 2.00.02 08/25/89) and run it
+I get:
+
+	A::A()
+	A::A(const A&)
+	B::Bar()
+	A::~A()
+	A::~A()
+
+If I compile it with g++ (gcc version 2.2.2) and run it I get:
+
+	A::A()
+	B::Bar()
+	A::~A()
+	A::~A()
+
+*/
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+  
+
+class A {
+public:
+  A() { die (1); }
+  A(const A&) { die (2); }
+  ~A() { count++; if (count != 4 && count != 5) die (-1); }
+};
+
+class B : public A {
+public:
+  void Bar() { die (3); }
+};
+
+void Foo(B b) { b.Bar(); }
+
+main()
+{
+  B b;
+  Foo(b);
+
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C
new file mode 100644
index 00000000000..35b53932141
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy4.C
@@ -0,0 +1,58 @@
+// GROUPS passed copy-ctors
+// Using Cfront 3.0.1 the programm below prints
+// 
+// 	  A()
+// 	  A(const A& a)
+// 	  ~A()
+// 	  A(A& a)        <---- !!!
+// 	  ~A()
+// 	  ~A()
+// 
+// the g++ 2.2.2 (sparc-sun-sunos4.1) generated code prints
+// 
+// 	  A()
+// 	  A(const A& a)
+// 	  ~A()
+// 	  A(const A& a)  <---- !!!
+// 	  ~A()
+// 	  ~A()
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A {
+public:
+  A() { die (1); }
+  A(const A& a) { die (2); }
+  A(A& a) { die (4); }
+  ~A() { count++; if (count != 3 && count != 5 && count != 6) die (-1); }
+};
+
+void foo1(const A& a) {
+  A b = a;
+}
+
+void foo2( A& a) {
+  A b = a;
+}
+
+int main() {
+  A a;
+
+  foo1(a);
+  foo2(a);
+
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C
new file mode 100644
index 00000000000..db63d75925b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy5.C
@@ -0,0 +1,84 @@
+// GROUPS passed copy-ctors
+/*
+bad:
+sibelius402> a.out
+a=5  a.virtMember()=30
+BaseClass::Increm --> {i=5, virtMember()=30}
+a=7  a.virtMember()=30
+b=7  b.virtMember()=30
+BaseClass::Increm --> {i=7, virtMember()=999}
+b=9  b.virtMember()=30
+sibelius403> 
+
+ good:
+
+sibelius406> a.out
+a=5  a.virtMember()=30
+BaseClass::Increm --> {i=5, virtMember()=30}
+a=7  a.virtMember()=30
+b=7  b.virtMember()=30
+BaseClass::Increm --> {i=7, virtMember()=30}
+b=9  b.virtMember()=30
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class BaseClass {
+
+  friend int operator != (const BaseClass irv, int x);
+
+  int i;
+
+public:
+
+  BaseClass( const BaseClass& ir ) : i(ir.i) {};
+  BaseClass() : i(5) {};
+
+  virtual int virtMember() { return( 999 ); };
+
+  void Increm( int r );
+};
+
+void BaseClass::Increm( int r )
+{
+  if ((i == 5 && virtMember () == 30)
+      || (i == 7 && virtMember () == 30))
+    i += r;
+  else
+    die ();
+};
+
+class DerivedClass : public BaseClass {
+public:
+  int virtMember() { return( 30 ); };
+};
+
+int operator != (const BaseClass irv, int x) { return irv.i != x; }
+
+main ()
+{
+    DerivedClass a;
+
+    if (a != 5 || a.virtMember () != 30)
+      die ();
+
+    a.Increm(2);
+
+    if (a != 7 || a.virtMember () != 30)
+      die ();
+
+    DerivedClass b = a;
+
+    if (b != 7 || a.virtMember () != 30)
+      die ();
+
+    b.Increm(2);
+
+    if (b != 9 || a.virtMember () != 30)
+      die ();
+
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C
new file mode 100644
index 00000000000..d15a4beee15
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy6.C
@@ -0,0 +1,55 @@
+// GROUPS passed copy-ctors
+/*
+g++ 2.3.3 will prefer using type conversions over the
+implicitly generated copy constructor. This is wrong.
+If you explicitly define a copy constructor, it will
+use it. However, the implicit copy constructor MUST be
+called whenever an explicit one would have been called
+also. See below: g++ converts from and back into
+unsigned, instead of using the implicit copy constructor:
+here is the version:
+Reading specs from /usr/lib/gcc-lib/i386-linux/2.3.3/specs
+gcc version 2.3.3
+ /usr/lib/gcc-lib/i386-linux/2.3.3/cpp -lang-c++ -v -undef -D__GNUC__=2 -D__GNUG__=2 -D__cplusplus -Dunix -Di386 -Dlinux -D__unix__ -D__i386__ -D__linux__ -D__unix -D__i386 -D__linux bug2.cc /usr/tmp/cca02008.i
+GNU CPP version 2.3.3 (80386, BSD syntax)
+ /usr/lib/gcc-lib/i386-linux/2.3.3/cc1plus /usr/tmp/cca02008.i -quiet -dumpbase bug2.cc -version -o /usr/tmp/cca02008.s
+GNU C++ version 2.3.3 (80386, BSD syntax) compiled by GNU C version 2.3.3.
+ as -o /usr/tmp/cca020081.o /usr/tmp/cca02008.s
+ ld /usr/lib/crt0.o -nojump -L/usr/lib/gcc-lib/i386-linux/2.3.3 /usr/tmp/cca020081.o -lg++ -lgcc -lc -lgcc
+
+Ok, and here is the output:
+test k: constructing from scratch
+test l=k: type conversion into unsigned
+constructing from unsigned
+
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+struct test {
+	test() { if (count != 0) die (); }
+
+	test(unsigned) {
+	  die ();
+	}
+	operator unsigned() {
+	  die ();
+	  return 0;
+	}
+};
+
+int
+main() {
+  test k;
+  test l=k;
+
+  printf ("PASS\n");
+
+  return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C
new file mode 100644
index 00000000000..c98d77f6d12
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy7.C
@@ -0,0 +1,29 @@
+// GROUPS passed copy-ctors
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class B {
+public:
+  B() {}
+  B(const B &) { printf ("PASS\n"); exit (0); };
+private:
+    int x;
+};
+
+class A : public B {
+public:
+    A() {}
+
+  A(const B &) { printf ("FAIL\n"); exit (1); }
+};
+
+main()
+{
+    A a;
+    A b(a);
+
+    printf ("FAIL\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C
new file mode 100644
index 00000000000..fe248bae34d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy8.C
@@ -0,0 +1,67 @@
+// GROUPS passed copy-ctors
+/*
+This report is for GCC 2.3.3 running on a Sun/4.  The bug is that when
+a class instance is passed-by-value, GCC does not correctly copy the value.
+At the end of this report is an example program that demonstrates the bug.  
+It should print:
+
+	construct A('x')
+	copy A('x')
+	destruct A('x')
+	destruct A('x')
+
+and in fact does for IBM's xlC C++.  However, for GCC 2.3.3, it fails
+to print the second line ["copy A('x')"], which indicates that it failed
+to call the copy-constructor for class A when it should have.  Below is a 
+typescript that lists the program, shows how I compiled it, and shows the 
+incorrect output.
+*/
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A { // Class with explicit & instrumented copy-constructor and destructor.
+public:
+    const char * id;
+    A( const char * id1 ) : id(id1) { die (1); }
+
+    // Copy constructor
+    A( const A& a ) : id(a.id) { die (2); }
+
+    // Destructor
+    ~A() { count++; if (count != 3 && count != 4) die (-1); }
+};
+
+class X { // Class without explicit copy-constructor
+private:
+    A a;
+public:
+    X( const char * id ) : a(id) {}
+};
+
+void Func( X x ) {      // Function with call-by-value argument
+}
+
+int
+main() {
+    X x("x");           // Construct instance of x.
+
+    // The next line should call the copy-constructor for X since x is
+    // being passed by value.  For GCC 2.3.3 on a Sun/4, it does not.
+    Func(x);
+
+    printf ("PASS\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C b/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C
new file mode 100644
index 00000000000..9c5114a322f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/copy9.C
@@ -0,0 +1,40 @@
+// GROUPS passed copy-ctors
+#include <iostream.h>
+
+// token types: from state parser
+const int T_EOF = 257;
+const int T_ERROR = 258;
+const int T_Float = 259;
+const int T_Int = 260;
+const int T_ID = 261;
+const int T_STRING = 262;
+
+class Complex;
+class State;
+
+// token, from state parser.
+class ParseToken {
+public:
+	int tok;
+	union {
+		char cval;
+		const char *sval;
+		int intval;
+		double  doubleval;
+		Complex* Complexval;
+		const State*  s;
+	}; 
+	ParseToken () { tok = 0; intval = 0;}
+};
+
+main () {
+	ParseToken a;
+	a.tok = T_Float;
+	a.doubleval = 23.2;
+	ParseToken b(a);
+
+	if (b.doubleval == 23.2)
+	  cout << "PASS\n";
+	else
+	  cout << "FAIL\n";
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C
new file mode 100644
index 00000000000..66de235b484
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash1.C
@@ -0,0 +1,44 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class D_Interval;
+
+class Date
+{
+ public:
+  Date(const D_Interval*,const Date&);
+private:
+  const D_Interval* interval;
+};
+
+class Time_Interval
+{
+ public:
+   Time_Interval(const Date& start,const Date& stop);
+   const Date& Start() const { return start; }
+   const Date& Stop() const { return stop; }
+ private:
+   Date start;
+   Date stop;
+};
+
+class Dated_Data
+{
+ public:
+   Dated_Data(const Time_Interval& dates);
+   virtual ~Dated_Data();
+   Time_Interval Dates() const { return dates; }
+ private:
+   Time_Interval dates;
+};
+
+class Raw_Data : public Dated_Data
+{
+ public:
+   Raw_Data(const Dated_Data *source,const D_Interval& period);
+};
+
+Raw_Data::Raw_Data(const Dated_Data *source,const D_Interval& period)
+     : Dated_Data(Time_Interval(Date(&period,source->Dates().Start()),
+				Date(&period,source->Dates().Stop())))
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C
new file mode 100644
index 00000000000..6680718bad6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash10.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class word
+{
+  unsigned char b1, b2;
+public:
+  word (unsigned int i = 0) { b1 = i & 0xff; b2 = (i & 0xff00) >> 8; }
+  operator unsigned int () { return (b2 <<  8) + b1; }
+};
+
+class just_another
+{
+  int foo;
+  char bar[23];
+};
+
+int mumble(word w)
+{
+  just_another *jap;
+  unsigned bar;
+
+  bar = w;
+  
+  jap = new just_another [w];
+  
+  return 0;
+}  
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C
new file mode 100644
index 00000000000..f03953ab20e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash11.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern "C" void printf (char *, ...);
+
+class A {
+	int	i;
+	int	j;
+    public:
+	int	h;
+	A() { i=10; j=20; }
+	virtual void f1() { printf("i=%d j=%d\n",i,j); }
+	friend virtual void f2() { printf("i=%d j=%d\n",i,j); }// ERROR -  virtual.*
+};
+
+class B : public A {
+    public:
+	virtual void f1() { printf("i=%d j=%d\n",i,j); }// ERROR -  member.*// ERROR -  member.*
+	friend virtual void f2() { printf("i=%d j=%d\n",i,j); }// ERROR -  virtual.*// ERROR -  member.*// ERROR -  member.*
+};
+
+main() {
+	A * a = new A;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C
new file mode 100644
index 00000000000..0671c7b8970
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash12.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X
+{
+        int i;
+public:
+        X(int j);
+}
+
+X *x = new X[10]();// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C
new file mode 100644
index 00000000000..a292d67f235
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash13.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class gen_op
+{
+public:
+  gen_op ( );
+  gen_op (const gen_op &Op1);
+  ~gen_op ( );
+  void operator = (const gen_op &Op1);
+};
+
+
+
+
+class spin_op 
+{
+public:
+  spin_op();
+  spin_op(const spin_op& SOp);
+  ~spin_op();
+  void operator= (const spin_op& SOp);
+  operator gen_op();
+};
+
+
+spin_op Fe();
+
+
+gen_op Spul_U_axis()
+{
+  gen_op U1;
+  U1 = Fe();
+}; // ERROR - reaches end of non-void function
+
+main () {};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C
new file mode 100644
index 00000000000..d7a0de482f9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash14.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern "C" void printf (char *, ...);
+
+
+class cl
+{
+  int i;
+public:
+  cl(int j = 0) {i = j;}
+  int get_i() {return i;}
+  };
+
+main()
+{
+  cl ob[3] = {1, 2, 3};
+  int i;
+
+  for(i=0; i<3; i++)
+    printf("%d\n", ob[i].get_i());
+
+  return 0;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C
new file mode 100644
index 00000000000..a4b1ffabee3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash15.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+class A {
+ public:
+  virtual ~A() {cout << "executed ~A()\n";};
+};
+
+class B : public A {
+ public:
+  virtual ~B() {cout << "executed ~B()\n";};
+};
+
+main() {
+  cout << "starting\n";
+  B b;
+  b.~A();// ERROR -  destructor
+  cout << "done\n";
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C
new file mode 100644
index 00000000000..5030b297ae0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash16.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class Graph {
+public:
+      unsigned         char N;
+      Graph(void) {}; // ERROR - previously defined here
+}
+
+Graph::Graph(void)
+{    N = 10;// ERROR -  return type.*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C
new file mode 100644
index 00000000000..7072eab2c88
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash17.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed old-abort
+//
+// This one creates
+//
+// gcc2: Internal compiler error: program cc1plus got fatal signal 11
+//
+// when compiled with g++.
+// The error goes away, if
+// 1) int ClassInvariant() is not virtual or
+// 2) GnObject has a virtual destructor or
+// 3) GnWidget has no virtual destructor or
+// 4) GnContracts has a virtual destructor
+//
+
+
+class GnContracts {
+  public:
+    virtual int ClassInvariant();
+//    virtual ~GnContracts();
+};
+
+class GnObject : public GnContracts {
+  public:
+//    virtual ~GnObject();
+};
+
+class GnWidget : public GnObject {
+  public:
+    virtual ~GnWidget();
+};
+
+class GnOptionGroup : public GnObject, public GnWidget {
+};// ERROR -  warning
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C
new file mode 100644
index 00000000000..d4a4c60b7c8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash18.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef int element;
+class Pix {
+public:
+    Pix();
+    Pix(const Pix&);
+
+    // Friend functions so that v == x works as does x == v works
+    friend int operator==(void *v, const Pix& x)
+        { return v == index; }// ERROR - .*
+    friend int operator==(void *v, const Pix& x)
+        { return v != index; }// ERROR - .*
+private:
+//    friend class List<T>;
+    element *index;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C
new file mode 100644
index 00000000000..dd621b16dcd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash19.C
@@ -0,0 +1,1704 @@
+// Special g++ Options: 
+// Build don't link: 
+// GROUPS passed old-abort
+typedef unsigned long _G_clock_t;
+typedef long _G_dev_t;
+typedef long int _G_fpos_t;
+typedef long _G_gid_t;
+typedef unsigned long _G_ino_t;
+typedef unsigned short _G_mode_t;
+typedef short _G_nlink_t;
+typedef long _G_off_t;
+typedef long _G_pid_t;
+typedef int _G_ptrdiff_t;
+typedef int   _G_sigset_t;
+typedef unsigned int _G_size_t;
+typedef long _G_time_t;
+typedef long _G_uid_t;
+typedef unsigned int _G_wchar_t;
+typedef int _G_ssize_t;
+typedef double * _G_va_list;
+class ostream; class streambuf; class backupbuf;
+extern "C" int __underflow(streambuf*);
+extern "C" int __overflow(streambuf*, int);
+typedef _G_off_t streamoff;
+typedef _G_off_t streampos;  
+typedef unsigned long __fmtflags;
+typedef unsigned char __iostate;
+struct _ios_fields {  
+    streambuf *_strbuf;
+    ostream* _tie;
+    int _width;
+    __fmtflags _flags;
+    _G_wchar_t _fill;
+    __iostate _state;
+    __iostate _exceptions;
+    int _precision;
+};
+enum state_value {
+    _good = 0 ,
+    _eof = 1 ,
+    _fail = 2 ,
+    _bad = 4  };
+enum open_mode {
+    input = 1 ,
+    output = 2 ,
+    atend = 4 ,
+    append = 8  };
+class ios : public _ios_fields {
+  public:
+    typedef __fmtflags fmtflags;
+    typedef int iostate;
+    typedef int openmode;
+    enum io_state {
+	goodbit = 0 ,
+	eofbit = 1 ,
+	failbit = 2 ,
+	badbit = 4  };
+    enum open_mode {
+	in = 1 ,
+	out = 2 ,
+	ate = 4 ,
+	app = 8 ,
+	trunc = 16 ,
+	nocreate = 32 ,
+	noreplace = 64 ,
+	bin = 128  };
+    enum seek_dir { beg, cur, end};
+    enum { skipws=01, left=02, right=04, internal=010,
+	   dec=020, oct=040, hex=0100,
+	   showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+	   scientific=04000, fixed=010000, unitbuf=020000, stdio=040000,
+	   dont_close=0x80000000  
+	   };
+    enum {  
+	basefield=dec+oct+hex,
+	floatfield = scientific+fixed,
+	adjustfield = left+right+internal
+    };
+    ostream* tie() const { return _tie; }
+    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
+    _G_wchar_t fill() const { return (_G_wchar_t)_fill; }
+    _G_wchar_t fill(_G_wchar_t newf)
+	{_G_wchar_t oldf = (_G_wchar_t)_fill; _fill = (char)newf; return oldf;}
+    fmtflags flags() const { return _flags; }
+    fmtflags flags(fmtflags new_val) {
+	fmtflags old_val = _flags; _flags = new_val; return old_val; }
+    int precision() const { return _precision; }
+    int precision(int newp) {
+	unsigned short oldp = _precision; _precision = (unsigned short)newp;
+	return oldp; }
+    fmtflags setf(fmtflags val) {
+	fmtflags oldbits = _flags;
+	_flags |= val; return oldbits; }
+    fmtflags setf(fmtflags val, fmtflags mask) {
+	fmtflags oldbits = _flags;
+	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
+    fmtflags unsetf(fmtflags mask) {
+	fmtflags oldbits = _flags & mask;
+	_flags &= ~mask; return oldbits; }
+    int width() const { return _width; }
+    int width(int val) { int save = _width; _width = val; return save; }
+    void _throw_failure() { }
+    streambuf* rdbuf() const { return _strbuf; }
+    void clear(iostate state = 0) {
+	_state = _strbuf ? state : state|badbit;
+	if (_state & _exceptions) _throw_failure(); }
+    void set(iostate flag) { _state |= flag;
+	if (_state & _exceptions) _throw_failure(); }
+    int good() const { return _state == 0; }
+    int eof() const { return _state & ios::eofbit; }
+    int fail() const { return _state & (ios::badbit|ios::failbit); }
+    int bad() const { return _state & ios::badbit; }
+    iostate rdstate() const { return _state; }
+    operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
+    int operator!() const { return fail(); }
+    iostate exception(iostate enable) {
+	iostate old = _exceptions; _exceptions = enable;
+	if (_state & _exceptions) _throw_failure();
+	return old; }
+    static int sync_with_stdio(int on);
+    static void sync_with_stdio() { sync_with_stdio(1); }
+    void unset(state_value flag) { _state &= ~flag; }
+    void close();
+    int is_open();
+    int readable();
+    int writable();
+  protected:
+    ios(streambuf* sb = 0, ostream* tie = 0);
+    virtual ~ios();
+    void init(streambuf* sb) { _state=0; _strbuf=sb; }
+};
+typedef ios::seek_dir _seek_dir;
+class streammarker {
+    friend class streambuf;
+    friend int __underflow(streambuf*);
+    struct streammarker *_next;   
+    streambuf *_sbuf;  
+    streampos _spos;  
+    void set_streampos(streampos sp) { _spos = sp; }
+    void set_offset(int offset) { _pos = offset; _spos = (streampos)(-2); }
+    int _pos;
+  public:
+    streammarker(streambuf *sb);
+    ~streammarker();
+    int saving() { return  _spos == -2; }
+    int delta(streammarker&);
+    int delta();
+};
+struct __streambuf {
+    int _flags;		 
+    char* _gptr;	 
+    char* _egptr;	 
+    char* _eback;	 
+    char* _pbase;	 
+    char* _pptr;	 
+    char* _epptr;	 
+    char* _base;	 
+    char* _ebuf;	 
+    struct streambuf *_chain;
+    friend class streammarker;
+    char *_other_gbase;  
+    char *_aux_limit;   
+    char *_other_egptr;  
+    streammarker *_markers;
+    unsigned short _cur_column;
+    char _unused;
+    char _shortbuf[1];
+};
+extern unsigned __adjust_column(unsigned start, const char *line, int count);
+struct streambuf : private __streambuf {
+    friend class ios;
+    friend class istream;
+    friend class ostream;
+    friend class streammarker;
+    friend int __underflow(streambuf*);
+  protected:
+    static streambuf* _list_all;  
+    streambuf*& xchain() { return _chain; }
+    void _un_link();
+    void _link_in();
+    char* gptr() const { return _gptr; }
+    char* pptr() const { return _pptr; }
+    char* egptr() const { return _egptr; }
+    char* epptr() const { return _epptr; }
+    char* pbase() const { return _pbase; }
+    char* eback() const { return _eback; }
+    char* base() const { return _base; }
+    char* ebuf() const { return _ebuf; }
+    int blen() const { return _ebuf - _base; }
+    void xput_char(char c) { *_pptr++ = c; }
+    int xflags() { return _flags; }
+    int xflags(int f) { int fl = _flags; _flags = f; return fl; }
+    void xsetflags(int f) { _flags |= f; }
+    void xsetflags(int f, int mask) { _flags = (_flags & ~mask) | (f & mask); }
+    void gbump(int n) { _gptr += n; }
+    void pbump(int n) { _pptr += n; }
+    void setb(char* b, char* eb, int a=0);
+    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
+    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
+    char *shortbuf() { return _shortbuf; }
+    int in_backup() { return _flags & 0x100 ; }
+    char *Gbase() { return in_backup() ? _other_gbase : _eback; }
+    char *eGptr() { return in_backup() ? _other_egptr : _egptr; }
+    char *Bbase() { return in_backup() ? _eback : _other_gbase; }
+    char *Bptr() { return _aux_limit; }
+    char *eBptr() { return in_backup() ? _egptr : _other_egptr; }
+    char *Nbase() { return _other_gbase; }
+    char *eNptr() { return _other_egptr; }
+    int have_backup() { return _other_gbase != ((void*)0) ; }
+    int have_markers() { return _markers != ((void*)0) ; }
+    int _least_marker();
+    void switch_to_main_get_area();
+    void switch_to_backup_area();
+    void free_backup_area();
+    void unsave_markers();  
+    int put_mode() { return _flags & 0x800 ; }
+    int switch_to_get_mode();
+    streambuf(int flags=0);
+  public:
+    static int flush_all();
+    static void flush_all_linebuffered();  
+    virtual int underflow() = 0;  
+    virtual int overflow(int c = (-1) ) = 0;  
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
+    int seekmark(streammarker& mark, int delta = 0);
+    int sputbackc(char c);
+    int sungetc();
+    virtual ~streambuf();
+    int unbuffered() { return _flags & 2  ? 1 : 0; }
+    int linebuffered() { return _flags & 0x200  ? 1 : 0; }
+    void unbuffered(int i)
+	{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
+    void linebuffered(int i)
+	{ if (i) _flags |= 0x200 ; else _flags &= ~0x200 ; }
+    int allocate() {  
+	if (base() || unbuffered()) return 0;
+	else return doallocate(); }
+    void allocbuf() { if (base() == ((void*)0) ) doallocbuf(); }
+    void doallocbuf();
+    virtual int sync();
+    virtual int pbackfail(int c);
+    virtual streambuf* setbuf(char* p, int len);
+    int in_avail() { return _egptr - _gptr; }
+    int out_waiting() { return _pptr - _pbase; }
+    virtual int xsputn(const char* s, int n);
+    int sputn(const char* s, int n) { return xsputn(s, n); }
+    int padn(char pad, int n);  
+    virtual int xsgetn(char* s, int n);
+    int sgetn(char* s, int n) { return xsgetn(s, n); }
+    int ignore(int);
+    virtual int get_column();
+    virtual int set_column(int);
+    long sgetline(char* buf, _G_size_t n, char delim, int putback_delim);
+    int sbumpc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr++; }
+    int sgetc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int snextc() {
+	if (_gptr >= _egptr && __underflow(this) == (-1) ) return (-1) ;
+	return _gptr++, sgetc(); }
+    int sputc(int c) {
+	if (_pptr >= _epptr) return __overflow(this, (unsigned char)c);
+	else return *_pptr++ = c, (unsigned char)c; }
+    void stossc() { if (_gptr < _egptr) _gptr++; }
+    int vscan(char const *fmt0, _G_va_list ap, ios* stream = ((void*)0) );
+    int scan(char const *fmt0 ...);
+    int vform(char const *fmt0, _G_va_list ap);
+    int form(char const *fmt0 ...);
+};
+class backupbuf : public streambuf {
+    friend class streammarker;
+  protected:
+    backupbuf(int flags=0) : streambuf(flags| 0x4000 ) { }
+  public:
+    virtual int pbackfail(int c);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+};
+struct __file_fields {
+    short _fileno;
+    int _blksize;
+    _G_fpos_t _offset;
+};
+class filebuf : public backupbuf {
+  protected:
+    struct __file_fields _fb;
+    void init();
+  public:
+    static const int openprot;  
+    filebuf();
+    filebuf(int fd);
+    filebuf(int fd, char* p, int len);
+    ~filebuf();
+    filebuf* attach(int fd);
+    filebuf* open(const char *filename, const char *mode);
+    filebuf* open(const char *filename, ios::openmode mode, int prot = 0664);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+    int is_open() const { return _fb._fileno >= 0; }
+    int fd() const { return is_open() ? _fb._fileno : (-1) ; }
+    filebuf* close();
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streambuf* setbuf(char* p, int len);
+    int xsputn(const char* s, int n);
+    int xsgetn(char* s, int n);
+    virtual int sync();
+  protected:  
+    int is_reading() { return eback() != egptr(); }
+    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
+    char* file_ptr() { return eGptr(); }
+    int do_write(const char *data, int to_do);
+    int do_flush() { return do_write(_pbase, _pptr-_pbase); }// ERROR - 
+    virtual _G_ssize_t sys_read(char* buf, _G_size_t size);
+    virtual _G_fpos_t sys_seek(_G_fpos_t, _seek_dir);
+    virtual _G_ssize_t sys_write(const void*, long);
+    virtual int sys_stat(void*);  
+    virtual int sys_close();
+};
+inline ios::ios(streambuf* sb  , ostream* tie  ) {
+		_state = sb ? ios::goodbit : ios::badbit; _exceptions=0;
+		_strbuf=sb; _tie = tie; _width=0; _fill=' ';
+		_flags=ios::skipws|ios::dec; _precision=6; }
+inline ios::~ios() {
+    if (!(_flags & (unsigned int)ios::dont_close)) delete _strbuf; }
+class istream; class ostream;
+typedef ios& (*__manip)(ios&);
+typedef istream& (*__imanip)(istream&);
+typedef ostream& (*__omanip)(ostream&);
+extern istream& ws(istream& ins);
+extern ostream& flush(ostream& outs);
+extern ostream& endl(ostream& outs);
+extern ostream& ends(ostream& outs);
+class ostream : virtual public ios
+{
+    void do_osfx();
+  public:
+    ostream() { }
+    ostream(streambuf* sb, ostream* tied=((void*)0) );
+    int opfx() {
+	if (!good()) return 0; else { if (_tie) _tie->flush(); return 1;} }
+    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
+		      do_osfx(); }
+    streambuf* ostreambuf() const { return _strbuf; }
+    ostream& flush();
+    ostream& put(char c) { _strbuf->sputc(c); return *this; }
+    ostream& put(unsigned char c) { return put((char)c); }
+    ostream& write(const char *s, int n);
+    ostream& write(const unsigned char *s, int n) { return write((const char*)s, n);}
+    ostream& put(signed char c) { return put((char)c); }
+    ostream& write(const signed char *s, int n) { return write((const char*)s, n);}
+    ostream& write(const void *s, int n) { return write((const char*)s, n);}
+    ostream& seekp(streampos);
+    ostream& seekp(streamoff, _seek_dir);
+    streampos tellp();
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, _G_va_list args);
+    ostream& operator<<(char c);
+    ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
+    ostream& operator<<(signed char c) { return (*this) << (char)c; }
+    ostream& operator<<(const char *s);
+    ostream& operator<<(const unsigned char *s)
+	{ return (*this) << (const char*)s; }
+    ostream& operator<<(const signed char *s)
+	{ return (*this) << (const char*)s; }
+    ostream& operator<<(void *p);
+    ostream& operator<<(int n);
+    ostream& operator<<(unsigned int n);
+    ostream& operator<<(long n);
+    ostream& operator<<(unsigned long n);
+    ostream& operator<<(long long n);
+    ostream& operator<<(unsigned long long n);
+    ostream& operator<<(short n) {return operator<<((int)n);}
+    ostream& operator<<(unsigned short n) {return operator<<((unsigned int)n);}
+    ostream& operator<<(double n);
+    ostream& operator<<(float n) { return operator<<((double)n); }
+    ostream& operator<<(__omanip func) { return (*func)(*this); }
+    ostream& operator<<(__manip func) {(*func)(*this); return *this;}
+    ostream& operator<<(streambuf*);
+};
+class istream : virtual public ios
+{
+    _G_ssize_t _gcount;
+    int _skip_ws();
+  public:
+    istream() { _gcount = 0; }
+    istream(streambuf* sb, ostream*tied=((void*)0) );
+    streambuf* istreambuf() const { return _strbuf; }
+    istream& get(char* ptr, int len, char delim = '\n');
+    istream& get(unsigned char* ptr, int len, char delim = '\n')
+	{ return get((char*)ptr, len, delim); }
+    istream& get(char& c);
+    istream& get(unsigned char& c) { return get((char&)c); }
+    istream& getline(char* ptr, int len, char delim = '\n');
+    istream& getline(unsigned char* ptr, int len, char delim = '\n')
+	{ return getline((char*)ptr, len, delim); }
+    istream& get(signed char& c)  { return get((char&)c); }
+    istream& get(signed char* ptr, int len, char delim = '\n')
+	{ return get((char*)ptr, len, delim); }
+    istream& getline(signed char* ptr, int len, char delim = '\n')
+	{ return getline((char*)ptr, len, delim); }
+    istream& read(char *ptr, int n);
+    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(signed char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
+    istream& get(streambuf& sb, char delim = '\n');
+    istream& gets(char **s, char delim = '\n');
+    int ipfx(int need) {
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
+	if (!need && (flags() & ios::skipws)) return _skip_ws();
+	return 1;
+    }
+    int ipfx0() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie) _tie->flush();
+	if (flags() & ios::skipws) return _skip_ws();
+	return 1;
+    }
+    int ipfx1() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
+	return 1;
+    }
+    int get() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sbumpc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    int peek() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sgetc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    _G_ssize_t gcount() { return _gcount; }
+    istream& ignore(int n=1, int delim = (-1) );
+    istream& seekg(streampos);
+    istream& seekg(streamoff, _seek_dir);
+    streampos tellg();
+    istream& putback(char ch) {
+	if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& unget() {
+	if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& scan(const char *format ...);
+    istream& vscan(const char *format, _G_va_list args);
+    istream& unget(char ch) { return putback(ch); }
+    int skip(int i);
+    istream& operator>>(char*);
+    istream& operator>>(unsigned char* p) { return operator>>((char*)p); }
+    istream& operator>>(signed char*p) { return operator>>((char*)p); }
+    istream& operator>>(char& c);
+    istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
+    istream& operator>>(signed char& c) {return operator>>((char&)c);}
+    istream& operator>>(int&);
+    istream& operator>>(long&);
+    istream& operator>>(long long&);
+    istream& operator>>(short&);
+    istream& operator>>(unsigned int&);
+    istream& operator>>(unsigned long&);
+    istream& operator>>(unsigned long long&);
+    istream& operator>>(unsigned short&);
+    istream& operator>>(float&);
+    istream& operator>>(double&);
+    istream& operator>>( __manip func) {(*func)(*this); return *this;}
+    istream& operator>>(__imanip func) { return (*func)(*this); }
+    istream& operator>>(streambuf*);
+};
+class iostream : public istream, public ostream
+{
+    _G_ssize_t _gcount;
+  public:
+    iostream() { _gcount = 0; }
+    iostream(streambuf* sb, ostream*tied=((void*)0) );
+};
+extern istream cin;
+extern ostream cout, cerr, clog;  
+struct Iostream_init { } ;   
+inline ios& dec(ios& i)
+{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& hex(ios& i)
+{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& oct(ios& i)
+{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
+extern char* form(const char*, ...);
+extern char* dec(long, int=0);
+extern char* dec(int, int=0);
+extern char* dec(unsigned long, int=0);
+extern char* dec(unsigned int, int=0);
+extern char* hex(long, int=0);
+extern char* hex(int, int=0);
+extern char* hex(unsigned long, int=0);
+extern char* hex(unsigned int, int=0);
+extern char* oct(long, int=0);
+extern char* oct(int, int=0);
+extern char* oct(unsigned long, int=0);
+extern char* oct(unsigned int, int=0);
+inline istream& WS(istream& str) { return ws(str); }
+typedef double *__gnuc_va_list;
+extern "C" {
+   typedef struct {
+	int		 __cnt;
+	unsigned char	*__ptr;
+	unsigned char	*__base;
+	unsigned short	 __flag;
+	unsigned char 	 __fileL;		 
+	unsigned char 	 __fileH;		 
+   } FILE;
+   typedef struct {
+	int		 __cnt;
+	unsigned char	*__ptr;
+	unsigned char	*__base;
+	unsigned short	 __flag;
+	unsigned char 	 __fileL;		 
+	unsigned char 	 __fileH;		 
+	unsigned char	*__bufendp;	 
+	unsigned char	 __smbuf[8 ];  
+   } _FILEX;
+     typedef unsigned int size_t;
+   typedef long int fpos_t;
+     typedef double *__va_list;
+   extern FILE __iob[];
+     extern int remove(const char *);
+     extern int rename(const char *, const char *);
+     extern FILE *tmpfile(void);
+     extern char *tmpnam(char *);
+     extern int fclose(FILE *);
+     extern int fflush(FILE *);
+     extern FILE *fopen(const char *, const char *);
+     extern FILE *freopen(const char *, const char *, FILE *);
+     extern void setbuf(FILE *, char *);
+     extern int setvbuf(FILE *, char *, int, size_t);
+     extern int fprintf(FILE *, const char *, ...);
+     extern int fscanf(FILE *, const char *,...);
+     extern int printf(const char *,...);
+     extern int scanf(const char *,...);
+     extern int sprintf(char *, const char *,...);
+     extern int sscanf(const char *, const char *,...);
+     extern int vprintf(const char *, __va_list);
+     extern int vfprintf(FILE *, const char *, __va_list);
+     extern int vsprintf(char *, const char *, __va_list);
+     extern int fgetc(FILE *);
+     extern char *fgets(char *, int, FILE *);
+     extern int fputc(int, FILE *);
+     extern int fputs(const char *, FILE *);
+     extern int getc(FILE *);
+     extern int getchar(void);
+     extern char *gets(char *);
+     extern int putc(int, FILE *);
+     extern int putchar(int);
+     extern int puts(const char *);
+     extern int ungetc(int, FILE *);
+     extern int fgetpos(FILE *, fpos_t *);
+     extern int fseek(FILE *, long int, int);
+     extern int fsetpos(FILE *, const fpos_t *);
+     extern long int ftell(FILE *);
+     extern void rewind(FILE *);
+     extern void clearerr(FILE *);
+     extern int feof(FILE *);
+     extern int ferror(FILE *);
+     extern void perror(const char *);
+       extern size_t fread(void *, size_t, size_t, FILE *);
+       extern size_t fwrite(const void *, size_t, size_t, FILE *);
+     extern int __flsbuf(unsigned char, FILE *);
+     extern int __filbuf(FILE *);
+     extern int fileno(FILE *);
+     extern FILE *fdopen(int, const char *);
+     extern int getw(FILE *);
+     extern int putw(int, FILE *);
+     extern int pclose(FILE *);
+     extern FILE *popen(const char *, const char *);
+     extern char *tempnam(const char *, const char *);
+     extern char *ctermid(char *);
+     extern char *cuserid(char *);
+     extern int nl_fprintf(FILE *, const char * ,...);
+     extern int nl_fscanf(FILE *, const char * ,...);
+     extern int nl_printf(const char * ,...);
+     extern int nl_scanf(const char * ,...);
+     extern int nl_sprintf(char *, const char * ,...);
+     extern int nl_sscanf(const char *, const char * ,...);
+   extern unsigned char *__bufendtab[];
+}
+extern "C" {
+   extern int __nl_char_size;
+   typedef struct {
+	int quot;	 
+	int rem;	 
+   } div_t;
+   typedef struct {
+	long int quot;	 
+	long int rem;	 
+   } ldiv_t;
+     typedef unsigned int wchar_t;
+       extern double atof(const char *);
+     extern int atoi(const char *);
+     extern long int atol(const char *);
+     extern double strtod(const char *, char **);
+     extern long int strtol(const char *, char **, int);
+     extern unsigned long int strtoul(const char *, char **, int);
+     extern int rand(void);
+     extern void srand(unsigned int);
+     extern int atexit(void (*) (void));
+     extern void exit(int);
+     extern char *getenv(const char *);
+     extern int system(const char *);
+       inline int abs(int d) { return (d>0)?d:-d; }
+     extern div_t div(int, int);
+     extern ldiv_t ldiv(long int, long int);
+     extern long int labs(long int);
+     extern int mblen(const char *, size_t);
+     extern int mbtowc(wchar_t *, const char *, size_t);
+     extern int wctomb(char *, wchar_t);
+     extern size_t mbstowcs(wchar_t *, const char *, size_t);
+     extern size_t wcstombs(char *, const wchar_t *, size_t);
+     extern void free(void *);
+     extern void qsort(void *, size_t, size_t, int (*)(const void *, const void *));
+       extern void abort(void);
+       extern void *bsearch(const void *, const void *, size_t, size_t, int (*) (const void *, const void *));
+       extern void *calloc(size_t, size_t);
+       extern void *malloc(size_t);
+       extern void *realloc(void *, size_t);
+     extern void setkey(const char *);
+     extern void lcong48( unsigned short [] );
+     extern double wcstod( const wchar_t *, wchar_t ** );
+     extern long wcstol( const wchar_t *, wchar_t **, int );
+     extern unsigned long wcstoul( const wchar_t *, wchar_t **, int );
+     extern double drand48(void);
+     extern double erand48(unsigned short []);
+     extern long jrand48(unsigned short []);
+     extern long lrand48(void);
+     extern long mrand48(void);
+     extern long nrand48(unsigned short []);
+     extern void srand48(long);
+     extern unsigned short *seed48(unsigned short []);
+     extern int putenv(const char *);
+    extern int clearenv(void);
+    extern int getopt(int, char * const [], const char *);
+    extern char *getpass(const char *);
+  extern char *optarg;
+  extern int optind;
+  extern int opterr;
+  struct mallinfo  {
+	int arena;	 
+	int ordblks;	 
+	int smblks;	 
+	int hblks;	 
+	int hblkhd;	 
+	int usmblks;	 
+	int fsmblks;	 
+	int uordblks;	 
+	int fordblks;	 
+	int keepcost;	 
+  };	
+     typedef struct {
+       unsigned int word1, word2, word3, word4;
+     } long_double;
+extern "C" {
+     typedef long gid_t;
+     typedef long uid_t;
+   struct passwd {
+	char	*pw_name;
+	char 	*pw_passwd;
+	uid_t	pw_uid;
+	gid_t	pw_gid;
+	char 	*pw_age;
+	char	*pw_comment;
+	char	*pw_gecos;
+	char	*pw_dir;
+	char	*pw_shell;
+	long	pw_audid;
+	int	pw_audflg;
+   };
+     extern struct passwd *getpwuid(uid_t);
+     extern struct passwd *getpwnam(const char *);
+   struct s_passwd {
+       char    *pw_name;
+       char    *pw_passwd;
+       char    *pw_age;
+       long     pw_audid;
+       int     pw_audflg;
+   };
+   struct comment {
+	char	*c_dept;
+	char	*c_name;
+	char	*c_acct;
+	char	*c_bin;
+   };
+     extern void setpwent(void);
+     extern void endpwent(void);
+     extern struct passwd *getpwent(void);
+     extern struct passwd *fgetpwent(FILE *);
+     extern struct s_passwd *getspwent(void);
+     extern struct s_passwd *getspwuid(int);
+     extern struct s_passwd *getspwaid(int);
+     extern struct s_passwd *getspwnam(char *);
+     extern struct s_passwd *fgetspwent(FILE *);
+}
+extern int errno;
+     extern "C" {
+         extern int errno;
+     }
+extern "C" {
+    extern void perror(const char*);
+    extern int sys_nerr;
+    extern char *sys_errlist[];
+    extern char *strerror (int);
+}
+     extern const char *fcvt(double, size_t, int *, int *);
+     extern char *gcvt(double, size_t, char *);
+     extern char *ecvt(double, size_t, int *, int *);
+     extern char *nl_gcvt(double, size_t, char *, int);
+     extern char *_ldecvt(long_double, size_t, int *, int *);
+     extern char *_ldfcvt(long_double, size_t, int *, int *);
+     extern char *_ldgcvt(long_double, size_t, char *);
+     extern int getpw(int, char *);
+     extern long a64l(const char *);
+     extern char *l64a(long);
+     extern void l3tol(long *, const char *, int);
+     extern void ltol3(char *, const long *, int);
+     extern char *getmsg(int, int, int, char *, int);
+     extern double nl_atof(const char *, int);
+     extern double nl_strtod(const char *, char **, int);
+     extern char *ltostr(long, int);
+     extern char *ultostr(unsigned long, int);
+     extern char *ltoa(long);
+     extern char *ultoa(unsigned long);
+     extern void memorymap(int);
+     extern struct mallinfo mallinfo(void);
+     extern int mallopt(int, int);
+}
+typedef void * POINTER;
+typedef FILE * FILE_PTR;
+typedef void (*DISPLAYER)   (POINTER obj, FILE_PTR fp, FILE_PTR errorFile)  ;
+typedef void (*DESTROYER)   (POINTER obj, FILE_PTR errorFile)  ;
+typedef void (*RCOUNT_INC)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef int  (*COMPARE)     (POINTER obj1, POINTER obj2)  ;
+typedef	unsigned long (*HASH_ADDR)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef	unsigned long (*HASH_SKIP)  (POINTER obj, FILE_PTR errorFile)  ;
+typedef POINTER
+	(*ACCESS_FCT)  (POINTER target, POINTER sample, FILE_PTR errorFile)  ;
+typedef POINTER DATA_PTR;
+     typedef long dev_t;		 
+     typedef unsigned long ino_t;	 
+     typedef unsigned short mode_t; 	 
+     typedef short nlink_t;		 
+     typedef long off_t;		 
+     typedef long pid_t;		 
+     typedef long time_t;		 
+      typedef int ssize_t;		 
+     typedef unsigned short __site_t;	 
+     typedef unsigned short __cnode_t;	 
+     typedef unsigned long clock_t;	 
+      typedef long key_t;		 
+   typedef unsigned short __ushort;	 
+   typedef long	__daddr_t;		 
+   typedef char *__caddr_t;		 
+   typedef long __swblk_t;
+   typedef unsigned char	u_char;	    
+   typedef unsigned short	u_short;    
+   typedef unsigned int		u_int;      
+   typedef unsigned long	u_long;     
+   typedef unsigned int		uint;	    
+   typedef unsigned short	ushort;	    
+   typedef __swblk_t		swblk_t;
+   typedef __daddr_t		daddr_t;
+   typedef __site_t		site_t;
+   typedef __cnode_t		cnode_t;
+     typedef __caddr_t		caddr_t;    
+   typedef long			paddr_t;
+   typedef short		cnt_t;
+   typedef unsigned int		space_t;
+   typedef unsigned int    	prot_t;
+   typedef unsigned long        cdno_t;
+   typedef unsigned short	use_t;
+   typedef struct _physadr { int r[1]; } *physadr;
+   typedef struct _quad { long val[2]; } quad;
+     typedef short cpu_t;
+     typedef struct label_t {
+	int	lbl_rp;
+       	int	lbl_sp;
+       	int	lbl_s[17];
+       	int	lbl_ss[1];
+	double	lbl_sf[4];
+     } label_t;
+   typedef char *dm_message;
+      typedef long	aid_t;
+   typedef pid_t		sid_t;	    
+     typedef long fd_mask;
+     typedef struct fd_set {
+       fd_mask fds_bits[ (((       2048   )+((  (sizeof(fd_mask) * 8)      )-1))/(  (sizeof(fd_mask) * 8)      )) ];
+     } fd_set;
+POINTER malloc  (size_t size )  ;
+POINTER calloc  (size_t n , size_t size )  ;
+void  free  (POINTER c )  ;
+void mem_report  (void )  ;
+typedef  int         BOOLEAN;
+typedef enum
+{
+  eNoErrors			= -1,
+  eUnknownProcessingError       = 0,
+  eAlgorithmFailure		= 100,
+  eAlreadyLocked                = 200,
+  eAttCount			= 300,
+  eAttRedefinition		= 400,
+  eBasicMatrixError		= 500,
+  eBadAddress			= 600,
+  eBadAttribute			= 700,
+  eBadFileNumber		= 800,
+  eBadMode			= 900,
+  eBadVersion			= 1000,
+  eColumnError			= 1100,
+  eConstraintError		= 1200,
+  eLBConstraintError		= 1300,
+  eUBConstraintError		= 1400,
+  eDatabaseError		= 1500,
+  eDataExists			= 1600,
+  eDataNotFound			= 1700,
+  eDictError			= 1800,
+  eDiffAtt			= 1900,
+  eDomain			= 2000,
+  eDuplicateAtt			= 2100,
+  eDuplicateKey			= 2200,
+  eElementMismatch		= 2300,
+  eEmptyAtt			= 2400,
+  eEmptyDict			= 2450,
+  eEmptyLink			= 2500,
+  eEmptyQueue			= 2600,
+  eEmptyStack			= 2700,
+  eEntityExists			= 2800,
+  eEntityNotFound		= 2900,
+  eEtaComputeError		= 3000,
+  eEtaFileError			= 3100,
+  eEtaInverseConsistency	= 3200,
+  eFileExists			= 3300,
+  eFileNotFound			= 3400,
+  eFunctionMismatch		= 3500,
+  eFunctionNotAvailable		= 3600,
+  eFunctionNotFound		= 3700,
+  eFunctionTypeConflict		= 3800,
+  eGraphError			= 3900,
+  eIllegalBMatrixOp		= 4000,
+  eIllegalData			= 4100,
+  eIllegalDeletion		= 4200,
+  eIllegalDictOp		= 4300,
+  eIllegalEtaFileOp		= 4400,
+  eIllegalFunctionRequest	= 4500,
+  eIllegalFunctionType		= 4600,
+  eIllegalGraphOp		= 4700,
+  eIllegalGraphType		= 4800,
+  eIllegalIndex			= 4900,
+  eIllegalInsertion		= 5000,
+  eIllegalListOp		= 5100,
+  eIllegalLPTokenOp		= 5200,
+  eIllegalLPTokenType		= 5300,
+  eIllegalMatrixOp		= 5400,
+  eIllegalMatrixSize		= 5500,
+  eIllegalMatrixState		= 5600,
+  eIllegalMatrixType		= 5700,
+  eIllegalNBMatrixOp		= 5800,
+  eIllegalOperation		= 5900,
+  eIllegalOption		= 6000,
+  eIllegalOverload		= 6100,
+  eIllegalSeek			= 6200,
+  eIllegalType			= 6300,
+  eIllegalVectorOp		= 6400,
+  eIllegalVectorType		= 6500,
+  eIllFormedADT			= 6600,
+  eInconsistentData		= 6700,
+  eInternalError		= 6800,
+  eInUse			= 6900,
+  eInvalidArgument		= 7000,
+  eInvalidAtt			= 7100,
+  eInvalidData			= 7200,
+  eInvalidIndex			= 7300,
+  eInvalidMatrixOp		= 7400,
+  eInvalidOperation		= 7500,
+  eInvalidOption		= 7600,
+  eInvalidParam			= 7700,
+  eInvalidVectorOp		= 7800,
+  eKeyNotFound			= 7900,
+  eLinkNotEmpty			= 8000,
+  eListError			= 8100,
+  eLockAccess			= 8200,
+  eLockExists			= 8300,
+  eLockNotFound			= 8400,
+  eLockReadOnly			= 8500,
+  eLockTrunc			= 8600,
+  eLPTokenError			= 8700,
+  eLPTokenMisuse		= 8800,
+  eMatrixError			= 8900,
+  eMatrixMismatch		= 9000,
+  eMatrixMultiplicationError	= 9100,
+  eMissingData			= 9200,
+  eMysteryError			= 9300,
+  eNameTooLong			= 9400,
+  eNeverLocked			= 9500,
+  eNoAccess			= 9600,
+  eNoLockReq			= 9800,
+  eNoMoreAtt			= 9900,
+  eNoMoreElements		= 10000,
+  eNonBasicMatrixError		= 10100,
+  eNonInvertibleMatrix		= 10200,
+  eNonsenseData			= 10300,
+  eNoSuchKey			= 10400,
+  eNotEnoughSpace		= 10500,
+  eNotFetched			= 10600,
+  eNotLocked			= 10700,
+  eNotSupported			= 10800,
+  eNullPointer			= 10900,
+  eNullInternalPointer		= 11000,
+  eNullCompare			= 11050,
+  eNullData			= 11070,
+  eNullDestroyer		= 11100,
+  eNullDisplayer		= 11200,
+  eNullFunction			= 11300,
+  eRemove			= 11400,
+  eRoundoff			= 11500,
+  eQueueNotEmpty		= 11600,
+  eSparseGraphError		= 11700,
+  eStackError			= 11800,
+  eStackNotEmpty		= 11900,
+  eTLRSProceduralError		= 12000,
+  eTooManyAtt			= 12100,
+  eTooManyLocks			= 12200,
+  eTypeConflict			= 12300,
+  eUnexpectedType		= 12400,
+  eUnixError			= 12500,
+  eVectorMismatch		= 12600,
+  eProcessingError		= 15000, 
+  eActionKludge			= 15100,
+  eNotImplemented		= 15200,
+  eNotStable			= 15300,
+  eNotReleased			= 15400,
+  eBeingWorkedOn		= 15500
+} eErrorState;
+extern "C" {
+extern	eErrorState	spider_errno;
+extern	char		err_string[];
+POINTER mallocate  (size_t n )  ;
+size_t pagesize  (void )  ;
+POINTER page_mallocate  (void )  ;
+POINTER make_memory_token  (int size , int page_cnt, const char *name)  ;
+POINTER mem_malloc  (POINTER mptr )  ;
+void mem_free  (POINTER mptr , POINTER obj )  ;
+const char *get_double_string  (char *buffer , double num )  ;
+int spider_strcat  (const char *proc , char *str1 , const char *str2 , int maxlen )  ;
+void init_errors  (void )  ;
+void append_abort  (const char *proc )  ;
+void append_message  (const char *proc , const char *msg )  ;
+void set_errno  (eErrorState err )  ;
+void spider_perror  (const char *proc , FILE_PTR errorFile )  ;
+void append_not_implemented  (const char *proc , int *target_errno )  ;
+const char *GetBooleanString  (BOOLEAN bool )  ;// ERROR - use of bool as identifier
+double truncate_value  (double x , double epsilon )  ;
+double log2  (double x )  ;
+int ceil_log2  (double x )  ;
+int floor_log2  (double x )  ;
+}
+extern "C" {
+extern  char char80[], char128[], char160[], char512[];
+extern  char char1000[], char2000[];
+extern  char char320[];	 
+BOOLEAN Get_EM_StderrFlag  (void )  ;
+void Set_EM_StderrFlag  (BOOLEAN printToStderr )  ;
+void CheckReleaseState  (eErrorState releaseState , const char *procName, 			  FILE_PTR errorFile )  ;
+void PrintErrorString  (const char *errorString , FILE_PTR errorFile )  ;
+const char *get_error_header  (eErrorState errorState )  ;
+void print_error_header  (eErrorState errorState , FILE_PTR errorFile )  ;
+void PrintErrorMessage  (eErrorState errorState , const char *message , 			  FILE_PTR errorFile )  ;
+}
+extern "C" {
+extern short show_increment_rcount;
+extern int errno;
+extern int bmk_errno;
+extern int ck_errno;
+extern int db_errno;
+extern int dict_errno;
+extern int glh_errno;
+extern int graph_errno;
+extern int hash_errno;
+extern int link_errno;
+extern int lp_errno;
+extern int matrix_errno;
+extern int nbmk_errno;
+extern int network_errno;
+extern int queue_errno;
+extern int set_kernel_errno;
+extern int stack_errno;
+}
+extern "C" {
+const char *spider_version_string  (void )  ;
+int  spider_version  (void )  ;
+const char *spider_errstring  (void )  ;
+void append_perror  (const char *s )  ;
+void unix_perror  (const char *s )  ;
+}
+typedef struct node a_dict_node, * DICT_NODE;
+struct node {
+	POINTER info;		 
+	DICT_NODE left;		 
+	DICT_NODE right;	 
+	DICT_NODE prev;		 
+	DICT_NODE next;		 
+};
+typedef struct tree a_dict, * DICT;
+struct tree {
+	int	  size;			 
+	COMPARE   comp; 		 
+	DICT_NODE header;		 
+	DICT_NODE last_accessed;	 
+	DICT_NODE list_head;		 
+	DICT_NODE list_tail;		 
+};
+typedef enum { PREORDER = -1, INORDER, POSTORDER } traversal_t;
+extern "C" {
+void dict_set_nopages  (int desired_nopages )  ;
+void dict_err  (void )  ;
+const char *traversal_string  (traversal_t tr )  ;
+DICT make_dictionary  (COMPARE cmp )  ;
+int dict_insert  (POINTER item , DICT dict )  ;
+int dict_delete  (POINTER item , DICT dict )  ;
+POINTER dict_access  (POINTER item , DICT dict )  ;
+POINTER dict_low  (DICT dict )  ;
+POINTER dict_nlow  (DICT dict )  ;
+POINTER dict_big  (DICT dict )  ;
+POINTER dict_nbig  (DICT dict )  ;
+POINTER dict_first  (DICT dict )  ;
+POINTER dict_next  (DICT dict )  ;
+POINTER dict_last  (DICT dict )  ;
+POINTER dict_prev  (DICT dict )  ;
+int clear_dictionary  (DICT dict , DESTROYER destroy , FILE *errorFile )  ;
+int dict_size  (const a_dict *dict )  ;
+POINTER dict_elem  (int index , DICT dict )  ;
+int dict_compare  (DICT d1 , DICT d2 )  ;
+DICT dict_copy  (DICT di , COMPARE cmp )  ;
+int dict_change_compare  (DICT di , COMPARE cmp )  ;
+int dict_height  (DICT di )  ;
+void dict_print_stats  (FILE *fp , DICT di )  ;
+void dict_print  (FILE *fp , DICT di , traversal_t tr , DISPLAYER display )  ;
+const char *dict_version  (void )  ;
+void init_dict_errors  (void )  ;
+const char *dict_errstring  (void )  ;
+void dict_append_perror  (const char *s )  ;
+void dict_perror  (const char *s )  ;
+extern int  dict_errno;
+}
+typedef struct q_item {
+  struct q_item *next;
+  POINTER data;
+} a_q_item, *Q_ITEM;
+typedef struct {
+  int rcount;
+  Q_ITEM first;
+  Q_ITEM last;
+  int count;
+} a_queue, *QUEUE;
+extern "C" {
+void queue_err  (void)  ;
+void queue_set_nopages  (int desired_nopages)  ;
+QUEUE make_queue  (void )  ;
+POINTER queue_look  (const a_queue * Q )  ;
+POINTER queue_last  (const a_queue * Q )  ;
+POINTER queue_remove  (QUEUE Q )  ;
+int queue_append  (QUEUE Q , POINTER data )  ;
+int queue_size  (const a_queue * Q )  ;
+void queue_destroy  (POINTER ptr , FILE_PTR errorFile )  ;
+void IncrementQRCount  (POINTER ptr , FILE_PTR errorFile )  ;
+const char *queue_version  (void )  ;
+void init_queue_errors  (void )  ;
+const char *queue_errstring  (void )  ;
+void queue_append_perror  (const char *s )  ;
+void queue_perror  (const char *s )  ;
+extern int queue_errno;
+}
+typedef struct s_item {
+  struct s_item *next;
+  POINTER data;
+} a_s_item, *S_ITEM;
+typedef struct stack {
+  int rcount;
+  S_ITEM top;
+  int count;
+} a_stack, *STACK;
+extern "C" {
+void stack_err  (void)  ;
+void stack_set_nopages  (int desired_nopages)  ;
+STACK make_stack  (void )  ;
+POINTER stack_look  (const a_stack * S )  ;
+POINTER stack_pop  (STACK S )  ;
+int stack_push  (STACK S , POINTER data )  ;
+int stack_size  (const a_stack * S )  ;
+void stack_destroy  (POINTER ptr , FILE_PTR errorFile )  ;
+void IncrementSRCount  (POINTER ptr , FILE_PTR errorFile )  ;
+const char *stack_version  (void )  ;
+void init_stack_errors  (void )  ;
+const char *stack_errstring  (void )  ;
+void stack_append_perror  (const char *s )  ;
+void stack_perror  (const char *s )  ;
+extern int stack_errno;
+}
+typedef const char *(*STRINGER)(const void *ptr);
+int default_compare(const void *p1, const void *p2);
+void default_displayer(const void *ptr, FILE *fp, FILE *errorFile);
+const char *default_stringer(const void *ptr);
+const char *object_stringer(const void *ptr);
+class object {
+	static long current_id;
+	static long next_id();
+protected:
+	void display2(ostream &fp = cout) const;
+	long id;
+public:
+	object()                  { id = next_id(); }
+	object(const object &obj) { id = next_id(); }
+	virtual ~object()
+	{
+		if (799  >=  999 ) cout <<   "~object() executing..."  << '\n'; ;
+	}
+	object & operator = (const object & obj)
+	{
+		return( *this );
+	}
+	virtual int compare(const void *p2) const;
+	virtual void display(ostream & fp = cout) const
+	{
+		display2(fp);
+	}
+	operator char *() const;
+};
+ostream & operator << (ostream & fp, object & obj);
+int operator < (object & obj1, object & obj2);
+int operator <= (object & obj1, object & obj2);
+int operator > (object & obj1, object & obj2);
+int operator >= (object & obj1, object & obj2);
+int operator == (object & obj1, object & obj2);
+int operator != (object & obj1, object & obj2);
+void null_destroy(void *p, FILE *errorFile);
+void object_destroy(void *p, FILE *errorFile);
+int  object_compare(const void *p1, const void *p2);
+void object_display(const void *p, FILE *fp, FILE *errorFile);
+class dict : public object {
+	class internal {
+	public:
+		DICT di;
+		int errno;
+		COMPARE compare_f;
+		DISPLAYER display_f;
+		DESTROYER destroy_f;
+		STRINGER string_f;
+		int count;
+		void append_error(int expr, const char *proc)
+		{
+			if (expr) dict_append_perror(proc);
+			errno = dict_errno;
+		}
+		void obj_error(int expr, const char *proc, const void *obj)
+		{
+			if (expr) {
+				dict_append_perror((*string_f)(obj));
+				dict_append_perror(proc);
+			}
+			errno = dict_errno;
+		}
+		internal(COMPARE cmp, DESTROYER destroyer,
+			 DISPLAYER displayer, STRINGER str_f)
+		{// ERROR - candidate for bad call
+			if (799  >=  800 ) cout <<  "Creating new dictionary..."  << '\n'; ;
+			if (cmp == ((void*)0) )       cmp = &default_compare;
+			if (displayer == ((void*)0) ) displayer = &default_displayer;
+			if (str_f == ((void*)0) )     str_f = &default_stringer;
+			compare_f = cmp;
+			display_f = displayer;
+			destroy_f = destroyer;
+			string_f  = str_f;
+			di = make_dictionary(compare_f);
+			append_error(di == ((void*)0) , "dict internal");
+			if (di == ((void*)0) ) {
+				dict_perror("build dictionary");
+				exit(errno);
+			}
+			count = 1;
+		}
+		~internal()
+		{
+			if (799  >=  800 ) cout <<  "dict ~internal executing"  << '\n'; ;
+			int err = clear_dictionary(di, destroy_f, (&__iob[2]) );
+			append_error(err, "clear dictionary");
+			if (err) dict_perror("dict ~internal");
+			free((void *)di);
+		}
+	};// ERROR - candidate list for bad call
+	internal *rep;
+protected:
+	int & errno()         { return( rep->errno );     }
+	COMPARE compare_f()   { return( rep->compare_f ); }
+	DISPLAYER display_f() { return( rep->display_f ); }
+	DESTROYER destroy_f() { return( rep->destroy_f ); }
+	STRINGER string_f()   { return( rep->string_f  ); }
+	void append_error(int expr, const char *proc)
+	{
+		rep->append_error(expr, proc);
+	}
+	void obj_error(int expr, const char *proc, const void *obj)
+	{
+		rep->obj_error(expr, proc, obj);
+	}
+public:
+	static int err;
+	static int val;
+	static void *p;
+	dict()
+	{
+		if (799  >=  800 ) cout <<  "Default constructor executing..."  << '\n'; ;
+		rep = new internal( &default_compare,   &null_destroy,
+				    &default_displayer, &default_stringer);// ERROR - no matching fn call
+	}
+	dict(COMPARE cmp,
+	     DESTROYER destroyer = ((void*)0) ,
+	     DISPLAYER displayer = &default_displayer,
+	     STRINGER str_f = &default_stringer)
+	{// ERROR - invalid type for default argument -- not expecting const
+		rep = new internal(cmp, destroyer, displayer, str_f);
+	}
+	dict(const dict &di2)
+	{
+		rep = di2.rep;
+		rep->count ++;
+		if (799  >=  800 ) cout <<  "Incrementing count to " << rep->count  << '\n'; ;
+	}
+	dict & operator = (const dict &di2)
+	{
+		di2.rep->count ++;   
+		if (799  >=  800 ) cout <<  "Incrementing di2 count to " << di2.rep->count  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing lvalue count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) {
+			delete rep;
+		}
+		rep = di2.rep;
+		return( *this );
+	}
+	~dict()
+	{
+		if (799  >=  800 ) cout <<  "~dict executing..."  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing dict::internal count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) delete rep;
+	}
+	int insert(POINTER item)
+	{
+		err = dict_insert(item, rep->di);
+		obj_error(err, "insert", item);
+		return errno();
+	}
+	int remove(POINTER item)
+	{
+		err = dict_delete(item, rep->di);
+		obj_error(err, "remove", item);
+		return errno();
+	}
+	POINTER access(POINTER item)
+	{
+		p = dict_access(item, rep->di);
+		obj_error(p == ((void*)0) , "access", item);
+		return(p);
+	}
+	POINTER low()
+	{
+		p = dict_low(rep->di);
+		append_error(p == ((void*)0) , "low");
+		return(p);
+	}
+	POINTER nlow()
+	{
+		p = dict_nlow(rep->di);
+		append_error(p == ((void*)0) , "nlow");
+		return(p);
+	}
+	POINTER big()
+	{
+		p = dict_big(rep->di);
+		append_error(p == ((void*)0) , "big");
+		return(p);
+	}
+	POINTER nbig()
+	{
+		p = dict_nbig(rep->di);
+		append_error(p == ((void*)0) , "nbig");
+		return(p);
+	}
+	POINTER first()
+	{
+		p = dict_first(rep->di);
+		append_error(p == ((void*)0) , "first");
+		return(p);
+	}
+	POINTER last()
+	{
+		p = dict_last(rep->di);
+		append_error(p == ((void*)0) , "last");
+		return(p);
+	}
+	POINTER next()
+	{
+		p = dict_next(rep->di);
+		append_error(p == ((void*)0) , "next");
+		return(p);
+	}
+	POINTER prev()
+	{
+		p = dict_prev(rep->di);
+		append_error(p == ((void*)0) , "prev");
+		return(p);
+	}
+	int clear(DESTROYER destroy, FILE *fp = (&__iob[2]) )
+	{
+		err = clear_dictionary(rep->di, destroy, fp);
+		append_error(err, "clear");
+		return errno();
+	}
+	int clear(FILE *fp = (&__iob[2]) )
+	{
+		err = clear_dictionary(rep->di, rep->destroy_f, fp);
+		append_error(err, "clear");
+		return errno();
+	}
+	int size()
+	{
+		val = dict_size(rep->di);
+		append_error(val < 0, "size");
+		return(val);
+	}
+	POINTER elem(int index)
+	{
+		p = dict_elem(index, rep->di);
+		append_error(p == ((void*)0) , "elem");
+		return(p);
+	}
+	int compare(dict &di2)
+	{
+		val = dict_compare(rep->di, di2.rep->di);
+		return(val);
+	}
+	int height()
+	{
+		val = dict_height(rep->di);
+		append_error(val < 0, "height");
+		return(val);
+	}
+	const char * version()
+	{
+		return( dict_version() );
+	}
+	void display(FILE *fp = (&__iob[1]) )
+	{
+		dict_print_stats(fp, rep->di);
+	}
+	void print(FILE *fp = (&__iob[1]) , traversal_t tr = INORDER)
+	{
+		fprintf(fp, "====== DICTIONARY (count=%d) ======\n",
+			rep->count);
+		dict_print(fp, rep->di, tr, rep->display_f);
+	}
+	void print(traversal_t tr, FILE *fp = (&__iob[1]) )
+	{
+		fprintf(fp, "====== DICTIONARY (count=%d) ======\n",
+			rep->count);
+		dict_print(fp, rep->di, tr, rep->display_f);
+	}
+	void error(const char *s = "class dict")
+	{
+		dict_errno = errno();
+		dict_perror(s);
+		errno() = 0;
+	}
+	void error_append(const char *s = "class dict")
+	{
+		dict_append_perror(s);
+	}
+	const char * errstring()
+	{
+		return( dict_errstring() );
+	}
+};
+ostream & operator << (ostream & fp, traversal_t tr);
+class queue : public object {
+	class internal {
+	public:
+		QUEUE Q;
+		QUEUE Q2;
+		int errno;
+		DISPLAYER display_f;
+		DESTROYER destroy_f;
+		STRINGER string_f;
+		int count;
+		swap()
+		{
+			QUEUE tmp = Q;
+			Q = Q2;
+			Q2 = tmp;
+		}
+		void append_error(int expr, const char *proc)
+		{
+			if (expr) queue_append_perror(proc);
+			errno = queue_errno;
+		}
+		void obj_error(int expr, const char *proc, const void *obj)
+		{
+			if (expr) {
+				queue_append_perror((*string_f)(obj));
+				queue_append_perror(proc);
+			}
+			errno = queue_errno;
+		}
+		internal(DESTROYER destroyer,
+		         DISPLAYER displayer, STRINGER str_f)
+		{// ERROR - candidate for bad call
+			if (799  >=  800 ) cout <<  "Creating new queue..."  << '\n'; ;
+			if (displayer == ((void*)0) ) displayer = &default_displayer;
+			if (str_f == ((void*)0) )     str_f = &default_stringer;
+			display_f = displayer;
+			destroy_f = destroyer;
+			string_f  = str_f;
+			Q = make_queue();
+			append_error(Q == ((void*)0) , "queue internal");
+			errno = queue_errno;
+			if (Q == ((void*)0) ) {
+				queue_perror("build queue");
+				exit(errno);
+			}
+			Q2 = make_queue();
+			append_error(Q2 == ((void*)0) , "queue internal");
+			if (Q2 == ((void*)0) ) {
+				queue_perror("build second queue");
+				exit(errno);
+			}
+			count = 1;
+		}
+		~internal()
+		{
+			if (799  >=  800 ) cout <<  "queue ~internal executing"  << '\n'; ;
+			while ((p = queue_remove(Q)) != ((void*)0) ) {
+				if (destroy_f != ((void*)0) ) {
+					(*destroy_f)((POINTER)&p, (&__iob[2]) );
+				}
+			}
+			queue_errno = 0;
+			queue_destroy((POINTER)&Q, (&__iob[2]) );
+			if (queue_errno) {
+				append_error(queue_errno,
+					     "queue_destroy(Q)");
+				queue_perror("queue ~internal");
+			}
+			queue_errno = 0;
+			queue_destroy((POINTER)&Q2, (&__iob[2]) );
+			if (queue_errno) {
+				append_error(queue_errno,
+					     "queue_destroy(Q2)");
+				queue_perror("queue ~internal");
+			}
+		}
+	};// ERROR - list of candidates for bad call
+	internal *rep;
+protected:
+	int & errno()         { return( rep->errno );     }
+	DISPLAYER display_f() { return( rep->display_f ); }
+	DESTROYER destroy_f() { return( rep->destroy_f ); }
+	STRINGER string_f()   { return( rep->string_f  ); }
+	void append_error(int expr, const char *proc)
+	{
+		rep->append_error(expr, proc);
+	}
+	void obj_error(int expr, const char *proc, const void *obj)
+	{
+		rep->obj_error(expr, proc, obj);
+	}
+public:
+	static int err;
+	static int val;
+	static void *p;
+	queue()
+	{
+		if (799  >=  800 ) cout <<  "Default constructor executing..."  << '\n'; ;
+		rep = new internal( &null_destroy,
+				    &default_displayer, &default_stringer);// ERROR - no matching fn for call
+	}
+	queue(DESTROYER destroyer = ((void*)0) ,
+	      DISPLAYER displayer = &default_displayer,
+	      STRINGER str_f = &default_stringer)
+	{// ERROR - invalid type for default argument -- not expecting const 
+		rep = new internal(destroyer, displayer, str_f);
+	}
+	queue(const queue &Q2)
+	{
+		rep = Q2.rep;
+		rep->count ++;
+		if (799  >=  800 ) cout <<  "Incrementing count to " << rep->count  << '\n'; ;
+	}
+	queue & operator = (const queue &Q2)
+	{
+		Q2.rep->count ++;   
+		if (799  >=  800 ) cout <<  "Incrementing Q2 count to " << Q2.rep->count  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing lvalue count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) {
+			delete rep;
+		}
+		rep = Q2.rep;
+		return( *this );
+	}
+	~queue()
+	{
+		if (799  >=  800 ) cout <<  "~queue executing..."  << '\n'; ;
+		if (799  >=  800 ) cout <<  "Decrementing queue::internal count to " << rep->count-1  << '\n'; ;
+		if (--rep->count <= 0) delete rep;
+	}
+	void error(const char *s = "class queue")
+	{
+		queue_errno = errno();
+		queue_perror(s);
+		errno() = 0;
+	}
+	void error_append(const char *s = "class queue")
+	{
+		queue_append_perror(s);
+	}
+	const char * errstring()
+	{
+		return( queue_errstring() );
+	}
+	int append(POINTER item)
+	{
+		err = queue_append(rep->Q, (POINTER)item);
+		obj_error(err, "append", item);
+		return errno();
+	}
+	POINTER remove()
+	{
+		p = queue_remove(rep->Q);
+		append_error(p == ((void*)0) , "remove");
+		return(p);
+	}
+	POINTER look(POINTER item)
+	{
+		p = queue_look(rep->Q);
+		append_error(p == ((void*)0) , "look");
+		return(p);
+	}
+	POINTER last(POINTER item)
+	{
+		p = queue_last(rep->Q);
+		append_error(p == ((void*)0) , "last");
+		return(p);
+	}
+	int size()
+	{
+		val = queue_size(rep->Q);
+		append_error(val < 0, "size");
+		return(val);
+	}
+	const char * version()
+	{
+		return( queue_version() );
+	}
+	void display(FILE *fp = (&__iob[1]) )
+	{
+		int i = 1;
+		POINTER ptr;
+		fprintf(fp, "====== QUEUE DISPLAY (size %d) ======\n",
+			size());
+		while (ptr = remove()) {
+			err = queue_append(rep->Q2, ptr);
+			if (err) {
+				obj_error(err, "append", ptr);
+				error("queue_append(rep->Q2)");
+			}
+			fprintf(fp, "[%d] ", i++);
+			(*rep->display_f)(ptr, fp, (&__iob[2]) );
+		}
+		rep->swap();
+	}
+};
+long object::current_id = 0;
+long object::next_id()
+{
+	return( ++current_id );
+}
+void object::display2(ostream & fp) const
+{
+	fp << "object #" << id;
+}
+ostream & operator << (ostream & fp, object & obj)
+{
+	obj.display(fp);
+	return(fp);
+}
+int object::compare(const void *p2) const
+{
+	const object & z2 = *(const object *) p2;
+	if (799  >=  1000 ) cout <<  "*** object::compare " << *this << " with " << z2  << '\n'; ;
+	return( id - z2.id );
+}
+int operator < (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) < 0) return(1);
+	else return(0);
+}
+int operator <= (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) <= 0) return(1);
+	else return(0);
+}
+int operator > (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) > 0) return(1);
+	else return(0);
+}
+int operator >= (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) >= 0) return(1);
+	else return(0);
+}
+int operator == (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) == 0) return(1);
+	else return(0);
+}
+int operator != (object & obj1, object & obj2)
+{
+	if (obj1.compare( &obj2 ) != 0) return(1);
+	else return(0);
+}
+void null_destroy(void *p, FILE *errorFile)
+{
+}
+int object_compare(const void *p1, const void *p2)
+{
+	const object *obj1 = (const object *) p1;
+	if (799  >=  1000 ) cout <<   "*** Comparing " << *obj1 << " to address " << long(p2)  << '\n'; ;
+	return( obj1->compare(p2) );
+}
+void object_display(const void *p, FILE *fp, FILE *errorFile)
+{
+	cout << *(object *)p << '\n';
+}
+void object_destroy(void *p, FILE *errorFile)
+{
+	object **pObj = (object **)p;
+	object *obj = *pObj;
+	if (obj == ((void*)0) ) {
+		if (799  >=  10 ) cout <<   "+ object_destroy: NIL object passed in"  << '\n'; ;
+		return;
+	}
+	if (799  >=  998 ) cout <<   "+ object_destroy: delete obj:"  << '\n'; ;
+	if (799  >=  998 ) cout <<   *obj  << '\n'; ;
+	if (799  >=  998 ) cout <<   "===================================================="  << '\n'; ;
+	delete obj;
+	*pObj = ((void*)0) ;
+}
+int default_compare(const void *p1, const void *p2)
+{
+	long L1 = long(p1);
+	long L2 = long(p2);
+	if (799  >=  1000 ) cout <<  "+ default_compare " << long(p1) << ',' << long(p2)  << '\n'; ;
+	if (L1 < L2) return(-1);
+	else if (L1 > L2) return(1);
+	else return(0);
+}
+const char * default_stringer(const void *ptr)
+{
+	static char buf[100];
+	sprintf(buf, "ADDRESS %lu", (unsigned long)ptr);
+	return(buf);
+}
+void default_displayer(const void *ptr, FILE *fp, FILE *errorFile)
+{
+	fprintf(fp, "%s\n", default_stringer(ptr));
+}
+object::operator char *() const
+{
+	const int max = 10;
+	const int maxChar = 16;
+	static char buf[max][maxChar];
+	static int index = 0;
+	char *s = buf[index++ % max];
+	sprintf(s, "object #%d", id);
+	return(s);
+}
+const char * object_stringer(const void *ptr)
+{
+	object & obj = *(object *)ptr;
+	return((char *)obj);
+}
+int dict::err;
+int dict::val;
+POINTER dict::p;
+ostream & operator << (ostream & fp, traversal_t tr)
+{
+	fp << traversal_string(tr);
+	return(fp);
+}
+int queue::err;
+int queue::val;
+POINTER queue::p;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C
new file mode 100644
index 00000000000..ad6e04029cc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// The compiler used to crash on this example.
+
+class x {
+public:
+  x();
+  static const x y[23];
+};
+const x x::y[23];
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C
new file mode 100644
index 00000000000..060be1c39f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash20.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <Complex.h>
+
+Complex ComputeVVself()
+{
+Complex temp1;
+Complex self[3][3];
+
+   self[1][2] = 100.0;
+   return self[1][2];
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C
new file mode 100644
index 00000000000..f7db97d43e9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash22.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct A {
+    void a1();
+    void a2();
+};
+
+struct B {
+    void A::a1(); // this used to die in chainon(), now grokdeclarator should// ERROR -  cannot declare.*
+    void A::a2(); // should be fixed by the 930629 change.// ERROR -  cannot declare.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C
new file mode 100644
index 00000000000..03ffee666a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash23.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// This used to die in chainon; it shouldn't any more.
+
+class A
+{
+public:
+  class B {
+  public:
+    void f ();
+    void g (int);
+  };
+  void B::f () {}// ERROR - .*
+  void B::g (int val) {}// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C
new file mode 100644
index 00000000000..af1c3010229
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash24.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed old-abort
+// gcc puts the array into a register, and then the store_bit_field () code
+// in expmed.c gets confused when it tries to store zero past the end of the
+// register (because the index is past the array bounds).   It ends up calling
+// store_split_bit_field, which then aborts, because we don't have a split bit
+// field.
+//
+// Seems easiest to detect this case in the front end, i.e. access outside the
+// array bounds, and then force the array to be allocated on the stack instead
+// of a register.
+
+main()
+{
+  char i[1];
+
+  i[1] = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C
new file mode 100644
index 00000000000..625eaf84707
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash25.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class memo{
+public:
+	static int rep;
+};
+
+class port_head : public memo {
+public:
+	static 	int rep;
+	unsigned cap();
+};
+
+class buff_head : private port_head {
+public:
+	static int rep;
+	port_head::cap;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C
new file mode 100644
index 00000000000..9b6643debe4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash26.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct B {
+    B();
+};
+ 
+class C : virtual public B
+{
+  public:
+    C() { }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C
new file mode 100644
index 00000000000..62acbe03e19
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash27.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class First {
+public:
+  First(const First& a);
+};
+
+class Second {
+  int i;
+  First f;
+public:
+  ~Second() {}
+  Second func();
+};
+
+void foo()
+{
+  extern Second x;
+  x = x.func();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C
new file mode 100644
index 00000000000..08adee9308a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash28.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+    class abc
+    {
+     public: 
+      void F()       { return; }
+
+     private:
+      typedef int myint;
+      typedef struct { int b; } mystruct;
+      typedef union  { int c; } myunion;
+    };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C
new file mode 100644
index 00000000000..855dd990be1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash29.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed old-abort
+
+union Value
+{
+	Value(){}
+};
+
+struct GlobalAddress
+{
+	GlobalAddress(Value *nvar){}// ERROR - .*
+};// ERROR -  candidates .*
+
+main()
+{
+	new GlobalAddress(Value());		// internal error occured here// ERROR -  no matching function .*
+	//new GlobalAddress(new Value());	// This line is correct code
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C
new file mode 100644
index 00000000000..b3b8354b543
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash3.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed old-abort
+int	strcmp();
+
+extern "C" {
+      // dies in common_type, cuz the TREE_TYPE of t2 is 0, so it can't get its
+      // TYPE_MAIN_VARIANT value.
+      // <void_type 184510 void permanent VOID
+      //  size <integer_cst 1844e0 type <integer_type 182548 int> constant permanent 0
+      //    align 1 symtab 0
+      //    pointer_to_this <pointer_type 1845e0>
+
+int       strcmp(const char*, const char*);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C
new file mode 100644
index 00000000000..ac73525536e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash30.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <String.h>
+
+main(void) {
+
+  String a[] = {"Hello"};
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C
new file mode 100644
index 00000000000..d5b7e541e8a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash31.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct mbuf {
+	struct mbuf *next;
+};
+
+void* malloc(int);
+struct mbuf *
+mbuf_allocate(int size)
+{
+    struct mbuf *bp;
+
+    bp = (struct mbuf *) malloc( 10 /*(unsigned) (size + sizeof(struct mbuf))*/);
+    return bp;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C
new file mode 100644
index 00000000000..ebca5a4f6fa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash32.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed old-abort
+enum Bool { FALSE, TRUE };
+Bool foo () { return TRUE; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C
new file mode 100644
index 00000000000..061f5a91794
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash33.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed old-abort
+extern void foo(void *);
+main() {
+	foo((struct bar *)0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C
new file mode 100644
index 00000000000..a147b6219df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash34.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+operator int () {}// ERROR - .*// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C
new file mode 100644
index 00000000000..e32b7c13b59
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash35.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed old-abort
+const unsigned int ENET_INTERRUPT_MID = 5;
+
+extern "C" void ENET_RxP();
+
+class EnetReceiver
+    {
+    public:
+        friend void ENET_RxP();
+        void  receiveMessage();
+        int *messagePointer;
+    };
+
+void EnetReceiver::receiveMessage()
+    {
+    if (*((unsigned int*) messagePointer) == ENET_INTERRUPT_MID)
+        {
+        }
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C
new file mode 100644
index 00000000000..10534535405
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash36.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct wait { int w_status; };
+int wait();
+extern "C" int wait(int*);
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C
new file mode 100644
index 00000000000..18eb64a7683
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash37.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef int _sigset_t;
+extern "C" {
+        extern int sigaction(int signo, const struct sigaction *action_spec_p, struct sigaction *old_action_p);
+}
+extern "C" {
+        extern void foo();
+};
+class SS {
+        friend void foo();
+protected:
+        void goo();
+};
+inline void
+SS::goo() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C
new file mode 100644
index 00000000000..d124c21e4a9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash38.C
@@ -0,0 +1,42 @@
+// Build don't link: 
+// GROUPS passed old-abort
+/*
+   I received the following message when using g++ (version 2.3.3):
+
+   main.cc: In method 'Implicit<implicit<INTEGER,2>,3>::Implicit()':
+   main.cc: Internal compiler error 241.
+   main.cc: Please report this to 'bug-g++@prep.ai.mit.edu'
+   */
+
+#include <stream.h>
+
+class INTEGER {
+int x;
+public:
+   typedef int BASE;
+   INTEGER(int y) : x(y) {}
+   INTEGER() {}
+   void encode() { cout << "Integer encoder";}
+   int operator=(int y) { x=y; return x; }
+   operator int() {return x; }
+};
+
+template< class T,  int n> class Implicit : public T {
+   public:
+     typedef typename T::BASE BASE;
+     Implicit(BASE value ): T(value) {};
+     Implicit() : T() {};
+     int myTag() { return n; }
+     void encode() { T::encode(); }
+     BASE operator=(BASE t) { return T::operator=(t); }
+};
+
+main() 
+{
+  Implicit<Implicit<INTEGER, 2> ,  3> y;
+
+  y = 10;
+};
+
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C
new file mode 100644
index 00000000000..f267abd6147
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash39.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed old-abort
+#include <GetOpt.h>
+#include <String.h>
+class foo {public: foo () {}};
+class bar {public: bar (foo& dflt);};
+class baz: public bar {public: baz (): bar (foo ()) {}};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C
new file mode 100644
index 00000000000..1f8a3ffc532
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash4.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef struct Thing {
+		Thing();
+	int	x;
+} Thing;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C
new file mode 100644
index 00000000000..dcebfbebade
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash40.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class foo {
+
+public:
+
+	virtual foo &operator <<(foo &(foo::*)(foo &));
+};
+
+
+foo &foo::operator<<(foo &(foo::*manip)(foo &))
+{
+ 
+   (this->*manip)(*this);
+ 
+   return *this;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C
new file mode 100644
index 00000000000..5d533b866e2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash41.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef void (**ppfn)(void);
+
+int main() {
+    ppfn fn;
+
+    fn = new (void(*)(void));
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C
new file mode 100644
index 00000000000..1b92f5d858d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash42.C
@@ -0,0 +1,6 @@
+// GROUPS passed old-abort
+// Build don't link: 
+int fn();// ERROR -  ambiguates.*
+int x;
+int& fn() {// ERROR -  new decl.*
+return x;}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C
new file mode 100644
index 00000000000..5fe54231c89
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash43.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// Special g++ Options: -g -fno-strict-prototype
+// GROUPS passed old-abort
+// excess errors test - XFAIL sparc64-*-elf
+extern "C" { typedef int jmp_buf[12]; }
+
+enum Error { NO_ERROR };
+class ErrorHandler
+{
+    ErrorHandler *previous;
+    static ErrorHandler *error_stack;
+    jmp_buf error_buffer;
+protected:
+    static void pop()
+    {
+	error_stack = error_stack->previous;
+    }
+public:
+    jmp_buf *push()
+    {
+	previous = error_stack;
+	error_stack = this;
+	return &error_buffer;
+    }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C
new file mode 100644
index 00000000000..dd356190913
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash44.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed old-abort
+template <class T> class bug {
+
+public:
+    void		Foo(const int = 0);
+    void		NotRedeclared(const int);
+
+private:
+	T		TheItem;
+};
+
+template <class T> void bug<T>::NotRedeclared(const int)
+{
+}
+
+template <class T> void bug<T>::Foo(const int)
+{
+}
+
+main()
+{
+	bug<char>	InstantiatedBug;
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C
new file mode 100644
index 00000000000..269a51908b2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash45.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+void foo() { static const char *const v[] = { 0 }; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C
new file mode 100644
index 00000000000..64d8d59ce21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash46.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class Rational {
+public:
+    Rational(int v): value(v)
+	{  }
+
+    int value;
+};
+typedef Rational __Rational;
+
+extern int operator>(const Rational&, const Rational&);
+
+class V {
+public:
+    class Rational {
+    public:
+	static int x(const __Rational& value);
+    };
+};
+
+int
+V::Rational::x(const __Rational& value)
+{
+    return value > 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C
new file mode 100644
index 00000000000..daf2bd8b74b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash47.C
@@ -0,0 +1,93 @@
+// Build don't link: 
+// GROUPS passed old-abort
+const int TRUE = 1;
+const int FALSE = 0;
+
+class Rep {
+protected:
+    Rep(): count(0)
+	{ }
+    Rep(const Rep& other): count(0)
+	{ }
+
+    Rep& operator=(const Rep& other)
+	{ /* DO NOT copy over other.count */
+	  return *this; }
+
+public:		// TODO - for now
+    // Because it is to hard to restrict these operations to the descendants
+    // of Rep<REP> that we haven't named yet.  So we just make them public.
+    void inc()
+	{ count++; }
+    void dec()
+	{ if (0 == --count) delete this; }
+private:
+    unsigned count;
+};
+
+template<class REP>
+class Ref {
+public:
+    Ref(): rep(0)
+	{ }
+    Ref(const Ref<REP>& other): rep(other.rep)
+	{ if (rep) rep->inc(); }
+    ~Ref()
+	{ if (rep) rep->dec();
+	  rep = 0; }
+
+    Ref<REP>& operator=(const Ref<REP>& other)
+	{ if (rep != other.rep) {
+	    if (rep) rep->dec();
+	    rep = other.rep;
+	    if (rep) rep->inc(); }
+	  return *this; }
+
+    bool null() const
+	{ return 0 == rep ? TRUE: FALSE; }
+    bool valid() const
+	{ return 0 != rep ? TRUE: FALSE; }
+
+    REP* operator->() const		// should be a valid() reference
+	{ return rep; }
+    operator REP*() const;		// should be a valid() reference
+
+protected:
+    REP *rep;
+
+    Ref(REP *r): rep(r)
+	{ if (rep) rep->inc(); }
+
+    Ref<REP>& operator=(REP *r)
+	{ if (rep != r) {
+	    if (rep) rep->dec();
+	    rep = r;
+	    if (rep) rep->inc(); }
+	  return *this; }
+};
+
+template<class REP>
+Ref<REP>::operator REP*() const		// should be a valid() reference
+{ return rep; }
+
+template<class REP> 
+inline int
+operator==(const Ref<REP>& a, const Ref<REP>& b)
+{ return (REP *) a == (REP *) b; }
+
+template<class REP> 
+inline int
+operator!=(const Ref<REP>& a, const Ref<REP>& b)
+{ return (REP *) a != (REP *) b; }
+
+class XRep: public Rep {
+public:
+    int i;
+};
+
+main()
+{
+    Ref<XRep> y;
+
+    return y != y;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C
new file mode 100644
index 00000000000..20882a80a53
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash48.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class internal {
+	int field;
+	int anotherfield;
+}; // ERROR - candidates are
+
+class bug {
+	internal* numbers;
+	bug(int size);
+}; // ERROR - several errors
+
+bug::bug(int size)
+{ // ERROR - candidates
+	numbers = new internal(size * size);// ERROR -  no match.*
+}
+
+main()
+{
+	bug test;// ERROR -  no match
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C
new file mode 100644
index 00000000000..5a8e11f4a42
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash49.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include<iostream.h>
+
+const /* int */ keys = 10;
+const /* int */ key[keys] = {6, key[1], 2, keys, 1, 7, 6, key[2], key[8]};
+
+void main()
+{ // ERROR - return type for main
+        for(int i = 0; i < keys;) cout << key[i++] << " ";
+        endl(cout);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C
new file mode 100644
index 00000000000..d884189f6b8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash5.C
@@ -0,0 +1,106 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// Should have been fixed by:
+//
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+// 
+// 	* cp-cvt.c (build_default_binary_type_conversion): Look deeper into
+// 	what ARG1 and ARG2 are if they're POINTER_TYPEs.
+
+volatile void exit(int);
+
+class CountableSet
+{
+	public:
+		virtual	~CountableSet() { }		
+};	
+
+template<class T>
+class FixedSet : virtual public CountableSet
+{
+	public:
+		virtual	int Get(int, T&) = 0;		 
+		virtual	~FixedSet() { }		
+};
+
+class ShrinkableSet
+{
+	public:
+		virtual int Remove(int) = 0;   
+};
+
+template<class T>
+class PVSet : virtual public FixedSet<T>, virtual public ShrinkableSet
+{
+	public:
+		virtual	void Append(const T&) = 0;
+		virtual	void operator+=(const T& a) { Append(a); }
+		virtual	~PVSet() { }		
+};
+
+template<class T>
+class MutSet : virtual public FixedSet<T>, virtual public FixedSet<T *>
+{
+	protected:
+		typedef	T	*Tp;
+
+	public:
+		void Append(const Tp& tp) { Append(*tp); }
+
+		T&	Access(int p)
+		{
+			Tp	tp;
+			Get(p, tp);
+			return *tp;
+		}
+		virtual	~MutSet() { }		
+};
+
+template <class T>
+class	SimpleSet : virtual public MutSet<T>
+{
+	protected:
+		T	*array;
+		int	size;
+
+		virtual	void	Allocate(int s)
+		{
+			array = new T[s];
+		}
+	public:
+		SimpleSet()
+		{
+			size = 0;
+			array = ((void*)0) ; // ERROR - implicit conversion
+		}
+ 		int	Get(int p, T& t)
+		{
+			t = array[p-1];
+			return 1;
+		}
+		int	Get(int p, T *& t)
+		{
+			t = &array[p-1];
+			return 1;
+		}
+		inline void Append(const T& a)
+		{
+			array[size-1] = a;
+		}
+		inline int Remove(int n) { return 0; }
+};
+
+class	Dummy
+{
+	public:
+		Dummy()	{}
+};
+
+main()
+{
+	SimpleSet<Dummy *>		bs1;
+	int	i, j;
+	Dummy	foo;
+
+	bs1+=&foo;// ERROR -  no .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C
new file mode 100644
index 00000000000..58695a2a330
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash50.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class B
+        {
+public:
+        int i;
+        };
+int operator & (const B &s) { return ( s.i  );};
+
+
+
+
+
+class C
+        {
+public:
+        C &operator = (const C &x)
+                {
+                return *this;
+                };
+        };
+
+C &(C::*DD)(const C &x) = &C::operator=;
+
+main()
+{
+        &DD;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C
new file mode 100644
index 00000000000..3586eb425f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash51.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class obj;
+
+typedef obj *obj_t;
+
+class obj {
+public:
+    obj( const obj& o );
+};   
+
+extern obj nowhere;
+
+class set: public obj {
+    unsigned  bit_vector;
+public:
+    set( const obj& o );
+    set&      operator|=( const int q );
+};   
+
+enum pin_enum { E_F, O_C, O_D, O_S, P_D, P_U, R, T, A, C };
+
+set t_q = ( ( ( ( ( ( set( nowhere ) |= E_F ) |= O_C ) |= O_D ) |= O_S )
+              |= P_U ) |= P_D ) |= T;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C
new file mode 100644
index 00000000000..d10afdcc43d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash52.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+class A {
+public:
+  friend A f(A &a);// ERROR -  ambiguates.*
+};
+
+A &f(A &a) {// ERROR -  new decl.*
+  cout << "Blah\n";
+} // ERROR - non-void function
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C
new file mode 100644
index 00000000000..163f8e6ced7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash53.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class A
+{
+  public:
+    class B
+    {
+      public:
+        virtual ~B();
+    };
+};
+
+template<int I>
+class C
+{
+  public:
+    class B
+    : public A::B
+    {
+    }; // bug2.cc:18: Internal compiler error 233.
+       // bug2.cc:18: Please submit a full bug report to `bug-g++@prep.ai.mit.edu'.
+};
+
+C<0> c;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C
new file mode 100644
index 00000000000..0b85fa1cc00
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash54.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed old-abort
+main()
+{
+    int a[100], **p;
+
+    p = &a[50];// ERROR -  assignment to.*
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C
new file mode 100644
index 00000000000..47a74249ef6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash55.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+      extern f(int);// ERROR -  ambiguates.*
+
+      int& f(int x)
+      {// ERROR -  new declaration.*
+          int local;// ERROR -  warning
+
+          local = x+2;
+      
+          return local;
+      }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C
new file mode 100644
index 00000000000..7b470678a78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash56.C
@@ -0,0 +1,383 @@
+// Build don't link: 
+// GROUPS passed old-abort
+const bool FALSE = 0;
+const bool TRUE = 1;
+class ListDProto {
+public:
+    ListDProto();
+    ListDProto(const ListDProto&);
+    virtual ~ListDProto();
+    void operator=(const ListDProto&);
+    unsigned length() const;
+    bool empty() const;
+    void clear();
+    void remove_head();
+    void remove_tail();
+    class link;
+    class Vix {
+    public:
+	Vix();
+	friend int operator==(void *v, const Vix& x)
+	    { return v == x.item; }// ERROR - list of candidates
+	friend int operator==(const Vix& x, void *v)
+	    { return v == x.item; }// ERROR - candidate for call
+	friend int operator!=(void *v, const Vix& x)
+	    { return v != x.item; }
+	friend int operator!=(const Vix& x, void *v)
+	    { return v != x.item; }
+	friend int operator==(const Vix& x1, const Vix& x2)
+	    { return x1.owner == x2.owner && x1.item == x2.item; }// ERROR - candidate for call
+	friend int operator!=(const Vix& x1, const Vix& x2)
+	    { return x1.owner != x2.owner || x1.item != x2.item; }
+	bool first;		 
+	bool last;		 
+    protected:
+        friend class ListDProto;
+	Vix(const ListDProto *o, link *i);
+	const ListDProto *owner;
+    private:
+	link *item;
+    };
+    enum Action { NORMAL, REMOVE_CURRENT };
+    Vix first() const;
+    void first(Vix& x) const;
+    void next(Vix& x) const;// ERROR - candidate for call
+    void next(Vix& x, Action a = NORMAL);// ERROR - list of candidates
+    Vix last() const;
+    void last(Vix& x) const;
+    void prev(Vix& x) const;
+    void prev(Vix& x, Action a = NORMAL);
+protected:
+    struct link {
+	link *next;
+	link *prev;
+	link(link *n = 0, link *p = 0);
+	virtual ~link();
+    private:
+	link(const link&);
+	void operator=(const link&);
+    };
+    unsigned count;
+    link *list_head;		 
+    link *list_tail;		 
+    virtual link *copy_item(link *old_item) const = 0;
+    void prepend(link *item);
+    void append(link *item);
+    void prepend(const ListDProto& proto);
+    void append(const ListDProto& proto);
+    void remove(link *item);
+    link *ref(const Vix&) const;
+};
+template<class T>
+class ListD: public ListDProto {
+public:
+    void prepend(const T& item);
+    void append(const T& item);
+    const T& head() const;
+    T& head();
+    void head(T& fill) const;
+    void remove_head()
+	{ ListDProto::remove_head(); }
+    void remove_head(T& fill);
+    const T& tail() const;
+    T& tail();
+    void tail(T& fill) const;
+    void remove_tail()
+	{ ListDProto::remove_tail(); }
+    void remove_tail(T& fill);
+    class Vix: public ListDProto::Vix {
+    public:
+	Vix(): ListDProto::Vix()
+	    { }
+    protected:
+        friend class ListD<T>;
+	Vix(const ListDProto::Vix& x): ListDProto::Vix(x)
+	    { }
+    };
+    Vix first() const
+	{ return ListDProto::first(); };
+    void first(Vix& x) const
+	{ ListDProto::first(x); };
+    void next(Vix& x, ListDProto::Action a = NORMAL) const
+	{ ListDProto::next(x, a); }// ERROR - .*// ERROR - .*
+    Vix last() const
+	{ return ListDProto::last(); }
+    void last(Vix& x) const
+	{ return ListDProto::last(x); }
+    void prev(Vix& x, ListDProto::Action a = NORMAL) const
+	{ return ListDProto::prev(x, a); }
+protected:
+    struct link_item: public ListDProto::link {
+	T item;
+	link_item(const T& i): link(0, 0), item(i)
+	    { }
+    private:
+	link_item(const link_item&);
+	void operator=(const link_item&);
+    };
+public:
+    T& operator()(const Vix& x)
+	{ link_item *li = (link_item *) ref(x);
+	  return li->item; }
+    const T& operator()(const Vix& x) const
+	{ link_item *li = (link_item *) ref(x);
+	  return li->item; }
+private:
+    ListDProto::link *copy_item(ListDProto::link *old_item) const;
+};
+template<class T>
+class SetLD: private ListD<T> {
+public:
+    SetLD();			 
+    SetLD(const ListD<T>&);	 
+    void add(const T& item);
+    void add(const ListD<T>& other);
+    void add(const SetLD<T>& other);
+    void remove(const T& item);
+    bool contains(const T& item) const;
+    ListD<T>::length;
+    ListD<T>::empty;
+    ListD<T>::clear;
+    typedef ListD<T>::Vix Vix;
+    ListD<T>::first;
+    ListD<T>::next;
+    ListD<T>::operator();
+};
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+template<class T>
+void
+ListD<T>::prepend(const T& item)
+{
+    link *newl = new link_item(item);
+    ListDProto::prepend(newl);
+}
+template<class T>
+void
+ListD<T>::append(const T& item)
+{
+    link *newl = new link_item(item); 
+    ListDProto::append(newl);
+}
+template<class T>
+const T&
+ListD<T>::head() const
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   50 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    return h->item;
+}
+template<class T>
+T&
+ListD<T>::head()
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   59 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    return h->item;
+}
+template<class T>
+void
+ListD<T>::head(T& fill) const
+{
+    ((void) (( 0 != list_head ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   68 ,  "0 != list_head" ), 0) )) ;
+    link_item *h = (link_item *) list_head;
+    fill = h->item;
+}
+template<class T>
+void
+ListD<T>::remove_head(T& fill)
+{
+    head(fill);
+    remove_head();
+}
+template<class T>
+const T&
+ListD<T>::tail() const
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   85 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    return h->item;
+}
+template<class T>
+T&
+ListD<T>::tail()
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   94 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    return h->item;
+}
+template<class T>
+void
+ListD<T>::tail(T& fill) const
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   103 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    fill = h->item;
+}
+template<class T>
+void
+ListD<T>::remove_tail(T& fill)
+{
+    ((void) (( 0 != list_tail ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",	  "/home/wbaker/work/include/templates/ListD.body.h" ,   112 ,  "0 != list_tail" ), 0) )) ;
+    link_item *h = (link_item *) list_tail;
+    fill = h->item;
+}
+template<class T>
+ListDProto::link *
+ListD<T>::copy_item(ListDProto::link *old) const
+{
+    link_item *old_item = (link_item *) old;
+    link_item *new_item = new link_item(old_item->item);
+    return new_item;
+}
+template<class T>
+SetLD<T>::SetLD():
+ListD<T>()
+{ }
+template<class T>
+SetLD<T>::SetLD(const ListD<T>& other):
+ListD<T>(other)
+{ }
+template<class T>
+void
+SetLD<T>::add(const T& item)
+{
+    if ( ! contains(item) )
+	append(item);
+}
+template<class T>
+void
+SetLD<T>::add(const ListD<T>& other)
+{
+    ListD<T>::Vix x;
+    for (first(x); 0 != x; next(x))
+	add(other(x));
+}
+template<class T>
+void
+SetLD<T>::add(const SetLD<T>& other)
+{
+    const ListD<T>& lother = other;
+    add(lother);
+}
+template<class T>
+void
+SetLD<T>::remove(const T& item)
+{
+    Action a = NORMAL;
+    Vix x;
+    for (first(x); 0 != x && REMOVE_CURRENT != a; next(x, a))
+	a = operator()(x) == item ? REMOVE_CURRENT: NORMAL;// ERROR - .*
+}
+template<class T>
+bool
+SetLD<T>::contains(const T& item) const
+{
+    Vix x;
+    for (first(x); 0 != x; next(x)) {
+	if (operator()(x) == item)// ERROR - .*
+	    return TRUE;
+    }
+    return FALSE;
+}
+template<class T>
+int
+operator==(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() != b.length())
+	return FALSE;
+    SetLD<T>::Vix x;
+    for (a.first(x); 0 != x; a.next(x)) {
+	if ( ! b.contains(a(x)) )
+	    return FALSE;
+    }
+    for (b.first(x); 0 != x; b.next(x)) {
+	if ( ! a.contains(b(x)) )
+	    return FALSE;
+    }
+    return TRUE;
+}
+template<class T>
+int
+operator!=(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a == b); }
+template<class T>
+int
+operator<=(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() > b.length())
+	return FALSE;
+    SetLD<T>::Vix x;
+    for (x=a.first(); 0 != x; a.next(x)) {
+	if ( ! b.contains(a(x)) )
+	    return FALSE;
+    }
+    return TRUE;
+}
+template<class T>
+int
+operator<(const SetLD<T>& a, const SetLD<T>& b)
+{
+    if (a.length() >= b.length())
+	return FALSE;
+    return a <= b;
+}
+template<class T>
+int
+operator>(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a <= b); }
+template<class T>
+int
+operator>=(const SetLD<T>& a, const SetLD<T>& b)
+{ return ! (a < b); }
+class String { };
+class IcaseString: public String { };
+class SetLD< IcaseString >: public SetLD<    String  > {	public:	 SetLD (): SetLD<    String  >() { };	 SetLD (const ListD<   IcaseString  >& other): SetLD<    String  >()	{ ListD<   IcaseString  >::Vix x;	for (other.first(x); 0 != x; other.next(x))	add(other(x)); };	 SetLD (const  SetLD & other): SetLD<    String  >(other) { };	const    IcaseString  & operator()(const Vix& x) const	{ return (   IcaseString  &) SetLD<    String  >::operator()(x); }	}; 	typedef SetLD<  String > SetLD_String_IcaseString_old_tmp99;	typedef SetLD< IcaseString > SetLD_String_IcaseString_new_tmp99;	
+inline int	 operator== (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{// ERROR - candidate for call
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator== (oa, ob);	} 	
+inline int	 operator!= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator!= (oa, ob);	} 	
+inline int	 operator< (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator< (oa, ob);	} 	
+inline int	 operator<= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator<= (oa, ob);	} 	
+inline int	 operator> (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator> (oa, ob);	} 	
+inline int	 operator>= (const SetLD_String_IcaseString_new_tmp99& a,	const SetLD_String_IcaseString_new_tmp99& b)
+{
+const SetLD_String_IcaseString_old_tmp99& oa = a;
+const SetLD_String_IcaseString_old_tmp99& ob = b;
+return  operator>= (oa, ob);	}   ;
+typedef SetLD<IcaseString> SLDiS;
+static void
+nop(int i)
+{
+    SetLD<IcaseString> x, y;
+    nop(x == y);
+ nop(x != y);
+nop(x < y);
+nop(x <= y);
+nop(x > y);
+nop(x >= y);
+}
+
+template class SetLD<String>;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C
new file mode 100644
index 00000000000..48014c56892
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash57.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class foo {
+private:
+  char buffer[1024];
+public:
+  foo();
+};
+
+main()
+{
+  static foo& a = *(new foo);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C
new file mode 100644
index 00000000000..922290f000c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash58.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X {
+public:
+void doit();
+};
+
+X::::doit()// ERROR -  (syntax|parse) error.*
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C
new file mode 100644
index 00000000000..ab6e5599d6a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash59.C
@@ -0,0 +1,1374 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed old-abort
+typedef char * __gnuc_va_list;
+void va_end (__gnuc_va_list);		 
+enum __va_type_classes {
+  __no_type_class = -1,
+  __void_type_class,
+  __integer_type_class,
+  __char_type_class,
+  __enumeral_type_class,
+  __boolean_type_class,
+  __pointer_type_class,
+  __reference_type_class,
+  __offset_type_class,
+  __real_type_class,
+  __complex_type_class,
+  __function_type_class,
+  __method_type_class,
+  __record_type_class,
+  __union_type_class,
+  __array_type_class,
+  __string_type_class,
+  __set_type_class,
+  __file_type_class,
+  __lang_type_class
+};
+typedef __gnuc_va_list va_list;
+typedef	int jmp_buf[9 ];
+typedef	int sigjmp_buf[9 +1];
+int	setjmp  (jmp_buf)  ;
+int	_setjmp  (jmp_buf)  ;
+int	sigsetjmp  (sigjmp_buf, int)  ;
+void	longjmp  (jmp_buf, int)  ;
+void	_longjmp  (jmp_buf, int)  ;
+void	siglongjmp  (sigjmp_buf, int)  ;
+const int BOR_C_DIR	= 0;		 
+const int BOR_C_REV	= 1;		 
+const int BOR_C		= 0x1;
+const int BOR_BD_DIR	= (0<<1);	 
+const int BOR_BD_REV	= (1<<1);	 
+const int BOR_BD	= 0x2;
+const int SERVICE_DATA	 = (1<<( 0 )) ;	 
+const int SERVICE_CLASS1 = (1<<( 1 )) ;	 
+const int SERVICE_CLASS2 = (1<<( 2 )) ;	 
+const int SERVICE_CLASS20 = (1<<( 3 )) ;	 
+const int SERVICE_VOICE	 = (1<<( 8 )) ;	 
+const int SERVICE_ALL	 = (1<<( 9 )) -1;
+const int VR_NORMAL	= 0;		 
+const int VR_FINE	= 1;		 
+const int VR_ALL	= (1<<( VR_FINE+1 )) -1;
+const int BR_2400	= 0;		 
+const int BR_4800	= 1;		 
+const int BR_7200	= 2;		 
+const int BR_9600	= 3;		 
+const int BR_12000	= 4;		 
+const int BR_14400	= 5;		 
+const int BR_ALL	= (1<<( BR_14400+1 )) -1;
+const int WD_1728	= 0;		 
+const int WD_2048	= 1;		 
+const int WD_2432	= 2;		 
+const int WD_1216	= 3;		 
+const int WD_864	= 4;		 
+const int WD_ALL	= (1<<( WD_864+1 )) -1;
+const int LN_A4		= 0;		 
+const int LN_B4		= 1;		 
+const int LN_INF	= 2;		 
+const int LN_ALL	= (1<<( LN_INF+1 )) -1;
+const int DF_1DMR	= 0;		 
+const int DF_2DMR	= 1;		 
+const int DF_2DMRUNCOMP	= 2;		 
+const int DF_2DMMR	= 3;		 
+const int DF_ALL	= (1<<( DF_2DMMR+1 )) -1;
+const int EC_DISABLE	= 0;		 
+const int EC_ENABLE	= 1;		 
+const int EC_ALL	= 0x3;
+const int BF_DISABLE	= 0;		 
+const int BF_ENABLE	= 1;		 
+const int BF_ALL	= 0x3;
+const int ST_0MS	= 0;		 
+const int ST_5MS	= 1;		 
+const int ST_10MS2	= 2;		 
+const int ST_10MS	= 3;		 
+const int ST_20MS2	= 4;		 
+const int ST_20MS	= 5;		 
+const int ST_40MS2	= 6;		 
+const int ST_40MS	= 7;		 
+const int ST_ALL	= (1<<( ST_40MS+1 )) -1;
+const int PPM_MPS	= 0;		 
+const int PPM_EOM	= 1;		 
+const int PPM_EOP	= 2;		 
+const int PPM_PRI_MPS	= 4;		 
+const int PPM_PRI_EOM	= 5;		 
+const int PPM_PRI_EOP	= 6;		 
+const int PPR_MCF	= 1;		 
+const int PPR_RTN	= 2;		 
+const int PPR_RTP	= 3;		 
+const int PPR_PIN	= 4;		 
+const int PPR_PIP	= 5;		 
+const int DLE = 16;		 
+const int SUB = 26;		 
+const int ETX = 3;		 
+const int DC1 = 17;		 
+const int DC2 = 18;		 
+const int CAN = 24;		 
+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 __SIZE_TYPE__ size_t;		 
+typedef int ptrdiff_t;	 
+typedef __wchar_t wchar_t;	 
+extern unsigned int _mb_cur_max;
+extern void	abort( );
+extern int	abs  (int)  ;
+extern double	atof  (const char *)  ;
+extern int	atoi  (const char *)  ;
+extern long int	atol  (const char *)  ;
+extern char *	bsearch  (const void *, const void *, long unsigned int , long unsigned int , int (*) (const void *, const void *))  ;
+extern void *	calloc  (long unsigned int , long unsigned int )  ;
+extern void	exit  (int)  ;
+extern void	free  (void *)  ;
+extern char *	getenv  (const char *)  ;
+extern void *	malloc  (long unsigned int )  ;
+extern int	qsort  (void *, long unsigned int , long unsigned int , int (*) (const void *, const void *))  ;
+extern int	rand( );
+extern void *	realloc  (void *, long unsigned int )  ;
+extern int	srand  (unsigned int)  ;
+extern int    mbtowc  (__wchar_t *, const char *, long unsigned int )  ;
+extern int    wctomb  (char *, __wchar_t )  ;
+extern size_t mbstowcs  (__wchar_t *, const char *, long unsigned int )  ;
+extern size_t wcstombs  (char *, const __wchar_t *, long unsigned int )  ;
+extern int atexit (void (*) (void));
+extern long int labs (long int);
+extern int putenv (char *);
+extern double strtod (const char *, char **);
+extern long int strtol (const char *, char **, int);
+extern long unsigned int strtoul (const char *, char **, int);
+extern int system (const char *);
+extern char *	strcat  (char *, const char *)  ;
+extern char *	strchr  (const char *, int)  ;
+extern int	strcmp  (const char *, const char *)  ;
+extern char *	strcpy  (char *, const char *)  ;
+extern size_t	strcspn  (const char *, const char *)  ;
+extern char *	strdup  (const char *)  ;
+extern size_t	strlen  (const char *)  ;
+extern char *	strncat  (char *, const char *, long unsigned int )  ;
+extern int	strncmp  (const char *, const char *, long unsigned int )  ;
+extern char *	strncpy  (char *, const char *, long unsigned int )  ;
+extern char *	strpbrk  (const char *, const char *)  ;
+extern char *	strrchr  (const char *, int)  ;
+extern size_t	strspn  (const char *, const char *)  ;
+extern char *	strstr  (const char *, const char *)  ;
+extern char *	strtok  (char *, const char *)  ;
+extern void * memchr (const void *, int, long unsigned int );
+extern int memcmp (const void *, const void *, long unsigned int );
+extern void * memcpy (void *, const void *, long unsigned int );
+extern void * memmove (void *, const void *, long unsigned int );
+extern void * memset (void *, int, long unsigned int );
+extern int strcoll (const char *, const char *);
+extern char * strerror (int);
+extern long unsigned int strxfrm (char *, const char *, long unsigned int );
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+extern	struct	_iobuf {
+	int	_cnt;
+	unsigned char *_ptr;
+	unsigned char *_base;
+	int	_bufsiz;
+	short	_flag;
+	char	_file;		 
+} _iob[];
+extern struct _iobuf 	*fopen  (const char *, const char *)  ;
+extern struct _iobuf 	*fdopen  (int, const char *)  ;
+extern struct _iobuf 	*freopen  (const char *, const char *, struct _iobuf  *)  ;
+extern struct _iobuf 	*popen  (const char *, const char *)  ;
+extern struct _iobuf 	*tmpfile();
+extern long	ftell  (struct _iobuf  *)  ;
+extern char	*fgets  (char *, int, struct _iobuf  *)  ;
+extern char	*gets  (char *)  ;
+extern char	*sprintf  (char *, const char *, ...)  ;
+extern char	*ctermid  (char *)  ;
+extern char	*cuserid  (char *)  ;
+extern char	*tempnam  (const char *, const char *)  ;
+extern char	*tmpnam  (char *)  ;
+extern int fclose (struct _iobuf  *);
+extern int fflush (struct _iobuf  *);
+extern int fgetc (struct _iobuf  *);
+extern int fgetpos (struct _iobuf  *, long *);
+extern int fprintf (struct _iobuf  *, const char *, ...);
+extern int fputc (int, struct _iobuf  *);
+extern int fputs (const char *, struct _iobuf  *);
+extern long unsigned int fread (void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int fscanf (struct _iobuf  *, const char *, ...);
+extern int fseek (struct _iobuf  *, long int, int);
+extern int fsetpos (struct _iobuf  *, const long *);
+extern long unsigned int fwrite (const void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int pclose (struct _iobuf  *);
+extern void perror (const char *);
+extern int printf (const char *, ...);
+extern int puts (const char *);
+extern int remove (const char *);
+extern int rename (const char *, const char *);
+extern void rewind (struct _iobuf  *);
+extern int scanf (const char *, ...);
+extern void setbuf (struct _iobuf  *, char *);
+extern int setvbuf (struct _iobuf  *, char *, int, long unsigned int );
+extern int sscanf (const char *, const char *, ...);
+extern int vprintf (const char *, __gnuc_va_list);
+extern int vsprintf (char *, const char *, __gnuc_va_list);
+extern int vfprintf (struct _iobuf  *, const char *, __gnuc_va_list);
+extern int ungetc (int, struct _iobuf  *);
+extern int _flsbuf (unsigned int, struct _iobuf  *);
+extern int _filbuf (struct _iobuf  *);
+typedef long _G_clock_t;
+typedef short _G_dev_t;
+typedef long   _G_fpos_t;
+typedef unsigned short _G_gid_t;
+typedef unsigned long _G_ino_t;
+typedef unsigned short _G_mode_t;
+typedef short _G_nlink_t;
+typedef long _G_off_t;
+typedef int _G_pid_t;
+typedef int _G_ptrdiff_t;
+typedef int _G_sigset_t;
+typedef long unsigned int _G_size_t;
+typedef long _G_time_t;
+typedef unsigned short _G_uid_t;
+typedef __wchar_t _G_wchar_t;
+typedef int   _G_ssize_t;
+typedef int _G_wint_t;
+typedef char * _G_va_list;
+typedef signed char _G_int8_t;
+typedef unsigned char _G_uint8_t;
+typedef short _G_int16_t;
+typedef unsigned short _G_uint16_t;
+typedef long _G_int32_t;
+typedef unsigned long _G_uint32_t;
+const size_t NPOS = (size_t)(-1);
+typedef void fvoid_t();
+typedef _G_wint_t wint_t;
+enum capacity { default_size, reserve };
+extern "C" fvoid_t *set_new_handler(fvoid_t *);
+extern fvoid_t *__new_handler;
+extern "C" void __default_new_handler();
+inline void *operator new(size_t, void *place) { return place; }
+inline void *operator new[](size_t, void *place) { return place; }
+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	unsigned int	uint;		 
+typedef	struct  _physadr_t { int r[1]; } *physadr_t;
+typedef	struct label_t {
+	int	val[2];
+} label_t;
+typedef	struct	_quad_t { long val[2]; } quad_t;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef	unsigned long	ino_t;
+typedef	short	dev_t;
+typedef	long	off_t;
+typedef	unsigned short	uid_t;
+typedef	unsigned short	gid_t;
+typedef	long	key_t;
+typedef	char *	addr_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;
+extern "C" {
+extern int mkstemp(char *);
+extern int strncasecmp(const char*, const char*, size_t);
+extern int strcasecmp(const char*, const char*);
+extern long random(void);
+extern int seteuid(uid_t);
+extern int setegid(gid_t);
+extern int ftruncate(int, off_t);
+extern int getdtablesize(void);
+struct fd_set;
+struct timeval;
+extern int select(int,struct fd_set*,struct fd_set*,struct fd_set*,struct timeval*);
+extern int ioctl(int, int, ...);
+extern int fchown(int, uid_t, gid_t);
+extern int gethostname(char*, int);
+extern char* optarg;
+extern int opterr;
+extern int optind;
+extern char* mktemp(char*);
+extern void syslog(int, const char*, ...);
+extern void vsyslog(int, const char*, va_list);
+extern void closelog(void);
+extern void openlog(const char*, int, int);
+extern int fchmod(int, mode_t);
+struct timezone;
+struct timeval;
+extern int gettimeofday(struct timeval*, struct timezone*);
+extern void endpwent(void);
+extern int getpeername(int,void*,int*);
+extern int getsockname(int,void*,int*);
+extern int socket(int, int, int);
+extern int connect(int, const void*, int);
+extern int flock(int, int);
+}
+typedef unsigned char fxBool;
+inline int fxmin(int a, int b)		{ return (a < b) ? a : b; }
+inline u_long fxmin(u_long a, u_long b)	{ return (a < b) ? a : b; }
+inline u_int fxmin(u_int a, u_int b)	{ return (a < b) ? a : b; }
+inline int fxmax(int a, int b)		{ return (a > b) ? a : b; }
+inline u_long fxmax(u_long a, u_long b)	{ return (a > b) ? a : b; }
+inline u_int fxmax(u_int a, u_int b)	{ return (a > b) ? a : b; }
+extern "C" void _fxassert(const char*, const char*, int);
+class fxObj {
+public:
+    fxObj();
+    virtual ~fxObj();
+    void inc();
+    void dec();
+    u_long getReferenceCount();
+    virtual const char* className() const;
+    int compare(const fxObj *) const;
+    virtual void subClassMustDefine(const char* method) const;
+protected:
+    u_long	referenceCount;
+};
+inline fxObj::fxObj()				{ referenceCount = 0; }
+inline void fxObj::inc()			{ ++referenceCount; }
+inline void fxObj::dec() {
+    if ( referenceCount>0 ); else _fxassert( "Bogus object reference count" ,"../util/Obj.h",54); ;
+    if (0 >= --referenceCount) delete this;
+}
+inline u_long fxObj::getReferenceCount()	{ return referenceCount; }
+class fxStr;
+class fxTempStr {
+public:
+    fxTempStr(fxTempStr const &other);
+    ~fxTempStr();
+    friend fxTempStr operator|(fxStr const&, fxStr const&);
+    friend fxTempStr operator|(fxStr const&, char const*);
+    friend fxTempStr operator|(char const*, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, fxStr const& b);
+    friend fxTempStr& operator|(const fxTempStr&, char const* b);
+    operator char*() const;
+    operator int() const;
+    operator float() const;
+    operator double() const;
+    u_int length() const;
+protected:
+    char	indata[100];		 
+    char*	data;			 
+    u_int	slength;		 
+    friend class fxStr;
+    fxTempStr(char const *, u_int, char const *, u_int);
+    fxTempStr& concat(char const* b, u_int bl);
+};
+inline fxTempStr::operator char*() const	{ return data; }
+inline fxTempStr::operator int() const		{ return atoi(data); }
+inline fxTempStr::operator float() const	{ return float(atof(data)); }
+inline fxTempStr::operator double() const	{ return double(atof(data)); }
+inline u_int fxTempStr::length() const		{ return slength - 1; }
+class fxStr {
+    friend class fxTempStr;
+public:
+    fxStr(u_int l=0);
+    fxStr(char const *s);
+    fxStr(char const *s, u_int len);
+    fxStr(fxStr const&);
+    fxStr(int, char const* format);
+    fxStr(long, char const* format);
+    fxStr(float, char const* format);
+    fxStr(double, char const* format);
+    fxStr(const fxTempStr&);
+    ~fxStr();
+    u_long hash() const;
+    operator char*() const
+	{ return data; }
+    operator int() const
+	{ return atoi(data); }
+    operator float() const
+	{ return float(atof(data)); }
+    operator double() const
+	{ return double(atof(data)); }
+    u_int length() const { return slength-1; }
+    char& operator[](u_int i) const
+    {   if ( i<slength-1 ); else _fxassert( "Invalid Str[] index" ,"../util/Str.h",109); ;
+	return data[i]; }
+    void operator=(const fxTempStr& s);
+    void operator=(fxStr const& s);
+    void operator=(char const *s);
+    friend fxBool operator==(fxStr const&, fxStr const&);
+    friend fxBool operator==(fxStr const&, char const*);
+    friend fxBool operator==(fxStr const&, char *);
+    friend fxBool operator==(char const*, fxStr const&);
+    friend fxBool operator!=(fxStr const&, fxStr const&);
+    friend fxBool operator!=(fxStr const&, char const*);
+    friend fxBool operator!=(char const*, fxStr const&);
+    friend fxBool operator>=(fxStr const&, fxStr const&);
+    friend fxBool operator>=(fxStr const&, char const*);
+    friend fxBool operator>=(char const*, fxStr const&);
+    friend fxBool operator<=(fxStr const&, fxStr const&);
+    friend fxBool operator<=(fxStr const&, char const*);
+    friend fxBool operator<=(char const*, fxStr const&);
+    friend fxBool operator>(fxStr const&, fxStr const&);
+    friend fxBool operator>(fxStr const&, char const*);
+    friend fxBool operator>(char const*, fxStr const&);
+    friend fxBool operator<(fxStr const&, fxStr const&);
+    friend fxBool operator<(fxStr const&, char const*);
+    friend fxBool operator<(char const*, fxStr const&);
+    int compare(fxStr const *a) const { return ::compare(*this, *a); }
+    friend int compare(fxStr const&, fxStr const&);
+    friend int compare(fxStr const&, char const*);
+    friend int compare(char const*, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, fxStr const&);
+    friend fxTempStr& operator|(const fxTempStr&, char const*);
+    friend fxTempStr operator|(fxStr const&, fxStr const&);
+    friend fxTempStr operator|(fxStr const&, char const*);
+    friend fxTempStr operator|(char const*, fxStr const&);
+    fxStr copy() const;
+    fxStr extract(u_int start,u_int len) const;
+    fxStr cut(u_int start,u_int len);
+    fxStr head(u_int) const;
+    fxStr tail(u_int) const;
+    void lowercase(u_int posn=0, u_int len=0);
+    void raisecase(u_int posn=0, u_int len=0);
+    void remove(u_int posn,u_int len=1);
+    void resize(u_int len, fxBool reallocate = ((fxBool)0) );
+    void setMaxLength(u_int maxlen);
+    void append(char a);
+    void append(char const *s, u_int len=0);
+    void append(const fxTempStr& s)
+	{ append((char*)s, s.slength-1); }
+    void append(fxStr const& s)
+	{ append((char*)s, s.slength-1); }
+    void insert(char a, u_int posn=0);
+    void insert(char const *, u_int posn=0, u_int len=0);
+    void insert(const fxTempStr& s, u_int posn=0)
+	{ insert((char*)s, posn, s.slength-1); }
+    void insert(fxStr const& s, u_int posn=0)
+	{ insert((char*)s, posn, s.slength-1); }
+    u_int next(u_int posn, char delimiter) const;
+    u_int next(u_int posn, char const *delimiters, u_int len=0) const;
+    u_int next(u_int posn, fxStr const& delimiters) const
+	{ return next(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int nextR(u_int posn, char delimiter) const;
+    u_int nextR(u_int posn, char const*, u_int len=0) const;
+    u_int nextR(u_int posn, fxStr const& delimiters) const
+	{ return nextR(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int skip(u_int posn, char a) const; 
+    u_int skip(u_int posn, char const *, u_int len=0) const;
+    u_int skip(u_int posn, fxStr const& delimiters) const
+	{ return skip(posn, (char*)delimiters, delimiters.slength-1); }
+    u_int skipR(u_int posn, char a) const;
+    u_int skipR(u_int posn, char const *, u_int len=0) const;
+    u_int skipR(u_int posn, fxStr const& delimiters) const
+	{ return skipR(posn, (char*)delimiters, delimiters.slength-1); }
+    fxStr token(u_int & posn, char delimiter) const;
+    fxStr token(u_int & posn, char const * delimiters,
+	u_int delimiters_len = 0) const;
+    fxStr token(u_int & posn, fxStr const & delimiters) const
+	{ return token(posn, delimiters.data, delimiters.slength-1); }
+    fxStr tokenR(u_int & posn, char delimiter) const;
+    fxStr tokenR(u_int & posn, char const * delimiters,
+	u_int delimiters_len = 0) const;
+    fxStr tokenR(u_int & posn, fxStr const & delimiters) const
+	{ return tokenR(posn, delimiters.data, delimiters.slength-1); }
+protected:
+    u_int slength;
+    char * data; 
+    static char emptyString;
+    void fxStr::resizeInternal(u_int);
+    int findEndBuffer(const char *, u_int buflen) const;
+    int findBuffer(const char *buf, u_int buflen) const;
+    void bracketBuffer(const char *, u_int buflen, int &, int &) const;
+};
+struct Class2Params {
+    u_int vr;		 
+    u_int br;		 
+    u_int wd;		 
+    u_int ln;		 
+    u_int df;		 
+    u_int ec;		 
+    u_int bf;		 
+    u_int st;		 
+    static u_int vrDISTab[2];		 
+    static u_int dfDISTab[4];		 
+    static u_int wdDISTab[8];		 
+    static u_int lnDISTab[3];		 
+    static u_int stDISTab[8];		 
+    static u_int stDCSTab[8];		 
+    static u_int brDISTab[8];		 
+    static u_int brDCSTab[8];		 
+    static u_int DISvrTab[2];		 
+    static u_int DISdfTab[2];		 
+    static u_int DISwdTab[4];		 
+    static u_int DISlnTab[4];		 
+    static u_int DISstTab[8];		 
+    static u_int DISbrTab[16];		 
+    static u_int DCSbrTab[16];		 
+    static const char* bitRateNames[8];		 
+    static const char* dataFormatNames[4];	 
+    static const char* vresNames[2];		 
+    static const char* pageWidthNames[8];	 
+    static const char* pageLengthNames[4];	 
+    static const char* scanlineTimeNames[8];	 
+    Class2Params();
+    int operator==(const Class2Params&) const;
+    int operator!=(const Class2Params&) const;
+    fxStr cmd() const;			 
+    void setFromDIS(u_int dis, u_int xinfo = 0);
+    void setFromDCS(u_int dcs, u_int xinfo = 0);
+    u_int getDCS() const;
+    fxBool is2D() const;
+    u_int pageWidth() const;
+    u_int transferSize(u_int ms) const;
+    u_int minScanlineSize() const;
+    fxStr encode() const;		 
+    void decode(const fxStr&);		 
+};
+typedef	struct {
+	unsigned short tiff_magic;	 
+	unsigned short tiff_version;	 
+	unsigned long  tiff_diroff;	 
+} TIFFHeader;
+typedef	struct {
+	unsigned short tdir_tag;	 
+	unsigned short tdir_type;	 
+	unsigned long  tdir_count;	 
+	unsigned long  tdir_offset;	 
+} TIFFDirEntry;
+typedef	enum {
+	TIFF_NOTYPE	= 0,	 
+	TIFF_BYTE	= 1,	 
+	TIFF_ASCII	= 2,	 
+	TIFF_SHORT	= 3,	 
+	TIFF_LONG	= 4,	 
+	TIFF_RATIONAL	= 5,	 
+	TIFF_SBYTE	= 6,	 
+	TIFF_UNDEFINED	= 7,	 
+	TIFF_SSHORT	= 8,	 
+	TIFF_SLONG	= 9,	 
+	TIFF_SRATIONAL	= 10,	 
+	TIFF_FLOAT	= 11,	 
+	TIFF_DOUBLE	= 12	 
+} TIFFDataType;
+typedef	struct tiff TIFF;
+extern int fclose (struct _iobuf  *);
+extern int fflush (struct _iobuf  *);
+extern int fgetc (struct _iobuf  *);
+extern int fgetpos (struct _iobuf  *, long *);
+extern int fprintf (struct _iobuf  *, const char *, ...);
+extern int fputc (int, struct _iobuf  *);
+extern int fputs (const char *, struct _iobuf  *);
+extern long unsigned int fread (void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int fscanf (struct _iobuf  *, const char *, ...);
+extern int fseek (struct _iobuf  *, long int, int);
+extern int fsetpos (struct _iobuf  *, const long *);
+extern long unsigned int fwrite (const void *, long unsigned int , long unsigned int , struct _iobuf  *);
+extern int pclose (struct _iobuf  *);
+extern void perror (const char *);
+extern int printf (const char *, ...);
+extern int puts (const char *);
+extern int remove (const char *);
+extern int rename (const char *, const char *);
+extern void rewind (struct _iobuf  *);
+extern int scanf (const char *, ...);
+extern void setbuf (struct _iobuf  *, char *);
+extern int setvbuf (struct _iobuf  *, char *, int, long unsigned int );
+extern int sscanf (const char *, const char *, ...);
+extern int vprintf (const char *, __gnuc_va_list);
+extern int vsprintf (char *, const char *, __gnuc_va_list);
+extern int vfprintf (struct _iobuf  *, const char *, __gnuc_va_list);
+extern int ungetc (int, struct _iobuf  *);
+extern int _flsbuf (unsigned int, struct _iobuf  *);
+extern int _filbuf (struct _iobuf  *);
+typedef	void (*TIFFErrorHandler)(const char* module, const char* fmt, va_list);
+typedef	int (*TIFFReadWriteProc)(void*, char*, unsigned long);
+typedef	long (*TIFFSeekProc)(void*, long, int);
+typedef	int (*TIFFCloseProc)(void*);
+typedef	long (*TIFFSizeProc)(void*);
+typedef	int (*TIFFMapFileProc)(void*, char**, long*);
+typedef	void (*TIFFUnmapFileProc)(void*, char*, long);
+extern "C" {
+extern	const char* TIFFGetVersion();
+extern	void TIFFClose(TIFF*);
+extern	int TIFFFlush(TIFF*);
+extern	int TIFFFlushData(TIFF*);
+extern	int TIFFGetField(TIFF*, unsigned int, ...);
+extern	int TIFFVGetField(TIFF*, unsigned int, va_list);
+extern	int TIFFGetFieldDefaulted(TIFF*, unsigned int, ...);
+extern	int TIFFVGetFieldDefaulted(TIFF*, unsigned int, va_list);
+extern	int TIFFReadDirectory(TIFF*);
+extern	unsigned long TIFFScanlineSize(TIFF*);
+extern	unsigned long TIFFStripSize(TIFF*);
+extern	unsigned long TIFFVStripSize(TIFF*, unsigned long);
+extern	unsigned long TIFFTileRowSize(TIFF*);
+extern	unsigned long TIFFTileSize(TIFF*);
+extern	unsigned long TIFFVTileSize(TIFF*, unsigned long);
+extern	int TIFFFileno(TIFF*);
+extern	int TIFFGetMode(TIFF*);
+extern	int TIFFIsTiled(TIFF*);
+extern	long TIFFCurrentRow(TIFF*);
+extern	int TIFFCurrentDirectory(TIFF*);
+extern	int TIFFCurrentStrip(TIFF*);
+extern	int TIFFCurrentTile(TIFF*);
+extern	int TIFFReadBufferSetup(TIFF*, char*, unsigned long);
+extern	int TIFFLastDirectory(TIFF*);
+extern	int TIFFSetDirectory(TIFF*, int);
+extern	int TIFFSetField(TIFF*, unsigned int, ...);
+extern	int TIFFVSetField(TIFF*, unsigned int, va_list);
+extern	int TIFFWriteDirectory(TIFF *);
+extern	void TIFFPrintDirectory(TIFF*, struct _iobuf *, long = 0);
+extern	int TIFFReadScanline(TIFF*, unsigned char*, unsigned, unsigned = 0);
+extern	int TIFFWriteScanline(TIFF*, unsigned char*, unsigned, unsigned = 0);
+extern	int TIFFReadRGBAImage(TIFF*,
+	    unsigned long, unsigned long, unsigned long*, int stop = 0);
+extern	TIFF* TIFFOpen(const char*, const char*);
+extern	TIFF* TIFFFdOpen(int, const char*, const char*);
+extern	TIFF* TIFFClientOpen(const char* name, const char* mode,
+	    void* clientdata,
+	    TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc,
+	    TIFFSeekProc seekproc, TIFFCloseProc closeproc,
+	    TIFFSizeProc sizeproc,
+	    TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc);
+extern	const char* TIFFFileName(TIFF*);
+extern	void TIFFError(const char*, const char*, ...);
+extern	void TIFFWarning(const char*, const char*, ...);
+extern	TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler handler);
+extern	TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler handler);
+extern	unsigned int TIFFComputeTile(TIFF*,
+	    unsigned long, unsigned long, unsigned long, unsigned int);
+extern	int TIFFCheckTile(TIFF*,
+	    unsigned long, unsigned long, unsigned long, unsigned);
+extern	unsigned int TIFFNumberOfTiles(TIFF*);
+extern	int TIFFReadTile(TIFF*,
+	    unsigned char*,
+	    unsigned long, unsigned long, unsigned long,
+	    unsigned int);
+extern	int TIFFWriteTile(TIFF*,
+	    unsigned char*,
+	    unsigned long, unsigned long, unsigned long,
+	    unsigned int);
+extern	unsigned int TIFFComputeStrip(TIFF*, unsigned long, unsigned int);
+extern	unsigned int TIFFNumberOfStrips(TIFF*);
+extern	int TIFFReadEncodedStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadRawStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadEncodedTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFReadRawTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteEncodedStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteRawStrip(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteEncodedTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	int TIFFWriteRawTile(TIFF*, unsigned, unsigned char*, unsigned long);
+extern	void TIFFSetWriteOffset(TIFF*, unsigned long);
+extern	void TIFFSwabShort(unsigned short *);
+extern	void TIFFSwabLong(unsigned long *);
+extern	void TIFFSwabArrayOfShort(unsigned short *, unsigned long);
+extern	void TIFFSwabArrayOfLong(unsigned long *, unsigned long);
+extern	void TIFFReverseBits(unsigned char *, unsigned long);
+extern	const unsigned char* TIFFGetBitRevTable(int);
+}
+struct G3Base {
+    short	data;		 
+    short	bit;		 
+    fxBool	is2D;		 
+    enum { G3_1D, G3_2D } tag;	 
+    const u_char* bitmap;	 
+    static const u_char zeroruns[256];
+    static const u_char oneruns[256];
+    static int findspan(const u_char**, int, int, const u_char*);
+    static int finddiff(const u_char*, int, int);
+    static void fillspan(u_char* cp, int x, int count);
+    void setup(const u_char*, fxBool is2d);
+};
+class fxStackBuffer;
+class G3Decoder : private G3Base {
+private:
+    short	bytePending;	 
+    short	prevByte;	 
+    u_char*	refline;	 
+    fxStackBuffer* recvBuf;	 
+    fxBool	decode1DRow(u_char*, u_int);
+    fxBool	decode2DRow(u_char*, u_int);
+    int		nextBit();
+    void	ungetBit();
+    int		nextByte();
+    int		decodeWhiteRun();
+    int		decodeBlackRun();
+    int		decodeUncompCode();
+    void	skipToEOL(int len);
+protected:
+    G3Decoder();
+    void	raiseEOF();
+    void	raiseRTC();
+    void	setPendingByte(u_char);
+    virtual int decodeNextByte() = 0;
+    void	setRefLine(u_char*);
+    u_char*	getRefLine();
+    virtual void invalidCode(const char* type, int x);
+    virtual void prematureEOL(const char* type, int x);
+    virtual void badPixelCount(const char* type, int x);
+    virtual void badDecodingState(const char* type, int x);
+public:
+    sigjmp_buf	jmpEOF;		 
+    sigjmp_buf	jmpRTC;		 
+    virtual ~G3Decoder();
+    void	setupDecoder(u_int, fxBool is2D);
+    void	decode(void* raster, u_int w, u_int h);
+    void	skip(u_int h);
+    void	skipLeader();
+    fxBool	decodeRow(void* scanline, u_int w);
+    void	skipRow();
+    fxBool	isLastRow1D();
+    fxBool	isNextRow1D();
+    fxBool	isByteAligned();
+    void	setRecvBuf(fxStackBuffer&);
+    fxStackBuffer* getRecvBuf();
+    void	flushRecvBuf();
+};
+inline void G3Decoder::setRecvBuf(fxStackBuffer& b){ recvBuf = &b; }
+inline fxStackBuffer* G3Decoder::getRecvBuf()	{ return recvBuf; }
+inline void G3Decoder::setRefLine(u_char* b)	{ refline = b; }
+inline u_char* G3Decoder::getRefLine()		{ return refline; }
+inline fxBool G3Decoder::isLastRow1D()		{ return tag == G3_1D; }
+enum FaxSendStatus {
+    send_retry,			 
+    send_failed,		 
+    send_done,			 
+    send_reformat,		 
+};
+class FaxServer;
+class FaxMachineInfo;
+class ModemConfig;
+class fxStackBuffer;
+class FaxFont;
+class FaxRequest;
+typedef unsigned int CallStatus;	 
+typedef	unsigned int CallType;		 
+typedef	unsigned int AnswerType;	 
+typedef unsigned int SpeakerVolume;
+typedef	unsigned int ATResponse;	 
+typedef	unsigned int BaudRate;		 
+typedef	unsigned int FlowControl;	 
+typedef	unsigned int SetAction;		 
+typedef struct {
+    const char*	msg;		 
+    u_short	len;		 
+    ATResponse	expect;		 
+    CallStatus	status;		 
+    CallType	type;		 
+} AnswerMsg;
+class FaxModem : public G3Decoder {
+public:
+    static FaxModem* deduceModem(FaxServer&, const ModemConfig& config);
+    enum {			 
+	OK	   = 0,		 
+	BUSY	   = 1,		 
+	NOCARRIER  = 2,		 
+	NOANSWER   = 3,		 
+	NODIALTONE = 4,		 
+	ERROR	   = 5,		 
+	FAILURE	   = 6,		 
+	NOFCON	   = 7,		 
+	DATACONN   = 8,		 
+    };
+    enum {			 
+	CALLTYPE_ERROR	= 0,	 
+	CALLTYPE_DATA	= 1,	 
+	CALLTYPE_FAX	= 2,	 
+	CALLTYPE_VOICE	= 3,	 
+	CALLTYPE_UNKNOWN = 4,	 
+    };
+    enum {			 
+	OFF	= 0,		 
+	QUIET	= 1,		 
+	LOW	= 2,		 
+	MEDIUM	= 3,		 
+	HIGH	= 4,		 
+    };
+    enum {			 
+	BR0	= 0,		 
+	BR300	= 1,		 
+	BR1200	= 2,		 
+	BR2400	= 3,		 
+	BR4800	= 4,		 
+	BR9600	= 5,		 
+	BR19200	= 6,		 
+	BR38400	= 7,		 
+	BR57600	= 8,		 
+	BR76800	= 9,		 
+    };
+    enum {			 
+	FLOW_NONE	= 0,	 
+	FLOW_XONXOFF	= 1,	 
+	FLOW_RTSCTS	= 2	 
+    };
+    enum {			 
+	ACT_NOW		= 0,	 
+	ACT_DRAIN	= 1,	 
+	ACT_FLUSH	= 2,	 
+    };
+    enum {			 
+	ANSTYPE_ANY	= 0,	 
+	ANSTYPE_DATA	= 1,	 
+	ANSTYPE_FAX	= 2,	 
+	ANSTYPE_VOICE	= 3,	 
+    };
+    enum {			 
+	AT_NOTHING	= 0,	 
+	AT_OK		= 1,	 
+	AT_CONNECT	= 2,	 
+	AT_NOANSWER	= 3,	 
+	AT_NOCARRIER	= 4,	 
+	AT_NODIALTONE	= 5,	 
+	AT_BUSY		= 6,	 
+	AT_OFFHOOK	= 7,	 
+	AT_RING		= 8,	 
+	AT_ERROR	= 9,	 
+	AT_EMPTYLINE	= 10,	 
+	AT_TIMEOUT	= 11,	 
+	AT_OTHER	= 12,	 
+    };
+private:
+    FaxServer&	server;		 
+    fxStr	resetCmds;	 
+    long	dataTimeout;	 
+    BaudRate	rate;		 
+    FlowControl	iFlow;		 
+    FlowControl	oFlow;		 
+    u_int	pageNumber;	 
+    FaxFont*	tagLineFont;	 
+    u_int	tagLineSlop;	 
+    fxStr	tagLine;	 
+    u_int	tagLineFields;	 
+    void	setupTagLine(const FaxRequest&);
+    u_int	cblc;		 
+    fxBool	lastRowBad;	 
+    u_long	recvEOLCount;	 
+    u_long	recvBadLineCount;
+    u_long	recvConsecutiveBadLineCount;
+    u_int	recvCC;		 
+    fxStackBuffer* recvBuf;	 
+    u_long	savedWriteOff;	 
+    void	recvRow(TIFF* tif, fxStackBuffer& row, u_char* buf);
+    void	invalidCode(const char* type, int x);
+    void	prematureEOL(const char* type, int x);
+    void	badPixelCount(const char* type, int x);
+    void	badDecodingState(const char* type, int x);
+protected:
+    const ModemConfig& conf;	 
+    FlowControl	flowControl;	 
+    u_int	modemServices;	 
+    fxStr	modemMfr;	 
+    fxStr	modemModel;	 
+    fxStr	modemRevision;	 
+    Class2Params modemParams;	 
+    char	rbuf[1024];	 
+    ATResponse	lastResponse;	 
+    fxStr	mfrQueryCmd;	 
+    fxStr	modelQueryCmd;	 
+    fxStr	revQueryCmd;	 
+    static const char* serviceNames[9];	  
+    static const u_char digitMap[12*2+1]; 
+    static const char* callStatus[9];	  
+    FaxModem(FaxServer&, const ModemConfig&);
+    virtual fxBool selectBaudRate(BaudRate max, FlowControl i, FlowControl o);
+    virtual fxBool setupModem() = 0;
+    virtual fxBool setupManufacturer(fxStr& mfr);
+    virtual fxBool setupModel(fxStr& model);
+    virtual fxBool setupRevision(fxStr& rev);
+    fxBool doQuery(const fxStr& queryCmd, fxStr& result, long ms = 30*1000);
+    virtual const AnswerMsg* findAnswer(const char* s);
+    virtual CallType answerResponse(fxStr& emsg);
+    virtual CallStatus dialResponse(fxStr& emsg) = 0;
+    void	setDataTimeout(long secs, u_int br);
+    long	getDataTimeout() const;
+    void	pause(u_int ms);
+    void	countPage();
+    void	modemTrace(const char* fmt, ...);
+    void	modemSupports(const char* fmt, ...);
+    void	modemCapability(const char* fmt, ...);
+    void	protoTrace(const char* fmt, ...);
+    void	recvTrace(const char* fmt, ...);
+    void	copyQualityTrace(const char* fmt, ...);
+    void	serverTrace(const char* fmt, ...);
+    void	traceBits(u_int bits, const char* bitNames[]);
+    void	traceModemParams();
+    void	tracePPR(const char* dir, u_int ppr);
+    void	tracePPM(const char* dir, u_int ppm);
+    void	trimModemLine(char buf[], int& cc);
+    int		getModemLine(char buf[], u_int bufSize, long ms = 0);
+    void	beginTimedTransfer();
+    void	endTimedTransfer();
+    fxBool	wasTimeout();
+    void	setTimeout(fxBool);
+    void	flushModemInput();
+    fxBool	putModem(void* data, int n, long ms = 0);
+    fxBool	putModemData(void* data, int n);
+    fxBool	putModemDLEData(const u_char* data, u_int,
+		    const u_char* brev, long ms);
+    fxBool	putModemLine(const char* cp);
+    int		getModemChar(long ms = 0);
+    int		getModemDataChar();
+    void	startTimeout(long ms);
+    void	stopTimeout(const char* whichdir);
+    static const char* ATresponses[13];
+    virtual ATResponse atResponse(char* buf, long ms = 30*1000);
+    virtual fxBool waitFor(ATResponse wanted, long ms = 30*1000);
+    fxBool	atCmd(const fxStr& cmd, ATResponse = AT_OK, long ms = 30*1000);
+    fxBool	atQuery(const char* what, u_int& v, long ms = 30*1000);
+    fxBool	atQuery(const char* what, fxStr& v, long ms = 30*1000);
+    u_int	fromHex(const char*, int = -1);
+    fxStr	toHex(int, int ndigits);
+    fxBool	parseRange(const char*, u_int&);
+    fxBool	vparseRange(const char*, int nargs ...);
+    fxBool	vatFaxCmd(ATResponse resp, const char* cmd ... );
+    fxBool	sendBreak(fxBool pause);
+    fxBool	setBaudRate(BaudRate rate);
+    fxBool	setBaudRate(BaudRate rate, FlowControl i, FlowControl o);
+    fxBool	setXONXOFF(FlowControl i, FlowControl o, SetAction);
+    fxBool	setDTR(fxBool on);
+    fxBool	setInputBuffering(fxBool on);
+    fxBool	modemStopOutput();
+    FlowControl	getInputFlow();
+    FlowControl	getOutputFlow();
+    fxBool	getProtocolTracing();
+    fxBool	getHDLCTracing();
+    FaxSendStatus sendSetupParams(TIFF*, Class2Params&,
+		    FaxMachineInfo&, fxStr&);
+    fxBool	recvCheckTSI(const fxStr&);
+    void	recvCSI(fxStr&);
+    void	recvDCS(Class2Params&);
+    void	recvNSF(u_int nsf);
+    void	recvSetupPage(TIFF* tif, long group3opts, int fillOrder);
+    void	recvResetPage(TIFF* tif);
+    fxBool	abortRequested();
+    fxBool	decodePPM(const fxStr& pph, u_int& ppm, fxStr& emsg);
+    fxBool	recvPageDLEData(TIFF* tif, fxBool checkQuality,
+		    const Class2Params& params, fxStr& emsg);
+    virtual void abortPageRecv() = 0;
+    virtual int decodeNextByte();
+    fxBool	checkQuality();
+    fxBool	isQualityOK(const Class2Params&);
+    u_long	getRecvEOLCount() const;
+    u_long	getRecvBadLineCount() const;
+    u_long	getRecvConsecutiveBadLineCount() const;
+    fxBool	setupTagLineSlop(const Class2Params&);
+    u_int	getTagLineSlop() const;
+    u_char*	imageTagLine(u_char* buf, u_int fillorder, const Class2Params&);
+public:
+    virtual ~FaxModem();
+    virtual fxBool dataService();		 
+    virtual fxBool voiceService();		 
+    virtual fxBool sync(long ms = 0);		 
+    virtual fxBool reset(long ms = 5*1000);	 
+    virtual void hangup();			 
+    virtual void setSpeakerVolume(SpeakerVolume);
+    virtual void setLID(const fxStr& number) = 0;
+    const fxStr& getModel() const;
+    const fxStr& getManufacturer() const;
+    const fxStr& getRevision() const;
+    virtual fxBool supports2D() const;
+    virtual fxBool supportsEOLPadding() const;
+    virtual fxBool supportsVRes(float res) const;
+    virtual fxBool supportsPageWidth(u_int w) const;
+    virtual fxBool supportsPageLength(u_int l) const;
+    virtual fxBool supportsPolling() const;
+    virtual int selectSignallingRate(int br) const;
+    u_int getBestSignallingRate() const;
+    u_int getBestScanlineTime() const;
+    virtual int selectScanlineTime(int st) const;
+    u_int getBestVRes() const;
+    u_int getBestDataFormat() const;
+    u_int getBestPageWidth() const;
+    u_int getBestPageLength() const;
+    u_int modemDIS() const;
+    virtual CallStatus dial(const char* number,
+	const Class2Params& dis, fxStr& emsg);
+    virtual void sendBegin(const FaxRequest&);
+    virtual fxBool getPrologue(Class2Params&,
+	u_int& nsf, fxStr& csi, fxBool& hasDoc) = 0;
+    virtual void sendSetupPhaseB();
+    virtual FaxSendStatus sendPhaseB(TIFF*, Class2Params&, FaxMachineInfo&,
+	fxStr& pph, fxStr& emsg) = 0;
+    virtual void sendEnd();
+    virtual void sendAbort() = 0;
+    virtual fxBool waitForRings(u_int rings);
+    virtual CallType answerCall(AnswerType, fxStr& emsg);
+    virtual fxBool recvBegin(fxStr& emsg) = 0;
+    virtual fxBool recvPage(TIFF*, int& ppm, fxStr& em) = 0;
+    virtual fxBool recvEnd(fxStr& emsg) = 0;
+    virtual void recvAbort() = 0;
+    virtual fxBool requestToPoll() = 0;
+    virtual fxBool pollBegin(const fxStr& pollID, fxStr& emsg) = 0;
+};
+inline long FaxModem::getDataTimeout() const		{ return dataTimeout; }
+inline const fxStr& FaxModem::getModel() const		{ return modemModel; }
+inline const fxStr& FaxModem::getManufacturer() const	{ return modemMfr; }
+inline const fxStr& FaxModem::getRevision() const	{ return modemRevision; }
+inline FlowControl FaxModem::getInputFlow()		{ return iFlow; }
+inline FlowControl FaxModem::getOutputFlow()		{ return oFlow; }
+inline u_int FaxModem::getTagLineSlop() const		{ return tagLineSlop; }
+struct ModemConfig {
+    fxStr	type;			 
+    fxStr	resetCmds;		 
+    fxStr	dialCmd;		 
+    fxStr	answerAnyCmd;		 
+    fxStr	answerDataCmd;		 
+    fxStr	answerFaxCmd;		 
+    fxStr	answerVoiceCmd;		 
+    fxStr	flowControlCmd;		 
+    fxStr	setupDTRCmd;		 
+    fxStr	setupDCDCmd;		 
+    fxStr	setupAACmd;		 
+    fxStr	noAutoAnswerCmd;	 
+    fxStr	setVolumeCmd[5];	 
+    fxStr	echoOffCmd;		 
+    fxStr	verboseResultsCmd;	 
+    fxStr	resultCodesCmd;		 
+    fxStr	onHookCmd;		 
+    fxStr	softResetCmd;		 
+    fxStr	waitTimeCmd;		 
+    fxStr	pauseTimeCmd;		 
+    fxStr	mfrQueryCmd;		 
+    fxStr	modelQueryCmd;		 
+    fxStr	revQueryCmd;		 
+    fxStr	answerAnyBeginCmd;	 
+    fxStr	answerDataBeginCmd;	 
+    fxStr	answerFaxBeginCmd;	 
+    fxStr	answerVoiceBeginCmd;	 
+    fxStr	sendBeginCmd;		 
+    u_int	t1Timer;		 
+    u_int	t2Timer;		 
+    u_int	t4Timer;		 
+    u_int	dialResponseTimeout;	 
+    u_int	answerResponseTimeout;	 
+    u_int	pageStartTimeout;	 
+    u_int	pageDoneTimeout;	 
+    fxStr	class1Cmd;		 
+    u_int	class1TCFResponseDelay;	 
+    u_int	class1SendPPMDelay;	 
+    u_int	class1SendTCFDelay;	 
+    u_int	class1TrainingRecovery;	 
+    u_int	class1RecvAbortOK;	 
+    u_int	class1FrameOverhead;	 
+    u_int	class1RecvIdentTimer;	 
+    u_int	class1TCFMaxNonZero;	 
+    u_int	class1TCFMinRun;	 
+    fxStr	class2Cmd;		 
+    fxStr	class2DCCQueryCmd;	 
+    fxStr	class2CQQueryCmd;	 
+    fxStr	class2BORCmd;		 
+    fxStr	class2RELCmd;		 
+    fxStr	class2CQCmd;		 
+    fxStr	class2AbortCmd;		 
+    fxStr	class2TBCCmd;		 
+    fxStr	class2CRCmd;		 
+    fxStr	class2PHCTOCmd;		 
+    fxStr	class2BUGCmd;		 
+    fxStr	class2LIDCmd;		 
+    fxStr	class2DCCCmd;		 
+    fxStr	class2DISCmd;		 
+    fxStr	class2DDISCmd;		 
+    fxStr	class2CIGCmd;		 
+    fxStr	class2SPLCmd;		 
+    fxStr	class2PTSCmd;		 
+    fxStr	class2RecvDataTrigger;	 
+    fxBool	class2XmitWaitForXON;	 
+    fxStr	class2PIECmd;		 
+    fxStr	class2NRCmd;		 
+    FlowControl	flowControl;		 
+    BaudRate	maxRate;		 
+    u_int	recvFillOrder;		 
+    u_int	sendFillOrder;		 
+    u_int	frameFillOrder;		 
+    u_int	resetDelay;		 
+    u_int	baudRateDelay;		 
+    u_int	maxPacketSize;		 
+    u_int	interPacketDelay;	 
+    u_int	percentGoodLines;	 
+    u_int	maxConsecutiveBadLines;	 
+    fxBool	waitForConnect;		 
+    fxStr	tagLineFmt;		 
+    fxStr	tagLineFontFile;	 
+    ModemConfig();
+    ~ModemConfig();
+    fxBool parseItem(const char* tag, const char* value);
+    void setVolumeCmds(const fxStr& value);
+    fxStr parseATCmd(const char*);
+};
+ModemConfig::ModemConfig()
+    : type("unknown")
+    , dialCmd("DT%s")			 
+    , noAutoAnswerCmd("S0=0")
+    , echoOffCmd("E0")
+    , verboseResultsCmd("V1")
+    , resultCodesCmd("Q0")
+    , onHookCmd("H0")
+    , softResetCmd("Z")
+    , waitTimeCmd("S7=30")		 
+    , pauseTimeCmd("S8=2")		 
+    , class1Cmd("+FCLASS=1")		 
+    , class2CQQueryCmd("+FCQ=?")	 
+    , tagLineFmt("From %%n|%c|Page %%p of %%t")
+{
+    class2XmitWaitForXON = ((fxBool)1) ;	 
+    setVolumeCmds("M0 L0M1 L1M1 L2M1 L3M1");
+    answerAnyCmd = "A";
+    flowControl = FaxModem::FLOW_NONE;	 
+    maxRate = FaxModem::BR19200;	 
+    sendFillOrder = 2 ;	 
+    recvFillOrder = 2 ;	 
+    frameFillOrder = 2 ;	 
+    resetDelay = 2600;			 
+    baudRateDelay = 0;			 
+    t1Timer = ((35+5)*1000) ;			 
+    t2Timer = ((6+1)*1000) ;			 
+    t4Timer = 3100 ;			 
+    dialResponseTimeout = 3*60*1000;	 
+    answerResponseTimeout = 3*60*1000;	 
+    pageStartTimeout = 3*60*1000;	 
+    pageDoneTimeout = 3*60*1000;	 
+    class1TCFResponseDelay = 75;	 
+    class1SendPPMDelay = 75;		 
+    class1SendTCFDelay = 75;		 
+    class1TrainingRecovery = 1500;	 
+    class1RecvAbortOK = 200;		 
+    class1FrameOverhead = 4;		 
+    class1RecvIdentTimer = t1Timer;	 
+    class1TCFMinRun = (2*1500 )/3; 
+    class1TCFMaxNonZero = 10;		 
+    maxPacketSize = 16*1024;		 
+    interPacketDelay = 0;		 
+    waitForConnect = ((fxBool)0) ;		 
+    percentGoodLines = 95;		 
+    maxConsecutiveBadLines = 5;		 
+}
+ModemConfig::~ModemConfig()
+{
+}
+static fxBool getBoolean(const char* cp)
+    { return ((strcasecmp( cp ,  "on" )==0)  || (strcasecmp( cp ,  "yes" )==0) ); }
+static BaudRate
+findRate(const char* cp)
+{
+    static const struct {
+	const char* name;
+	BaudRate    br;
+    } rates[] = {
+	{   "300", FaxModem::BR300 },
+	{  "1200", FaxModem::BR1200 },
+	{  "2400", FaxModem::BR2400 },
+	{  "4800", FaxModem::BR4800 },
+	{  "9600", FaxModem::BR9600 },
+	{ "19200", FaxModem::BR19200 },
+	{ "38400", FaxModem::BR38400 },
+	{ "57600", FaxModem::BR57600 },
+	{ "76800", FaxModem::BR76800 },
+    };
+    for (int i = (sizeof ( rates ) / sizeof ( rates [0])) -1; i >= 0; i--)
+	if ((strcasecmp( cp ,  rates[i].name )==0) )
+	    return (rates[i].br);
+    return (FaxModem::BR0);
+}
+static BaudRate
+getRate(const char* cp)
+{
+    BaudRate br = findRate(cp);
+    if (br == FaxModem::BR0) {
+	syslog(3 , "Unknown baud rate \"%s\", using 19200", cp);
+	br = FaxModem::BR19200;			 
+    }
+    return (br);
+}
+static u_int
+getFill(const char* cp)
+{
+    if ((strcasecmp( cp ,  "LSB2MSB" )==0) )
+	return (2 );
+    else if ((strcasecmp( cp ,  "MSB2LSB" )==0) )
+	return (1 );
+    else {
+	syslog(3 , "Unknown fill order \"%s\"", cp);
+        return ((u_int) -1);
+    }
+}
+static FlowControl
+getFlow(const char* cp)
+{
+    if ((strcasecmp( cp ,  "xonxoff" )==0) )
+	return (FaxModem::FLOW_XONXOFF);
+    else if ((strcasecmp( cp ,  "rtscts" )==0) )
+	return (FaxModem::FLOW_RTSCTS);
+    else if ((strcasecmp( cp ,  "none" )==0) )
+	return (FaxModem::FLOW_NONE);
+    else {
+	syslog(3 , "Unknown flow control \"%s\", using xonxoff", cp);
+	return (FaxModem::FLOW_XONXOFF);	 
+    }
+}
+void
+ModemConfig::setVolumeCmds(const fxStr& tag)
+{
+    u_int l = 0;
+    for (int i = FaxModem::OFF; i <= FaxModem::HIGH; i++) {
+	fxStr tmp = tag.token(l, " \t");		 
+	setVolumeCmd[i] = parseATCmd(tmp);
+    }
+}
+fxStr
+ModemConfig::parseATCmd(const char* cp)
+{
+    fxStr cmd(cp);
+    u_int pos = 0;
+    while ((pos = cmd.next(pos, '<')) != cmd.length()) {
+	u_int epos = pos+1;
+	fxStr esc = cmd.token(epos, '>');
+	esc.lowercase();
+	char ecode;
+	if (esc == "xon")
+	    ecode = (0x80|0xf) ;
+	else if (esc == "rts")
+	    ecode = (0x80|0xe) ;
+	else if (esc == "none")
+	    ecode = (0x80|0xd) ;
+	else if (esc == "")		 
+	    ecode = '<';
+	else {
+	    BaudRate br = findRate(esc);
+	    if (br == FaxModem::BR0) {
+		syslog(3 , "Unknown AT escape code \"%s\"", (char*) esc);
+		pos = epos;
+		continue;
+	    }
+	    ecode = 0x80| ((int)( br )) ;
+	}
+	cmd.remove(pos, epos-pos);
+	cmd.insert(ecode, pos);
+    }
+    return (cmd);
+}
+static const struct {
+    const char*		 name;
+    fxStr ModemConfig::* p;
+} atcmds[] = {
+    { "ModemAnswerCmd",			&ModemConfig::answerAnyCmd },
+    { "ModemAnswerAnyCmd",		&ModemConfig::answerAnyCmd },
+    { "ModemAnswerFaxCmd",		&ModemConfig::answerFaxCmd },
+    { "ModemAnswerDataCmd",		&ModemConfig::answerDataCmd },
+    { "ModemAnswerVoiceCmd",		&ModemConfig::answerVoiceCmd },
+    { "ModemAnswerFaxBeginCmd",		&ModemConfig::answerFaxBeginCmd },
+    { "ModemAnswerDataBeginCmd",	&ModemConfig::answerDataBeginCmd },
+    { "ModemAnswerVoiceBeginCmd",	&ModemConfig::answerVoiceBeginCmd },
+    { "ModemResetCmds",			&ModemConfig::resetCmds },
+    { "ModemResetCmd",			&ModemConfig::resetCmds },
+    { "ModemDialCmd",			&ModemConfig::dialCmd },
+    { "ModemFlowControlCmd",		&ModemConfig::flowControlCmd },
+    { "ModemSetupAACmd",		&ModemConfig::setupAACmd },
+    { "ModemSetupDTRCmd",		&ModemConfig::setupDTRCmd },
+    { "ModemSetupDCDCmd",		&ModemConfig::setupDCDCmd },
+    { "ModemNoAutoAnswerCmd",		&ModemConfig::noAutoAnswerCmd },
+    { "ModemEchoOffCmd",		&ModemConfig::echoOffCmd },
+    { "ModemVerboseResultsCmd",		&ModemConfig::verboseResultsCmd },
+    { "ModemResultCodesCmd",		&ModemConfig::resultCodesCmd },
+    { "ModemOnHookCmd",			&ModemConfig::onHookCmd },
+    { "ModemSoftResetCmd",		&ModemConfig::softResetCmd },
+    { "ModemWaitTimeCmd",		&ModemConfig::waitTimeCmd },
+    { "ModemCommaPauseTimeCmd",		&ModemConfig::pauseTimeCmd },
+    { "ModemMfrQueryCmd",		&ModemConfig::mfrQueryCmd },
+    { "ModemModelQueryCmd",		&ModemConfig::modelQueryCmd },
+    { "ModemRevQueryCmd",		&ModemConfig::revQueryCmd },
+    { "ModemSendBeginCmd",		&ModemConfig::sendBeginCmd },
+    { "Class1Cmd",			&ModemConfig::class1Cmd },
+    { "Class2Cmd",			&ModemConfig::class2Cmd },
+    { "Class2BORCmd",			&ModemConfig::class2BORCmd },
+    { "Class2RELCmd",			&ModemConfig::class2RELCmd },
+    { "Class2CQCmd",			&ModemConfig::class2CQCmd },
+    { "Class2AbortCmd",			&ModemConfig::class2AbortCmd },
+    { "Class2CQQueryCmd",		&ModemConfig::class2CQQueryCmd },
+    { "Class2DCCQueryCmd",		&ModemConfig::class2DCCQueryCmd },
+    { "Class2TBCCmd",			&ModemConfig::class2TBCCmd },
+    { "Class2CRCmd",			&ModemConfig::class2CRCmd },
+    { "Class2PHCTOCmd",			&ModemConfig::class2PHCTOCmd },
+    { "Class2BUGCmd",			&ModemConfig::class2BUGCmd },
+    { "Class2LIDCmd",			&ModemConfig::class2LIDCmd },
+    { "Class2DCCCmd",			&ModemConfig::class2DCCCmd },
+    { "Class2DISCmd",			&ModemConfig::class2DISCmd },
+    { "Class2DDISCmd",			&ModemConfig::class2DDISCmd },
+    { "Class2CIGCmd",			&ModemConfig::class2CIGCmd },
+    { "Class2PTSCmd",			&ModemConfig::class2PTSCmd },
+    { "Class2SPLCmd",			&ModemConfig::class2SPLCmd },
+    { "Class2PIECmd",			&ModemConfig::class2PIECmd },
+    { "Class2NRCmd",			&ModemConfig::class2NRCmd },
+    { "TagLineFont",			&ModemConfig::tagLineFontFile },
+    { "TagLineFormat",			&ModemConfig::tagLineFmt },
+};
+static const struct {
+    const char*		 name;
+    u_int ModemConfig::* p;
+} fillorders[] = {
+    { "ModemRecvFillOrder",		&ModemConfig::recvFillOrder },
+    { "ModemSendFillOrder",		&ModemConfig::sendFillOrder },
+    { "ModemFrameFillOrder",		&ModemConfig::frameFillOrder },
+};
+static const struct {
+    const char*		 name;
+    u_int ModemConfig::* p;
+} numbers[] = {
+    { "ModemResetDelay",		&ModemConfig::resetDelay },
+    { "ModemBaudRateDelay",		&ModemConfig::baudRateDelay },
+    { "ModemMaxPacketSize",		&ModemConfig::maxPacketSize },
+    { "ModemInterPacketDelay",		&ModemConfig::interPacketDelay },
+    { "FaxT1Timer",			&ModemConfig::t1Timer },
+    { "FaxT2Timer",			&ModemConfig::t2Timer },
+    { "FaxT4Timer",			&ModemConfig::t4Timer },
+    { "ModemDialResponseTimeout",	&ModemConfig::dialResponseTimeout },
+    { "ModemAnswerResponseTimeout",	&ModemConfig::answerResponseTimeout },
+    { "ModemPageStartTimeout",		&ModemConfig::pageStartTimeout },
+    { "ModemPageDoneTimeout",		&ModemConfig::pageDoneTimeout },
+    { "Class1TCFResponseDelay",		&ModemConfig::class1TCFResponseDelay },
+    { "Class1SendPPMDelay",		&ModemConfig::class1SendPPMDelay },
+    { "Class1SendTCFDelay",		&ModemConfig::class1SendTCFDelay },
+    { "Class1TrainingRecovery",		&ModemConfig::class1TrainingRecovery },
+    { "Class1RecvAbortOK",		&ModemConfig::class1RecvAbortOK },
+    { "Class1FrameOverhead",		&ModemConfig::class1FrameOverhead },
+    { "Class1RecvIdentTimer",		&ModemConfig::class1RecvIdentTimer },
+    { "Class1TCFMaxNonZero",		&ModemConfig::class1TCFMaxNonZero },
+    { "Class1TCFMinRun",		&ModemConfig::class1TCFMinRun },
+    { "PercentGoodLines",		&ModemConfig::percentGoodLines },
+    { "MaxConsecutiveBadLines",		&ModemConfig::maxConsecutiveBadLines },
+};
+fxBool
+ModemConfig::parseItem(const char* tag, const char* value)
+{
+    int i;
+    for (i = (sizeof ( atcmds ) / sizeof ( atcmds [0])) -1; i >= 0; i--)
+	if ((strcasecmp( tag ,  atcmds[i].name )==0) ) {
+	    (*this).*atcmds[i].p = parseATCmd(value);
+	    return (((fxBool)1) );
+	}
+    for (i = (sizeof ( fillorders ) / sizeof ( fillorders [0])) -1; i >= 0 ; i--)
+	if ((strcasecmp( tag ,  fillorders[i].name )==0) ) {
+	    (*this).*fillorders[i].p = getFill(value);
+	    return (((fxBool)1) );
+	}
+    for (i = (sizeof ( numbers ) / sizeof ( numbers [0])) -1; i >= 0 ; i--)
+	if ((strcasecmp( tag ,  numbers[i].name )==0) ) {
+	    (*this).*numbers[i].p = atoi(value);
+	    return (((fxBool)1) );
+	}
+    fxBool recognized = ((fxBool)1) ;
+    if ((strcasecmp( tag ,  "ModemType" )==0) )
+	type = value;
+    else if ((strcasecmp( tag ,  "ModemSetVolumeCmd" )==0) )
+	setVolumeCmds(value);
+    else if ((strcasecmp( tag ,  "ModemFlowControl" )==0) )
+	flowControl = getFlow(value);
+    else if ((strcasecmp( tag ,  "ModemMaxRate" )==0)  || (strcasecmp( tag ,  "ModemRate" )==0) )
+	maxRate = getRate(value);
+    else if ((strcasecmp( tag ,  "ModemWaitForConnect" )==0) )
+	waitForConnect = getBoolean(value);
+    else if ((strcasecmp( tag ,  "Class2RecvDataTrigger" )==0) )
+	class2RecvDataTrigger = value;
+    else if ((strcasecmp( tag ,  "Class2XmitWaitForXON" )==0) )
+	class2XmitWaitForXON = getBoolean(value);
+    else
+	recognized = ((fxBool)0) ;
+    return (recognized);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C
new file mode 100644
index 00000000000..a6527a5cbd4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash6.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed old-abort
+// Should be fixed by:
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+// 
+// 	* cp-decl.c (start_function): Avoid a null-reference on CTYPE.
+
+template<int>
+class Program {
+} ;
+
+class Program<0> {
+public:
+   inline friend float EvalNextArg()
+        { return 1.0 ; }
+} ;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C
new file mode 100644
index 00000000000..b2af4310d1b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash60.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X
+{
+public:
+    X ();
+    int	f[4];
+};
+
+// Note that we mistakenly initialize the array data member as if it
+// was scalar
+X::X () : f (0) {}// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C
new file mode 100644
index 00000000000..4d3bbc4c693
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash61.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed old-abort
+        template <class TP> class sapp { };
+        class foo {};
+        extern foo& __iomanip_setw (foo&, TP);// ERROR -  type spec.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C
new file mode 100644
index 00000000000..77b9fc84763
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash62.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#include <iostream.h>
+
+	void
+	fubar(ostream* out, const char* string)
+	{
+  	  (*out) << string << endl;
+  	  return;
+	}
+
+	int
+	main()
+	{
+  	  // Declare a ref and a pointer to the same ostream.
+  	  //
+  	  ostream* out = &cerr;
+  	  ostream& die = cerr;
+
+  	  // Valid call to fubar.
+  	  //
+  	  fubar(out, "First line.");
+  
+  	  // Invalid call to fubar. (1st arg is an ostream&. fubar expects
+  	  // ostream*.)This should be a syntax error, but g++ does not catch it.
+  	  // Call to this function results in a bus error in fubar when the 1st
+  	  // arg is dereferenced.
+  	  //
+  	  fubar(die, "Second line.");// ERROR -  cannot convert .die.*
+  
+  	  return 1;
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C
new file mode 100644
index 00000000000..84f8fc57624
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash63.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class String
+   {
+ public:
+   String (const char *str);
+   };
+
+class UnitList 
+   {
+ public:
+   UnitList (...);
+   };
+
+UnitList unit_list (String("keV"));
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C
new file mode 100644
index 00000000000..310241850f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash64.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed old-abort
+typedef long unsigned int size_t;
+typedef void (*RF_Ptr)(void *);
+
+struct _im_pers_mem_spec {
+  inline _im_pers_mem_spec(void );
+  inline _im_pers_mem_spec(auto int of, auto int n);
+};
+
+struct _type_desc {
+  _type_desc(char *, int , RF_Ptr , int , int ,...);
+};
+
+struct metatype { int base_list; };
+
+static _type_desc _type_metatype("metatype", sizeof(metatype),
+  (RF_Ptr)0, 0, 1, 1,
+  _im_pers_mem_spec( ((size_t)&((( metatype *)0)-> base_list )) , 1));
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C
new file mode 100644
index 00000000000..132651e90a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash65.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class X {
+public:  
+  virtual const char* 	XY(const void* val) const = 0;
+};
+
+
+class Y : public X {
+public:
+  using X::xy;// ERROR -  no memb.*
+
+  using X::z;// ERROR -  no memb.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C
new file mode 100644
index 00000000000..878957b84e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash66.C
@@ -0,0 +1,137 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed old-abort
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned long ulong;
+extern int swap_endian;			 
+inline ushort
+swapshort(ushort value)
+{
+    value &= 0xffff;
+    return ((value << 8) | (value >> 8));
+}
+struct eshort
+{
+    ushort	data;			 
+    operator ushort() { return swap_endian ? swapshort(data) : data;}
+    eshort(ushort t) { data = swap_endian ? swapshort(t) : t;}
+    eshort() {}
+};
+inline ulong
+swaplong(ulong value)
+{
+    ulong v = (value << 16) | (value >> 16);
+    return ((v >> 8) & 0x00ff00ff) | ((v << 8) & 0xff00ff00);
+};
+struct elong
+{
+    ulong	data;			 
+    operator ulong() { return swap_endian ? swaplong(data) : data;}
+    elong(ulong t) { data = swap_endian ? swaplong(t) : t; }
+    elong() {}
+};
+struct digiheader
+{
+    uchar	type[2];		 
+    eshort	soft_version;		 
+    eshort	lo_boot_rev;		 
+    eshort	hi_boot_rev;		 
+    eshort	load_segment;		 
+    eshort	length;			 
+    eshort	exec_start;		 
+    eshort	image_offset;		 
+    elong	startup_code[2];	 
+    elong	checksum;		 
+};
+extern void uncompress(uchar* buf, ulong len);
+extern ulong compress(char* filename, uchar* buffer, ulong);
+struct filehdr
+{
+    eshort	f_magic;		 
+    eshort	f_nscns;		 
+    elong	f_timdat;		 
+    elong	f_symptr;		 
+    elong	f_nsyms;		 
+    eshort	f_opthdr;		 
+    eshort	f_flags;		 
+};
+struct aouthdr
+{
+    eshort	magic;			 
+    eshort	vstamp;			 
+    elong	tsize;			 
+    elong	dsize;			 
+    elong	bsize;			 
+    elong	entry;			 
+    elong	text_start;		 
+    elong	data_start;		 
+    elong	bss_start;		 
+    elong	gprmask;		 
+    elong	cprmask[4];		 
+    elong	gp_value;		 
+};
+struct scnhdr
+{
+    char	s_name[8];		 
+    elong	s_paddr;		 
+    elong	s_vaddr;		 
+    elong	s_size;			 
+    elong	s_scnptr;		 
+    elong	s_relptr;		 
+    elong	s_lnnoptr;		 
+    eshort	s_nreloc;		 
+    eshort	s_nlnno;		 
+    elong	s_flags;		 
+};
+int file_little_endian;			 
+int host_little_endian;			 
+int swap_endian;			 
+int docheck;				 
+int expand;				 
+ulong memsize;				 
+ulong compression_quality;		 
+char *compressfile;			 
+int debug_level;			 
+extern "C" int getopt (int, char**, char*);
+int
+main(int argc, char** argv)
+{
+    uchar checksum;
+    uchar docrc;
+    ulong len;
+    ulong maxlen;
+    int i;
+    int c;
+    int magic;
+    int tsize;
+    int dsize;
+    int quality;
+    char dummy;
+    uchar* code;
+    uchar* buf;
+    char* ap;
+    digiheader *dh;
+    compression_quality = 10000;
+    docheck = 0;
+    while ((c = getopt(argc, argv, "Ccdf:k:q:x:")) != -1)
+    {
+	switch (c)
+	{
+	default:
+	    goto usage;
+	}
+    }
+    if ((expand && (docheck || compressfile || quality)) ||
+	(quality && !compressfile))
+    {
+    usage:
+	return(2);
+    }
+    if (compressfile)
+    {
+	dh->image_offset = len;
+	
+	len += compress(compressfile, code + len, maxlen - len);
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C
new file mode 100644
index 00000000000..f63ba5ddf3f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash67.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed old-abort
+#pragma comment(exestr, "@(#) errno.h 10.2 92/03/26 ")
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C
new file mode 100644
index 00000000000..b209bd891c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash68.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// Special g++ Options: -w -O
+// GROUPS passed old-abort
+class   RWDlist
+{
+public:
+  RWDlist& operator=(const RWDlist&);
+};
+class DataItemRWGDlist : public RWDlist {};
+
+class Base {};
+class DataItemList : public Base
+{
+  private:
+  DataItemRWGDlist m_diList;
+};      
+
+class StatementGroup
+{
+  public:
+    DataItemList   dataItemList;
+    StatementGroup(const StatementGroup&);
+};
+
+StatementGroup::StatementGroup(const StatementGroup& sg)
+{
+  dataItemList = sg.dataItemList;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C
new file mode 100644
index 00000000000..c55cab97848
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash7.C
@@ -0,0 +1,47 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class Vector
+{
+  int sz;
+  T *v;
+public:
+  Vector (int s) : sz (s) { v = new T[sz]; }
+  ~Vector () { delete[] v; }
+  T &operator[] (int i) { return v[i]; }
+  int size () { return sz; }
+};
+
+template<class T>// ERROR - previous definition of T
+struct Comparator
+{
+  typedef T T;// ERROR - use of template type T in typedef to T
+  static lessthan (T &a, T &b) { return a < b; }
+};
+
+template<class Comp>
+struct Sort
+{
+  static void sort (Vector<Comp::T> &);// ERROR - use of bad T
+};
+
+template<class Comp>
+void Sort<Comp>::sort (Vector<Comp::T> &v)// ERROR - use of bad T
+{
+  int n = v.size ();
+
+  for (int i = 0; i < n - 1; i++)
+    for (int j = n - 1; i < j; j--)
+      if (Comp::lessthan (v[j], v[j - 1]))
+	{
+	  typename Comp::T temp = v[j];
+	  v[j] = v[j - 1];
+	  v[j - 1] = temp;
+	}
+}
+
+void
+f (Vector<int> &vi)
+{
+  Sort<Comparator<int> >::sort (vi);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C
new file mode 100644
index 00000000000..701452ab6c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash8.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed old-abort
+template<int a, int b>
+class Elvis
+{// ERROR - in template.*
+} ;
+
+template<int a>
+class Elvis<0>// ERROR - .*
+{
+   int geta() { return a ; }
+} ;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C b/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C
new file mode 100644
index 00000000000..a4155ef6bb5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/crash9.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed old-abort
+class A {};
+
+class SimQuery
+{
+public:
+  SimQuery();
+  ~SimQuery();
+  int SetMeshFile(char name[]);
+protected:
+  A& scaling;
+  A* mesh;
+};
+
+SimQuery::SimQuery():scaling(A) {}// ERROR - .*
+
+SimQuery::~SimQuery() {}// ERROR - 
+
+int SimQuery::SetMeshFile(char name[])
+{// ERROR - 
+  mesh = new C;// ERROR - .*
+  return 0; // needed to avoid warning of reaching end of non-void fn
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C
new file mode 100644
index 00000000000..eaf487159d8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors1.C
@@ -0,0 +1,27 @@
+// GROUPS passed constructors
+// Check that global level object constructors get called.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1;
+	int f2;
+	base (int arg1, int arg2);
+};
+
+
+base global_base(0x55, 0xff);
+
+int main ()
+{
+	if ((global_base.f1 != 0x55) || (global_base.f2 != 0xff))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+base::base(int arg1, int arg2)
+{
+	f1 = arg1;
+	f2 = arg2;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C
new file mode 100644
index 00000000000..2f83ce1cdb8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors2.C
@@ -0,0 +1,28 @@
+// GROUPS passed constructors
+// Check that sub-words sized class members are correctly set
+// by constructors.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int f1 : 8;
+	int f2 : 8;
+	base (int arg1, int arg2);
+};
+
+
+base global_base(0x55, 0x7e);
+
+int main ()
+{
+	if ((global_base.f1 != 0x55) || (global_base.f2 != 0x7e))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+base::base(int arg1, int arg2)
+{
+	f1 = arg1;
+	f2 = arg2;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C b/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C
new file mode 100644
index 00000000000..755d547b022
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ctors3.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed constructors
+class A;
+
+class B {
+public:
+    B();
+static A sa;
+};
+
+class A {
+public:
+    A(int i);
+};
+
+A B::sa(1);
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C
new file mode 100644
index 00000000000..57f3b426108
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt1.C
@@ -0,0 +1,44 @@
+// Build don't link: 
+// GROUPS passed conversions
+#include <iostream.h>
+
+class Thing
+{
+public:
+      typedef enum { GOOD_THING, BAD_THING, } ThingType ; // ERROR - comma
+	Thing (ThingType type) : thingType (type) { }
+	~Thing () { }
+private:
+	ThingType thingType ;
+} ;
+
+class Group
+{
+public:
+      typedef enum { THIS_GROUP, THAT_GROUP, } GroupType ; // ERROR - comma
+	Group (GroupType type) : groupType (type), groupCount (0) { }
+	~Group () { }
+	void append (Thing* const &entry) { groupCount ++ ; }
+	operator GroupType () const { return groupType ; }
+	operator int () const { return groupCount ; } // remove this and problem gone
+
+private:
+	int groupCount ;
+	GroupType groupType ;
+} ;
+
+inline Group& operator += (Group& g, Thing* const t)
+{
+	g.append (t) ;
+	return g ; // complaint is here
+}
+
+int
+main (int argc, char** argv)
+{
+	Group g (Group::THIS_GROUP) ;
+
+	g += new Thing (Thing::GOOD_THING) ;
+	cout << "Group type is " << (Group::GroupType) g << endl ;
+	return 0 ;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C
new file mode 100644
index 00000000000..76ae1561f3a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt2.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed conversions
+void f(const short & s) { }
+
+   int
+main() {
+   f(0);
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C
new file mode 100644
index 00000000000..6ab8465c6df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt3.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed conversions
+class GttObject {};
+class GctObject: virtual public GttObject {};
+class NDAMObject: virtual public GttObject, virtual public GctObject {};
+class GctHashObject: virtual public GctObject {};
+
+class GctRef: virtual public GctHashObject
+{ public: operator void*() const; };
+
+class NDAMAssemblerObject: virtual public NDAMObject {};
+class GctReferenceObject: virtual public GctHashObject {};
+class NDAMValue: virtual public NDAMAssemblerObject, public GctReferenceObject {};
+
+class nnyacc;
+class NDAMValueRef : virtual public NDAMObject, public GctRef 
+{
+  NDAMValue *operator->() const;	 
+  operator NDAMValue *() const;	 
+friend class nnyacc;
+};
+
+typedef void* Pix;
+class NDAMValueRefSLList
+{
+public:
+  NDAMValueRefSLList();
+  NDAMValueRefSLList(const NDAMValueRefSLList& a);
+  ~NDAMValueRefSLList();
+  NDAMValueRef& operator () (Pix p) const;
+};
+
+struct bar
+{
+  NDAMValueRefSLList *valueList;
+};
+
+class nnyacc
+{
+public:
+      static void assign(void*& lval, void*& rval); // ERROR - candidates
+};
+
+void
+foo (bar yylval, bar *yyvsp)
+{
+  nnyacc::assign(yylval.valueList, yyvsp[0].valueList);// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C
new file mode 100644
index 00000000000..3d9f475b679
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt4.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed conversions
+class A {};
+
+template <class TP>
+class B
+{
+  A &(*_f) (A &, TP);
+  TP _a;
+public:
+  B (A &(*f) (A &, TP), TP a) : _f (f), _a (a) {}
+  friend A &operator<< (A &o, const B<TP> &m)
+    { (*m._f) (o, m._a); return o; }
+};
+
+A &setw (A &, int);
+B<int> setw (int n)
+{
+  return B<int> (setw, n);
+}
+
+A x;
+
+void f ()
+{
+  x << setw (2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C b/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C
new file mode 100644
index 00000000000..5eeea6e6393
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/cvt5.C
@@ -0,0 +1,27 @@
+// GROUPS passed conversions
+// Build don't link:
+typedef unsigned long Array[3];
+
+void sample(const unsigned long (&an_array)[3]);
+
+class Sample
+  {
+ public:
+  void simple(const Array &an_array);
+  static void sample(const Array &an_array);
+  };
+
+class A
+  {
+ public:
+  Array array;
+  };
+
+  Sample s;
+
+  void simple(const A &a)
+    {
+    s.simple(a.array);
+    sample(a.array);
+    Sample::sample(a.array);
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C b/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C
new file mode 100644
index 00000000000..af9752693c7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/def-fns1.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed default-functions
+class dictionary {
+public:
+  dictionary (int);
+};
+
+class symbol {
+public:
+  symbol ();
+};
+
+// a default ctor should not be generated for hyphenation_language,
+// since a ctor has already been declared; if one is generated, there
+// will be an error about not enough args to the ctor for dictionary,
+// since dictionary only defines a ctor taking an int (it ALSO should
+// not get a default ctor)
+struct hyphenation_language {
+  symbol name;
+  dictionary exceptions;
+  hyphenation_language(symbol nm) : name(nm), exceptions(501) {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C b/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C
new file mode 100644
index 00000000000..816c3009d2e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/delete1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed operator-delete
+/* ARM $5.3.4 */
+void f(char *p, char *q[], const char *r, const char *s[])
+{
+  delete 0;             /* illegal: non-pointer */// ERROR - .*expected pointer.*
+  delete (char*)0;      /* no effect */
+  delete p;
+  delete[] q;
+  delete[4] q;          /* ANSI forbids size arg */// ERROR -  anachronistic .*
+  delete r;             /* no longer illegal: const */
+  delete[] s;
+  delete[4] s;          /* ANSI forbids size arg */// ERROR -  anachronistic.*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C b/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C
new file mode 100644
index 00000000000..f2bacde1185
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/delete2.C
@@ -0,0 +1,25 @@
+// GROUPS passed operator-delete
+// Check that using the delete operator with a null pointer
+// is allowed (as called for by The Book, pg. 259)
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int member;
+};
+
+base* bp;
+
+void test ()
+{
+	delete bp;
+}
+
+int main ()
+{
+	bp = (base *) 0;
+	test ();
+
+	printf ("PASS\n");
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C
new file mode 100644
index 00000000000..dbbfa80f9f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors1.C
@@ -0,0 +1,56 @@
+// GROUPS passed destructors
+// Check that when an object of a derived class is (implicitly)
+// destructed (on exit from the block in which it is declared)
+// that the destructor for the base class also gets executed.
+//
+// (also check that this execution doesn't seg-fault)
+
+extern "C" void printf (char *, ...); 
+
+int derived_destructed;
+int base_destructed;
+
+struct base {
+  int base_data_member;
+
+  base()
+  {
+    base_data_member = 0x5e5e;
+  }
+  ~base()
+  {
+    base_destructed = 0x781f;
+  }
+};
+
+struct derived : public base {
+  int derived_data_member;
+
+  derived()
+  {
+    derived_data_member = 0xe5e5;
+  }
+  ~derived()
+  {
+    derived_destructed = 0xf178;
+  }
+};
+
+
+void test2 ();
+
+int main ()
+{
+	test2 ();
+	if ((base_destructed != 0x781f) || (derived_destructed != 0xf178))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+void test2 ()
+{
+	derived derived_object;
+
+	derived_object.derived_data_member = 99;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C
new file mode 100644
index 00000000000..511ab7f231c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors2.C
@@ -0,0 +1,74 @@
+// GROUPS passed destructors
+// Check that virtual destructors work correctly.  Specifically,
+// check that when you destruct an object of a derived class for
+// which the base class had an explicitly declared virtual destructor
+// no infinite recursion occurs.
+//
+// Bug description:
+//    The generated g++ code apparently calls the base class destructor via
+//    the virtual table, rather than directly. This, of course, results in the
+//    infinite recursion.
+
+extern "C" void printf (char *, ...); 
+
+int errors = 0;
+
+struct base {
+	int member;
+	base();
+	virtual ~base();
+};
+  
+base::base()
+{
+}
+
+base::~base()
+{
+}
+
+struct derived : public base
+{
+	int member;
+	derived();
+	~derived();
+};
+  
+derived::derived() : base()
+{
+}
+
+int derived_destructor_calls = 0;
+
+extern void exit (int);
+
+derived::~derived()
+{
+	if (++derived_destructor_calls > 2)
+		errors++;
+}
+
+void test ();
+
+int main ()
+{
+	test ();
+
+	if (errors)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+base* bp;
+
+void test()
+{
+	derived a;
+
+	a.member = 99;
+	bp = new derived;
+	delete bp;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C b/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C
new file mode 100644
index 00000000000..a1ca853cf91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/dtors3.C
@@ -0,0 +1,66 @@
+// GROUPS passed destructors
+// Check that member and base classes get properly destructed
+// when an object of a derived class is destructed via a pointer
+// to it which only has a "compile-time" type of "pointer-to-base".
+//
+// Note that in order for this test to work properly, the destructor
+// for the base class should be explicitly declared to be virtual.
+
+extern "C" void printf (char *, ...); 
+
+int member_destructor_calls = 0;
+int middle_destructor_calls = 0;
+
+struct member_type {
+	int data_member;
+	member_type () {}
+	~member_type ();
+};
+
+struct base {
+	int data_member;
+	base () {}
+	virtual ~base ();
+};
+
+struct middle : public base {
+	member_type member1;
+	member_type member2;
+	middle () {}
+	~middle ();		// should be implicitly virtual
+};
+
+struct derived : public middle {
+	member_type member1;
+	member_type member2;
+	//~derived () {}
+};
+
+int main ()
+{
+	base* bp = new derived;
+	delete bp;
+	derived *dp = new derived;
+	delete dp;
+
+	if ((member_destructor_calls != 8) || (middle_destructor_calls != 2))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+member_type::~member_type ()
+{
+	member_destructor_calls++;
+}
+
+base::~base ()
+{
+}
+
+middle::~middle ()
+{
+	middle_destructor_calls++;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C
new file mode 100644
index 00000000000..68639a1e143
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum-clash.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed arm
+enum color {red, yellow, green=20, blue};
+color c = 1;	// this should be an error// ERROR - .*
+int i = yellow;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C
new file mode 100644
index 00000000000..7ec648f4cd9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo {
+public:
+  enum bar { baz = 1, bat = 7 };
+};
+
+class derv : public foo { };
+
+main()
+{
+  foo::bar x = foo::baz;
+  derv::bar y = derv::bat;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C
new file mode 100644
index 00000000000..5c955d3587f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum10.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed enums
+class Type
+{
+	public:
+
+		enum name
+		{
+			A
+		};
+};
+
+class A
+{
+};
+
+class B: public A
+{
+	public:
+		B();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C
new file mode 100644
index 00000000000..7705aa36bd6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum11.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed enums
+class X
+{
+    enum
+    {
+       oneMask = 0x0000FFFF,
+       twoMask  = 0x000F0000,
+       thiMask = 0xFFF00000,
+    }; // ERROR - comma
+    unsigned int foo;
+
+public:
+    X (int) : foo (oneMask | twoMask ) {}               // No warning
+    X ()    : foo (oneMask | twoMask | thiMask) {}      // Warning
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C
new file mode 100644
index 00000000000..7d4eb7d0c42
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum12.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed enums
+enum Bool { False, True };
+
+enum Bool object;
+
+struct S
+{
+  Bool field:1;
+
+  void copy_enum_bit_field () const { object = field; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C
new file mode 100644
index 00000000000..ea6dfa71f23
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum13.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum COLOR { red, green, blue };
+ 
+struct S {
+    COLOR       color:2;
+};
+ 
+COLOR color;
+S object;
+ 
+void fubar ()
+{
+    color = object.color;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C
new file mode 100644
index 00000000000..192a2b4c468
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum14.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed enums
+  enum E { A = 0x80000000 };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C
new file mode 100644
index 00000000000..58da846f888
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo {
+public:
+  enum bar { baz = 1, bat = 7 };
+};
+
+class foo2 {
+public:
+  enum bar2 { baz2 = 1, bat2 = 7 };
+};
+
+class derv : public foo, public foo2 { };
+
+main()
+{
+  foo::bar x = foo::baz;
+  derv::bar2 y = derv::bat2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C
new file mode 100644
index 00000000000..38b7d3cdae8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum foo
+{
+  x = 0
+};
+
+enum bar
+{
+  // this used to say `x' wasn't a constant, because build_enumerator
+  // was getting the value of x wrapped around a NOP_EXPR.  It now
+  // strips them off before working on it, so we shouldn't get any
+  // errors  for this.
+  y = (x + 0x0000)
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C
new file mode 100644
index 00000000000..826ccd3b9f0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed enums
+class X {
+public:
+  enum { a };
+};
+
+enum { b = 1 };
+enum ok {  y = b };
+enum notok { z = X::a };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C
new file mode 100644
index 00000000000..2fa1ea3c9c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum5.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed enums
+enum Thing { FIRST, SECOND } ;
+
+main()
+{
+    Thing x = FIRST ;
+    x = 27 ;          // this line should be a type error.// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C
new file mode 100644
index 00000000000..de821487b0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum6.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed enums
+class X {
+  private:
+    enum E1 {a1, b1};
+  public:
+    enum E2 {a2, b2};
+    };
+
+void h(X* p) {
+    X::E2 e2;
+    int x2 = X::a2;
+
+    X::E1 e1;
+    int x1 = X::a1;		// Should be rejected, and is.// ERROR - .*
+    }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C
new file mode 100644
index 00000000000..5a397d7f361
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum7.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed enums
+enum color { red, green, blue, orange, brown };
+
+struct s {
+      enum color      field:2; // ERROR - too small
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C
new file mode 100644
index 00000000000..d9380ad09ef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum8.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed enums
+class foo1
+{
+ public:
+   enum foo1_enum
+   {
+      ENUM1,
+      ENUM2,
+   }; // ERROR - comma
+};
+
+   
+class foo2 
+{
+ private:
+   enum foo1::foo1_enum	Enum;
+};
+
+
+class foo3
+{
+ private:
+   foo1::foo1_enum Enum;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C b/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C
new file mode 100644
index 00000000000..f04deb13a83
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/enum9.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed enums
+enum fig {
+    figgy,
+    pudding,
+}; // ERROR - comma
+
+class X {
+public:
+    static fig (*open)(void *thing, const char *filename);
+    static fig (*parse)(void *thing);
+};
+
+enum fig (*X::open)(void *thing, const char *filename) = 0;
+fig (*X::parse)(void *thing) = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C
new file mode 100644
index 00000000000..9450d7671c6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class A { };
+
+int i = A::_ter;// ERROR -  ._ter.*
+int j = A::term;// ERROR -  .term.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C
new file mode 100644
index 00000000000..24ddcaa1661
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg10.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  virtual static int f () = 0;// ERROR -  member `f' cannot be declared both virtual and static.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C
new file mode 100644
index 00000000000..de5ed8a1316
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg11.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed error-messages
+void foo (mutable int x);// ERROR -  non-member `x' cannot be declared `mutable'.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C
new file mode 100644
index 00000000000..0b59ba0c8da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg12.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  friend mutable int x ();// ERROR -  non-object member `x' cannot be declared `mutable'
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C
new file mode 100644
index 00000000000..0bfb4c22414
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg2.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+typedef void (*pfv)(double, double);
+extern "C" typedef void (*pfv)(double, double);// ERROR -  multiple.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C
new file mode 100644
index 00000000000..1d115e6c46a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg3.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed error-messages
+#include <fstream.h>
+#include <iomanip.h>
+
+// This error should not appear:
+// bug.C: In method `test::test(const class test &)':
+// bug.C:8: field `' not in immediate context
+
+class test{
+public:
+	int	flags;
+	test()	{};
+	};
+
+int main()
+
+{
+return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C
new file mode 100644
index 00000000000..72f6150a882
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class X {
+public:
+    static int x;// ERROR -  previous.*
+    static int y;// ERROR -  previous.*
+};
+
+unsigned X::x;// ERROR -  conflict.*
+unsigned X::y;// ERROR -  conflict.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C
new file mode 100644
index 00000000000..37b956c568f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg5.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {};
+~foo () {}// ERROR -  destructors must be member functions.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C
new file mode 100644
index 00000000000..ce60f0d4567
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg6.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  ~bar () {}// ERROR -  destructor `bar' must match class name `foo'.*
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C
new file mode 100644
index 00000000000..5971806fa46
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg7.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  volatile int () {}// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C
new file mode 100644
index 00000000000..a2ad4df947d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg8.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed error-messages
+operator int ;// ERROR -  declaration of `operator int' as non-function.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C
new file mode 100644
index 00000000000..0714de696cc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/err-msg9.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed error-messages
+class foo {
+public:
+  int ~foo ();// ERROR -  return type specification for destructor invalid.*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C
new file mode 100644
index 00000000000..8d942c7e2ed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend1.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed friends
+class A
+{
+private:
+  A () {}
+
+friend struct B;
+};
+
+class B
+{
+public:
+  A a;
+};
+
+B b;
+
+main () {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C
new file mode 100644
index 00000000000..5b1333f7b80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend2.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed friends
+class X {
+  int a;
+friend void friend_set (X*, int);
+};
+
+void friend_set (X *p, int i) { p->a = i; }
+
+void f()
+{
+  X obj;
+  friend_set (&obj, 10);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C
new file mode 100644
index 00000000000..1fa48a8c527
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend3.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed friends
+class B {
+
+   friend class A;
+
+   enum {
+      bEnum = 1,
+   }; // ERROR - comma
+
+   int bArray[ bEnum ];
+
+public:
+   void bFunction(int arg[ bEnum ]);
+};
+
+
+class A {
+   int aMember;
+
+public:
+   void aFunction(int a[B::bEnum])
+   {
+      B b;
+      b.bArray[ B::bEnum ] = aMember;
+   }
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C b/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C
new file mode 100644
index 00000000000..f19d81a9d0a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/friend4.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed friends
+// do_friend should complain that foo was declared as a friend of
+// A before A was defined
+struct A;
+struct B { friend A::foo (); };// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C b/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C
new file mode 100644
index 00000000000..79c5b51371d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/groff1.C
@@ -0,0 +1,33 @@
+// GROUPS passed groff
+/* This should compile properly with the new overloading scheme.  */
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int win = 0;
+
+class symbol
+{
+public:
+  symbol(const char *p, int how = 0) {}
+  symbol() {}
+};
+
+class dictionary
+{
+public:
+  void *lookup(symbol s, void *v=0) { win = 1; }
+  void *lookup(const char *) {}
+};
+
+main()
+{
+  char buf[2048];
+  dictionary exceptions;
+  unsigned char *tem = new unsigned char[19 + 1];
+
+  exceptions.lookup (symbol (buf), tem);
+
+  printf (win ? "PASS\n" : "FAIL\n");
+  exit (! win);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init1.C b/gcc/testsuite/g++.old-deja/g++.brendan/init1.C
new file mode 100644
index 00000000000..4396906ed32
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init1.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed initialization
+  class Thing{
+  private:
+	  int x,y;
+  public:
+	  Thing (int v, int q) { x = v; q = y; }
+	  void doit(int);
+  };
+
+  Thing t(18,19);
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init10.C b/gcc/testsuite/g++.old-deja/g++.brendan/init10.C
new file mode 100644
index 00000000000..45b29853afd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init10.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct { int :0; } a;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init11.C b/gcc/testsuite/g++.old-deja/g++.brendan/init11.C
new file mode 100644
index 00000000000..69fd77c7c71
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init11.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct String {
+  char * string;
+  String(const char* st);  
+};
+
+extern char array [];
+static String sub = array;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init12.C b/gcc/testsuite/g++.old-deja/g++.brendan/init12.C
new file mode 100644
index 00000000000..f3c03e0690e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init12.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed array-bindings
+char * bob();
+
+main()
+{
+    char a[1][2];
+    a[0] = bob();// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init13.C b/gcc/testsuite/g++.old-deja/g++.brendan/init13.C
new file mode 100644
index 00000000000..41f0fcf68bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init13.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct A {
+  operator int ();
+};
+ 
+int i = A();
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init2.C b/gcc/testsuite/g++.old-deja/g++.brendan/init2.C
new file mode 100644
index 00000000000..a9ec6f3bea6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init2.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed initialization
+// this should give an error in require_instantiated_type about not
+// being allowed to have an initializer list in an argument list.
+int f(int a = {1});// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init3.C b/gcc/testsuite/g++.old-deja/g++.brendan/init3.C
new file mode 100644
index 00000000000..91b2f7cbeb6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init3.C
@@ -0,0 +1,38 @@
+// GROUPS passed initialization
+// p2766: Make sure that members are initialized in order of declaration
+// in the class, not in order of specification in the mem-initializer list.
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void die () { printf ("FAIL\n"); exit (1); }
+
+class bar1 {
+public:
+  bar1 (int) { if (count != 0) die (); count = 1; }
+};
+
+class bar2
+{
+public:
+  bar2 (int) { if (count != 1) die (); count = 2; }
+};
+
+class foo
+{
+public:
+  bar1 a;
+  bar2 b;
+  foo (int, int);
+};
+
+// bar1 should get built before bar2
+foo::foo (int x, int y) : b(x), a(y) {}
+
+main()
+{
+  foo f (1, 2);
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init4.C b/gcc/testsuite/g++.old-deja/g++.brendan/init4.C
new file mode 100644
index 00000000000..c1d359281e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init4.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct CharList { int i; };
+
+const CharList& terminals = { 1 };// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init5.C b/gcc/testsuite/g++.old-deja/g++.brendan/init5.C
new file mode 100644
index 00000000000..112dcacbb94
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init5.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed initialization
+int main( int argc, char**argv, char** envp ){
+    char* domain = argv[1];
+    domain = domain? (char*)"component" : domain;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init6.C b/gcc/testsuite/g++.old-deja/g++.brendan/init6.C
new file mode 100644
index 00000000000..e49758adf1a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init6.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed initialization
+class Tag {
+public:
+	Tag(int i):value(i){}
+	int value;
+};
+
+extern const Tag myTag;
+extern const Tag myTag=9;
+
+// The compiler should not issue an error on this line; expand_static_init
+// should be checking that there's no initializer for this line, and thus
+// doesn't need to produce an error.
+extern const Tag myTag;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init7.C b/gcc/testsuite/g++.old-deja/g++.brendan/init7.C
new file mode 100644
index 00000000000..033da8f9fe8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init7.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed initialization
+struct myChoiceList
+{
+	int bla;
+	int blubb;
+	int brummbrumm;
+};
+
+extern const myChoiceList foo;
+
+extern const myChoiceList foo = {1,1,1};
+
+// finish_decl should have an exclusion so an error is not produced
+// for this line.
+extern const myChoiceList foo;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init8.C b/gcc/testsuite/g++.old-deja/g++.brendan/init8.C
new file mode 100644
index 00000000000..4818a41ab72
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init8.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed initialization
+class A
+{
+public:
+    A(const A & a) : i_member(a.i_member)
+    {
+    }
+    A(const int & i) : i_member(i)
+    {
+    }
+    union
+    {
+        int i_member;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/init9.C b/gcc/testsuite/g++.old-deja/g++.brendan/init9.C
new file mode 100644
index 00000000000..bad6416ef23
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/init9.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed initialization
+int FALSE = 0;
+class X {
+public:
+  static int FALSE;
+};
+
+// The compiler should NOT complain about redeclaration of the global
+// `FALSE' with this declaration...grokvardecl shouldn't be doing that.
+int X::FALSE = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/label1.C b/gcc/testsuite/g++.old-deja/g++.brendan/label1.C
new file mode 100644
index 00000000000..ff0b87c3097
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/label1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed labels
+// it should only give 1 error, about using an undefined label
+int main(void) { goto dummy; }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/label2.C b/gcc/testsuite/g++.old-deja/g++.brendan/label2.C
new file mode 100644
index 00000000000..bce21125d55
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/label2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed labels
+class X {
+public:
+    X();
+};
+void foo ()
+{
+X:  ::abort();
+    goto X;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/line1.C b/gcc/testsuite/g++.old-deja/g++.brendan/line1.C
new file mode 100644
index 00000000000..d76832e76c4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/line1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed error-messages
+typedef struct s S;// ERROR -  previous.*
+struct S { int member:1; };  // the lineno for this should be 2, not 0// ERROR -  conflicting types.*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C
new file mode 100644
index 00000000000..666ec256fb2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+int main( int argc, char**argv, char** envp ){
+    char* domain = argv[1];
+    domain = domain? (char*)"component" : domain;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C
new file mode 100644
index 00000000000..4d96926ccf8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc10.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// The compiler shouldn't give a `invalid operands to binary +' for this
+// case.
+enum flag { OFF, ON };
+enum BOOL { FALSE = (enum flag) 0, TRUE };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C
new file mode 100644
index 00000000000..043f6a5493e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc11.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// This should not complain about A::f being abstract.
+struct	A
+{
+	virtual int f() = 0;
+};
+
+struct	B : virtual A
+{
+	virtual int f()		{	return 1;	}
+	virtual int g() = 0;
+};
+
+struct	C: B
+{
+	int g()			{	return 2;	}
+};
+
+C	c;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C
new file mode 100644
index 00000000000..73db9bfccd4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc12.C
@@ -0,0 +1,16 @@
+// GROUPS passed miscellaneous
+extern "C" void exit (int);
+extern "C" int printf (char *, ...);
+
+/* Make sure cp-lex.c handles these properly--if this links, that means
+   it emitted the strings instead of __FUNCTION__.0, etc.  */
+
+int
+main()
+{
+  char *a = __FUNCTION__;
+  char *b = __PRETTY_FUNCTION__;
+
+  printf ("PASS\n");
+  exit (0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C
new file mode 100644
index 00000000000..57292a292cb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc13.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// This should only give warnings from duplicate_decls; it should not get
+// errors from push_overloaded_decl as well.
+
+extern "C"
+{
+  long unsigned int strlen(char*);// ERROR -  warning// ERROR -  warning.*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C
new file mode 100644
index 00000000000..7d57e30147d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc14.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+class X {
+public:
+    enum e {
+	New,// ERROR -  conflicts with other.*
+    }; // ERROR - comma
+
+    static int New(int);// ERROR -  declaration.*
+};
+
+main() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C
new file mode 100644
index 00000000000..e4dd53e0994
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc15.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// we shouldn't get any warnings or errors for this code
+struct A {
+        int     aa;
+};
+struct B : public A {
+};
+struct C : public A {
+};
+struct D : public C, public B {
+        void fun() { C::aa = 10; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C
new file mode 100644
index 00000000000..15e3946a0d3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc16.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// Using a typedef causes a compiler error
+typedef unsigned int Uint32;
+
+// Using a define so that there isn't a typedef works OK.
+//#define Uint32 unsigned int
+
+Uint32 func0(Uint32, Uint32)
+{
+   return 0;
+}
+
+Uint32 func1(Uint32, Uint32)
+{
+   return 1;
+}
+
+Uint32 (*mf[])(Uint32, Uint32) = {func0, func1};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C
new file mode 100644
index 00000000000..987618f9789
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc17.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+typedef int va_list;
+class ostream;
+class String {
+public:
+operator const char *() const;
+};
+class FwtErrorManager {
+public:
+    FwtErrorManager(ostream& err, const char *program);
+public:
+    void form(const char *format, ...);
+protected:
+    const String _program;	 
+private:
+    FwtErrorManager(const FwtErrorManager&);
+    void operator=(const FwtErrorManager&);
+};
+class FwtProgram: public FwtErrorManager {
+public:
+    FwtProgram();	 
+};
+class FwtArgOptions { };
+class FwtStdProgram: public FwtProgram, public FwtArgOptions {
+public:
+    FwtStdProgram();	 
+    void usage_if_not_complete();
+};
+void
+FwtStdProgram::usage_if_not_complete()
+{
+	FwtStdProgram& thisp = *this;
+	thisp.form("%s: error, there were unrecognized options",
+		   (char *) FwtErrorManager::_program);// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C
new file mode 100644
index 00000000000..d9aa99bbf78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// Should be fixed by:
+// Sun Jun 13 12:55:22 1993  Brendan Kehoe  (brendan@lisa.cygnus.com)
+//
+//	* cp-decl.c (grokvardecl): Don't complain about duplicate
+//	definitions of `extern "C"' declarations (parallelize it with how
+//	regular `extern' decls are handled).
+
+extern "C" double  _MaXdOuB, _MiNdOuB;
+extern "C" double  _MaXdOuB, _MiNdOuB;	// no error should be emitted for this
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C
new file mode 100644
index 00000000000..d632cb733f9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc3.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed miscellaneous-bugs
+// The compiler should not error about taking the addr of main in this example.
+class fred {
+private:
+  void main () {
+  }
+public:
+  fred ( ) {
+    &fred::main;
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C
new file mode 100644
index 00000000000..93aea92d31f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// This should not emit an error about A::~A() being redefined; we
+// should check that it is a pure virtual.
+class A {
+public:
+    virtual ~A() = 0;
+};
+
+A::~A() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C
new file mode 100644
index 00000000000..05eeed61e1e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc5.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+class A {
+    static A aa[2];
+};
+
+A A::aa[2]; // should be completely legal
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C
new file mode 100644
index 00000000000..b05c1f1da54
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc6.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// test that use of `inline' is forbidden when it should be
+inline int i;// ERROR - .*
+struct c { inline int i; };// ERROR - .*
+int foo (inline int i);// ERROR - .*
+inline class c; // ERROR - inline
+inline typedef int t; // ERROR - inline
+class d { inline friend class c; }; // ERROR - inline
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C
new file mode 100644
index 00000000000..078dbc9c858
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc7.C
@@ -0,0 +1,15 @@
+// GROUPS passed miscellaneous
+extern "C" void printf (char *, ...);
+
+main()
+{
+  int i = 0;
+  // Make sure build_unary_op correctly computes this.
+  int *pi = &(++i);
+  *pi = 4;
+
+  if (i != 4)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C
new file mode 100644
index 00000000000..7efad41d896
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc8.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+// used to say invalid lvalue in `&\'
+class foo {
+        int     a;
+    public:
+        foo(int a);
+};
+
+foo::foo(int a)
+{
+    foo::a=a;
+}
+
+main()
+{
+foo     obj(4);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C b/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C
new file mode 100644
index 00000000000..88071c6e04a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/misc9.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed miscellaneous
+//The program listed below produces the following error during compilation:
+//   % g++ bug17.cc
+//   bug17.cc: In method `class Y& Y::operator = (const class Y&)':
+//   bug17.cc:18: invalid use of non-lvalue array
+
+class X {
+public:
+   X& operator=(const X&) { return *this; }
+};
+
+struct S {
+   char c[10];
+   X x;
+};
+
+class Y {
+   S s;
+public:
+   const S& f() const { return s; }
+
+   Y& operator=(const Y& _Y) {
+      s = _Y.s;    // this line compiles
+      s = _Y.f();  // this line does not compile
+      return *this;
+   }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C b/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C
new file mode 100644
index 00000000000..79157b7607c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/mutable1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed mutable
+class foo;
+class bar {
+  mutable foo const *foobar;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C
new file mode 100644
index 00000000000..32aab3ee9c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+int x;
+class enclose {
+public:
+  int x;
+
+  class inner {
+  public:
+    void f (int i) {
+      x = i;// ERROR - .*
+    }
+  };
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C
new file mode 100644
index 00000000000..751440d1947
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest10.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A
+	{
+	public:
+		class B
+			{
+			public:
+				int f ();
+				void g (int);
+			private:
+				int b;
+			};
+	};
+
+int A::B::f ()
+	{
+	int val=b;
+	return val;
+	}
+
+void A::B::g (int val)
+	{
+	b = val;
+	}
+
+
+main ()
+	{
+	}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C
new file mode 100644
index 00000000000..4a57b383858
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest11.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A {
+  int x;
+
+  struct B {
+    int x;
+  };
+  struct C {
+    int bug (A::B &y);
+  };
+};
+
+int
+A::C::bug (A::B &y)
+{
+  return y.x;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C
new file mode 100644
index 00000000000..19286db1dc0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest12.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+struct enclose {
+  class nested;
+  nested *nptr;
+  class nested {
+    int x;
+  };
+  void f();
+};
+
+void enclose::f()
+{
+  nptr = new enclose::nested;  
+}
+
+void g()
+{
+  enclose obj;
+  obj.nptr = new enclose::nested;  
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C
new file mode 100644
index 00000000000..354e7bc35be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest13.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// The bug here is that wer'e getting a message about inner not
+// being a basetype itself.  I think it's because it's being
+// compared as the "inner" we knew about when it was forward-declared,
+// versus the "inner" we know about when it *has* been defined.
+
+class temp
+{
+public:
+        struct inner;
+        inner *trump()
+        {
+                return (tt);
+        }
+        struct inner
+        {
+                int ll;
+        }*tt;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C
new file mode 100644
index 00000000000..4a696af4dc2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest15.C
@@ -0,0 +1,37 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class BDDHeap {
+public:
+    BDDHeap();
+    BDDHeap(const BDDHeap&);
+
+    class Page {
+    public:
+	int i;
+    };
+    struct Pointer {
+	Page *page;
+	unsigned index;
+
+	Pointer();
+	Pointer(const BDDHeap& heap);
+    };
+
+    struct Half {
+	struct {
+	    Page *top;
+	    Page **tail;
+	} inuse;
+
+	Half();
+    };
+
+    Half half[2];
+    unsigned halfspace;
+};
+
+inline
+BDDHeap::Pointer::Pointer(const BDDHeap& heap):
+page(heap.half[heap.halfspace].inuse.top),
+index(0)
+{ }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C
new file mode 100644
index 00000000000..920ea0b5de5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest16.C
@@ -0,0 +1,41 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class BDDHeap {
+public:
+    BDDHeap();
+    BDDHeap(const BDDHeap&);
+
+    class Page {
+    public:
+	int i;
+    };
+    struct Pointer {
+	Page *page;
+	unsigned index;
+
+	Pointer();
+	Pointer(const BDDHeap& heap);
+    };
+
+    struct Half {
+	struct {
+	    Page *top;
+	    Page **tail;
+	} inuse;
+
+	Half();
+    };
+
+    Half half[2];
+    unsigned halfspace;
+};
+
+inline
+BDDHeap::Pointer::Pointer(const BDDHeap& heap):
+page(0),
+index(0)
+{
+    Page *x = heap.half[heap.halfspace].inuse.top;
+    page = x;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C
new file mode 100644
index 00000000000..f61c49ee9f5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest17.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class T {
+public:
+    typedef int I;
+    class Y {int y;};
+    typedef Y Z;
+};
+
+T::I i;
+T::Y y;
+T::Z z;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C
new file mode 100644
index 00000000000..e41def435f9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest18.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t2.C||.
+
+// This code demonstrates what appears to be a bug with nested types.
+// In C++, nested typedefs are not supposed to be visible outside
+// their class scopes but they apparently are in gcc 2.4.5.  This code
+// compiles fine in AT&T cfront 3.0.1, but will not compile with gcc.
+
+// If this class does not precede String, then the code will compile.
+
+class Another {
+public:
+    typedef int Length;
+};
+
+// If String does not define typedef int Length, then the code will
+// compile.
+
+class String {
+public:
+    typedef int Length;		// remove this and it will compile fine
+
+    int foo(Length length) const;
+};
+
+int String::foo(Length length) const {
+    return length;
+}
+
+// File ||t2.C|| ends here.
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C
new file mode 100644
index 00000000000..efa7ac5ee48
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest19.C
@@ -0,0 +1,40 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t3.C||.
+
+// This code demonstrates a variation of the same problem with nested
+// types.  In C++, nested typedefs are not supposed to be visible
+// outside their class scopes but they apparently are in gcc 2.4.5.
+// This code compiles fine in AT&T cfront 3.0.1, but gcc rejects it
+// with the messages given below.
+
+// If this class does not precede Expr, then the code will compile.
+
+class Another {
+public:
+    typedef int Boolean;
+    enum { FALSE, TRUE };
+};
+
+// If Expr does not define typedef int Boolean, then the code will
+// compile.
+
+class Expr {
+public:
+    typedef int Boolean;
+    enum { FALSE, TRUE };
+    void foo();
+    void call_something_with(Boolean);
+};
+
+// t3.C: In method `void  Expr::foo ()':
+//   t3.C:36: uninitialized const `Boolean'
+//   t3.C:36: parse error before `='
+//   t3.C:37: `argument' undeclared (first use this function)
+//   t3.C:37: (Each undeclared identifier is reported only once
+//   t3.C:37: for each function it appears in.)
+
+void Expr::foo() {
+    const Boolean argument = TRUE;
+    call_something_with(argument);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C
new file mode 100644
index 00000000000..4b55245e5f8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest2.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class A {
+protected:
+  class B {
+  public:
+    ~B();
+  private:
+    float _datum;
+  };
+private:
+  B *_b;
+};
+
+A::B::~B()
+{
+  _datum = 8.0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C
new file mode 100644
index 00000000000..297b08af825
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest20.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+// This is the first line of file ||t5.C||.
+
+// This code initializing an unnamed union inside a class appears to
+// be legal C++ input and compiles fine with AT&T cfront 3.0.1, but
+// gcc 2.4.5 complains about multiple initializations of the same
+// member.
+
+class Expr {
+public:
+    enum Type { undefined, slong, ulong, ldouble };
+    Expr();
+    Expr(Type type, const Expr* initializer);
+private:
+    Type type_;
+    union {
+	long slong_;
+	unsigned long ulong_;
+	long double ldouble_;
+    };
+};
+
+// Construct an undefined expression.
+
+Expr::Expr()
+    :
+    type_(undefined),
+    slong_(-1)
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C
new file mode 100644
index 00000000000..c4eb0ee78ab
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest21.C
@@ -0,0 +1,95 @@
+// GROUPS passed nested-classes
+#include <iostream.h>
+#include <stdio.h>
+
+static char output[1024];
+
+class BDDRetrace {
+public:
+    class Dump {
+    public:
+	virtual Dump& operator<<(char c) = 0;
+	virtual Dump& operator<<(int i) = 0;
+	virtual Dump& operator<<(double r) = 0;
+    };
+
+    class Dump1: public Dump {
+    public:
+	Dump& operator<<(char c);
+	Dump& operator<<(int i);
+	Dump& operator<<(double r);
+    };
+};
+
+class Dump2: public BDDRetrace::Dump {
+public:
+    BDDRetrace::Dump& operator<<(char c);
+    BDDRetrace::Dump& operator<<(int i);
+    BDDRetrace::Dump& operator<<(double r);
+};
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(char c)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%c", output, "1-", c);
+  strcpy (output, tempout);
+  return *this;
+}
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(int i)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%d", output, "1-", i);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+BDDRetrace::Dump1::operator<<(double r)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%1.0f", output, "1-", r);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(char c)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%c", output, "2-", c);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(int i)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%d", output, "2-", i);
+  strcpy (output, tempout);
+  return *this; }
+
+BDDRetrace::Dump&
+Dump2::operator<<(double r)
+{ char tempout[1024];
+  sprintf (tempout, "%s%s%1.0f", output, "2-", r);
+  strcpy (output, tempout);
+  return *this; }
+
+main()
+{
+    BDDRetrace::Dump1 d1;
+    Dump2 d2;
+
+    sprintf (output, " ");
+
+    d1 << 'a';
+    d1 << 1;
+    d1 << 1.0;
+
+    d2 << 'a';
+    d2 << 1;
+    d2 << 1.0;
+
+    if (strcmp (output, " 1-a1-11-12-a2-12-1") == 0)
+      printf ("PASS\n");
+    else
+      printf ("FAIL\n");
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C
new file mode 100644
index 00000000000..cd26c34d582
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest22.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class foo {
+public:
+   typedef int bar;
+   foo::bar    fb; // this line causes a syntax error!
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C
new file mode 100644
index 00000000000..e18398bf3fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest23.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class CS {
+public:
+    class PS {
+    };
+};
+
+class NCS: public CS {
+public:
+    class S: public PS {
+    };
+};
+
+int i;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C
new file mode 100644
index 00000000000..4fcc02c63d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest24.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+struct A {
+  A (){}
+};
+
+void foo ()
+{
+ struct B {};
+
+ struct S : B {
+   A a;
+ };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C
new file mode 100644
index 00000000000..16e7df88b45
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest3.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed nested-classes
+class X {
+public:
+  struct M2 { int m; };
+  M2 g(int);
+};
+
+
+X::M2 X::g(int i) { X::M2 m2; return m2; }
+
+main() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C b/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C
new file mode 100644
index 00000000000..34631f4f0cd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/nest4.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed nested-classes
+class vec {
+    class blah { };
+
+    ::vec::blah	satan( 0);// ERROR - .*
+    blah	herman( 0);// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C b/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C
new file mode 100644
index 00000000000..5341010822c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new-array.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed operator-new
+typedef struct {
+	int a;
+} AStruct;
+
+void MakeBug() {
+	AStruct *job;
+
+	// This used to crash, it should now give error(s).
+	job = new AStruct[];// ERROR - .*
+
+	job = new AStruct;
+}
+
+main () {
+	MakeBug();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new1.C b/gcc/testsuite/g++.old-deja/g++.brendan/new1.C
new file mode 100644
index 00000000000..09326d2ce58
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed operator-new
+typedef __SIZE_TYPE__ size_t;
+struct x { int a; void * operator new (size_t, void *); };
+struct x * f(void *p) { return new (p) x; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new2.C b/gcc/testsuite/g++.old-deja/g++.brendan/new2.C
new file mode 100644
index 00000000000..64b3d51e08a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new2.C
@@ -0,0 +1,67 @@
+// GROUPS passed operator-new
+// Check that if there is a user defined class-specific operator
+// new for a given class, that operator is invoked when a new
+// object of the class is requested, regardless of whether or not
+// there is also a constructor for the given class, and regardless
+// of whether or not the constructor for the given class is defined
+// before or after the new operator is even declared.
+
+extern "C" void printf (char *, ...); 
+
+typedef __SIZE_TYPE__ size_t;
+
+struct base {
+	int i;
+
+	base ()
+	{
+		i = 7;
+	}
+
+	void * operator new (size_t size);
+	void operator delete (void*);
+};
+
+class derived : public base {
+	int j;
+};
+
+int new_call_count = 0;
+int expected_size = 0;
+int errors = 0;
+
+int main ()
+{
+	base*		base_ptr;
+	derived*	derived_ptr;
+
+	expected_size = 4;
+	base_ptr = new base;
+	expected_size = 8;
+	derived_ptr = new derived ();
+
+	if ((new_call_count != 2) || (errors != 0))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+char allocation_space[1000];
+char* allocation_ptr = allocation_space;
+
+void base::operator delete (void* p)
+{
+}
+
+void *base::operator new (size_t size)
+{
+	char* return_value = allocation_ptr;
+
+	new_call_count++;
+	if (size != expected_size)
+		errors++;
+	allocation_ptr = allocation_ptr + size;
+	return (void*) return_value;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/new3.C b/gcc/testsuite/g++.old-deja/g++.brendan/new3.C
new file mode 100644
index 00000000000..9e7eb8a855f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/new3.C
@@ -0,0 +1,35 @@
+// GROUPS passed operator-new
+#include <stdio.h>
+#include <stdlib.h>
+
+int pass = 0;
+
+void *operator new(size_t sz){
+
+  void *p;
+
+  pass = 1;
+  p = malloc(sz);
+  return p;
+}
+
+class A {
+public:
+  A() {}
+  ~A() {}
+
+  int a;
+  int b;
+};
+
+
+int main()
+{
+  A *bb = new A[10];
+  delete [] bb;
+
+  if (pass)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C
new file mode 100644
index 00000000000..113f46bfdda
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ns1.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed old-abort
+struct B 
+{
+      void f(char); // ERROR - Cannot reduce access
+      void g(char);
+};
+  
+class C 
+{
+  int g();
+};// ERROR -  warning
+
+class D2 : public B 
+{
+  using B::f;  // ok: B is a base of D
+  using C::g;  // error: C isn't a base of D2
+}; // ERROR - type C is not a base type for type D2
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C
new file mode 100644
index 00000000000..6146eb401a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed operators
+struct A {
+	int x;
+};
+
+int operator()(A x,float y) { // MUST be a member function// ERROR - .*
+	return 1;
+}
+
+main() {
+	A x;
+	x(1.0); // ERROR - no match for call
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C
new file mode 100644
index 00000000000..ece06ef3d06
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators2.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed operators
+class X { };
+void operator[](X& a, X& b) {} // MUST be a member function// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C
new file mode 100644
index 00000000000..e068de3aa52
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators3.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed operators
+class X { };
+void operator->(X& a, X& b) {} // MUST be a member function// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C
new file mode 100644
index 00000000000..b56d26c073d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators4.C
@@ -0,0 +1,121 @@
+// GROUPS passed operators
+// Check that the & operator, when applied to a global function
+// or member function returns a proper value as long as the context
+// in which the result of & is used requires a pointer to a specific
+// unambigous (function-pointer) type.
+//
+// This test fails (in test5()) when compiled with g++ 1.34.1.
+
+extern "C" void printf (char *, ...); 
+
+int function (char c);
+int function (float f);
+
+class base {
+	int filler;
+public:
+	int method (char);
+	int method (float);
+};
+
+void* vp;
+
+typedef int (*ptr_to_func_of_char)(char);
+typedef int (*ptr_to_func_of_float)(float);
+typedef int (base::*ptr_to_method_of_char)(char);
+typedef int (base::*ptr_to_method_of_float)(float);
+
+int test2 (void*);
+int test3 (void*);
+int test4 (void*);
+int test5 (void*);
+
+base* base_ptr;
+
+int fail ()
+{
+  printf ("FAIL\n");
+  return 1;
+}
+
+int main ()
+{
+	base_ptr = new base;
+
+	ptr_to_func_of_char p0 = &function;
+	vp = (void*) p0;
+	if (test2 (vp))
+		return fail ();
+	ptr_to_func_of_float p1 = &function;
+	vp = (void*) p1;
+	if (test3 (vp))
+		return fail ();
+	ptr_to_method_of_char p2 = &base::method;
+	vp = (void*) p2; // ERROR - 
+	if (test4 (vp))
+		return fail ();
+	ptr_to_method_of_float p3 = &base::method;
+	vp = (void*) p3; // ERROR - 
+	if (test5 (vp))
+		return fail ();
+
+	printf ("PASS\n");
+	return 0;
+}
+
+int test2 (void* vp)
+{
+	char ch = 'x';
+
+	return (((ptr_to_func_of_char)vp)(ch) !=  9901);
+}
+
+int test3 (void* vp)
+{
+	float flt = 9.9;
+
+	return (((ptr_to_func_of_float)vp)(flt) !=  9902);
+}
+
+int test4 (void* vp)
+{
+	char ch = 'x';
+	ptr_to_method_of_char p = (ptr_to_method_of_char) vp; // ERROR - bad type conversion
+
+	return ((base_ptr->*p)(ch) !=  9904);
+}
+
+int test5 (void* vp)
+{
+	float flt = 9.9;
+	ptr_to_method_of_float p = (ptr_to_method_of_float) vp; // ERROR - bad type conversion
+
+	if ((base_ptr->*p)(flt) !=  9905) {
+		return 1;
+	} else
+		return 0;
+}
+
+int function (char c)
+{
+	c = c;
+	return 9901;
+}
+
+int function (float f)
+{
+	f = f;
+	return 9902;
+}
+
+int base::method (char c)
+{
+	c = c;
+	return 9904;
+}
+
+int base::method (float f)
+{
+	f = f;
+	return 9905;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C
new file mode 100644
index 00000000000..84c09a2a4b2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators5.C
@@ -0,0 +1,52 @@
+// GROUPS passed operators
+// Check that operators may be (directly) recursive.
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int i;
+};
+
+base base_variable;
+
+base operator+ (const base& left, const base& right)
+{
+	base ret_val;
+
+	ret_val.i = left.i + right.i;
+	return ret_val;
+}
+
+base operator- (const base& left, int right)
+{
+	base ret_val;
+
+	ret_val.i = left.i - right;
+	return ret_val;
+}
+
+// Define the unary ! operator for class base to be the fibonachi
+// operator.
+
+base operator! (const base& right)
+{
+	if (right.i < 2)
+		return right;
+	else
+		return ((!(right-1)) + (!(right-2)));
+}
+
+int main ()
+{
+	base k;
+
+	k.i = 15;
+	k = !k;		// fib it!
+
+	if (k.i != 610)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C
new file mode 100644
index 00000000000..c0c23188a8e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators6.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed operators
+class a {
+public:
+    a* operator->() { return this; }
+    void p();
+};
+
+void a::p() {
+  operator->();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C
new file mode 100644
index 00000000000..7a952211c9b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators7.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed operators
+class A {
+  char *p;
+public:
+  operator const char *() const { return p; }
+};
+
+int foo(const A &a)
+{
+  return (a != 0);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C b/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C
new file mode 100644
index 00000000000..390f749bc5e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/operators8.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed operators
+struct A {
+  char *p;
+  operator char *();
+};
+
+char foo(A a)
+{
+  return a[0];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C
new file mode 100644
index 00000000000..5658fdd8f9b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Foo
+{
+public:
+  int f (void);
+};
+
+class Bar : public Foo
+{
+public:
+      int f (int); // ERROR - candidates are
+};
+
+main ()
+{
+  Bar b;
+
+  b.f ();// ERROR - 
+  b.f (10);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C
new file mode 100644
index 00000000000..e28d6ea805d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload10.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Bed {
+   public:
+   static void bed_func(
+      int        (*f)(int &, int, int));
+};
+class g_func {
+public:
+	static int save_status;
+
+	// in compute_harshness, we should be using comptypes, not ==, to
+	// check if this is equivalent to the previous decl; the only
+	// difference is the default arg
+	static int rpt_func(int &status, int expand, 
+		int restore_cursor=1 );
+};
+
+int  main (int argc, 
+           char **argv,
+           char  **envp)
+{
+   Bed::bed_func(g_func::rpt_func);
+   return(1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C
new file mode 100644
index 00000000000..cbced94cbcf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload11.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed overloading
+class foo_int
+{
+public:
+  int & i;
+
+  foo_int (int &j) : i(j) {};
+  void inc () { i++; }
+
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C
new file mode 100644
index 00000000000..75068da88bb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload2.C
@@ -0,0 +1,43 @@
+// GROUPS passed overloading
+// Check that calls to the correct overloaded virtual
+// functions are generated even where the type of the formal
+// arguments for the overloadings are similar or related.
+
+extern "C" void printf (char *, ...); 
+
+int proper_method_called = 0;
+
+struct base {
+	int member;
+	virtual void method (char)
+	{
+	}
+	virtual void method (char *)
+	{
+	}
+};
+
+struct derived : public base {
+	int member;
+	virtual void method (char)
+	{
+	}
+	virtual void method (char *)
+	{
+		proper_method_called++;
+	}
+};
+
+char *message;
+
+int main ()
+{
+	derived derived_object;
+
+	derived_object.method (message);
+
+	if (proper_method_called != 1)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C
new file mode 100644
index 00000000000..baa90fb282d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload3.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed overloading
+typedef int rutBoolean;
+
+class rutBigIntRep
+{
+public:
+  friend rutBoolean operator>(const rutBigIntRep& a, const rutBigIntRep& b);
+  operator rutBoolean() const;  
+protected:
+  enum Kluge {kluge};
+  rutBigIntRep(Kluge) {}
+  rutBigIntRep();
+  rutBigIntRep(const rutBigIntRep& value);
+  rutBigIntRep& operator=(const rutBigIntRep& value);
+};
+
+rutBoolean operator>(const rutBigIntRep& a, const rutBigIntRep& b) {
+  // This should not result in a warning.  It used to warn about the
+  // conversion from int to enum while exploring the possibility of
+  // converting `a' via `operator rutBoolean', then using the
+  // rutBigIntRep(Kluge) constructor.  It later realizes it shouldn't
+  // do this, but the call to build_type_conversion was ending up with
+  // a warning in convert.
+  rutBigIntRep diff(a);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C
new file mode 100644
index 00000000000..21c3dc8db5a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload4.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed overloading
+  typedef void *		(*NewObject) (void);
+  
+  class B
+  {
+  public:
+	static void WantsNew (NewObject creator); // ERROR - candidates are
+  };
+  
+  class A
+  {
+  public:
+      static A * NewOne (void);
+  
+      static void InitClass (void)
+      {
+	  B::WantsNew ( (NewObject) A::NewOne );
+	  // This used to die in convert_harshness_{ansi,old} cuz it
+	  // didn't know what to do about a void type.
+	  B::WantsNew ( A::NewOne );// ERROR - 
+      }
+  };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C
new file mode 100644
index 00000000000..d71f0c01d2e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload5.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed overloading
+class Foo
+{
+public:
+  int operator << (const signed char&);
+  int operator << (const unsigned char&);
+  int operator << (const short&);
+  int operator << (const unsigned short&);
+  int operator << (const long&);
+  int operator << (const unsigned long&);
+};
+
+int main ()
+{
+  Foo fd;
+
+  // We fixed convert_harshness_ansi so it considers the call to
+  // <<(const signed char&) to be a trivial conversion.  It used
+  // to always make it a standard conversion, which made it conflict
+  // with <<(const unsigned char &), which is really a std conv.
+  fd << (signed char) 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C
new file mode 100644
index 00000000000..84903c19d74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload6.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed overloading
+struct temp_string {
+  temp_string (const unsigned char);
+};
+  
+class String {
+ public:
+  String& operator = (temp_string);
+  String& operator = (const String&);
+}; 
+class S {
+ public:
+  operator temp_string & () const;
+}; 
+
+S lbuf;
+
+static void e_r ()
+{
+  String a;
+  a = lbuf;
+ return;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C
new file mode 100644
index 00000000000..0c39e0d8c21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload7.C
@@ -0,0 +1,41 @@
+// GROUPS passed overloading
+extern "C" void printf (char *, ...);
+
+struct NoName {
+        
+        int first;
+        int second;
+};
+
+class Casted {
+
+  public:
+
+        NoName  x;
+        double  y;
+
+        Casted ( int _x , double _y ): y(_y) 
+        { 
+                x.first = _x;
+                x.second = _x*2;
+        }
+        
+        operator NoName() const { return x; }
+        operator double() const { return y; }
+};
+
+main()
+{
+        Casted c(10,12.34);
+
+        NoName x;
+        double y;
+
+        x = c;
+        y = c;
+
+	if (x.first == 10 && x.second == 20 && y == 12.34)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C
new file mode 100644
index 00000000000..6057ebe7086
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload8.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed overloading
+typedef struct{double re,im;} complex;
+class Complex{public:double re,im;
+    inline void operator=(Complex&X){re=X.re; im=X.im;};};
+void zxcvbnm(int n,...){n=1;}
+main(){complex c; Complex C;
+zxcvbnm(1,c);
+zxcvbnm(1,C);}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C b/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C
new file mode 100644
index 00000000000..2d5dfa3553d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/overload9.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed overloading
+class CLogger
+{
+public:
+      void operator() (int,const char *) {}; // ERROR - candidates
+      void operator() (int,const char *, ...) {}; // ERROR - candidates
+} Log;
+
+class CGLogger : public CLogger
+{
+} GLog;
+
+main()
+{
+        Log(1,"Test");// ERROR -  call of.*
+        Log(1,"Test %d",3);
+        GLog(1,"Test");// ERROR -  call of.*
+        GLog(1,"Test %d",3);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C
new file mode 100644
index 00000000000..76bfb0ea378
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed parsing
+class Try {
+private:
+  char s;
+public:
+  // an escaped double-quote should not call consume_string inside
+  // reinit_parse_for_block
+  void  mf() { s='\"'; }
+};
+
+main()
+{
+  Try x;
+  x.mf();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C b/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C
new file mode 100644
index 00000000000..cd588e15d86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/parse2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed parsing
+class BitString {
+public:
+    int i;
+};
+
+
+typedef BitString BS;
+typedef ::BitString cBS;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C
new file mode 100644
index 00000000000..ba1a2084efe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class foo {
+public:
+      operator ++ (); // ERROR - no type or storage class
+};
+
+main()
+{
+  foo x;
+
+  // This should fall back to calling operator++(), and be an error with
+  // the -pedantic flag.
+  x++;// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C
new file mode 100644
index 00000000000..1e34433e180
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed initialization
+class foo {
+public:
+      operator ++ (); // ERROR - no type or storage class
+      operator ++ (int); // ERROR - no type or storage class
+      operator ++ (char);		// illegal// ERROR - .*
+      operator ++ (short);		// illegal// ERROR - .*
+      operator ++ (long);		// illegal// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C
new file mode 100644
index 00000000000..4244e4ff59e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost3.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class Y {
+public:
+   friend Y operator++ (Y&);
+   friend Y operator++ (Y&, char);	// illegal// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C b/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C
new file mode 100644
index 00000000000..ac31f912952
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/prepost4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed prefix-postfix
+class Y {
+public:
+   friend Y operator++ (Y&);
+
+   // This is legal---it's a good test to make sure that grokfndecl's
+   // checking of the arguments is sane.
+   friend Y operator++ (Y&, int);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C
new file mode 100644
index 00000000000..3e3b2dfe1b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy1.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed ptolemy-bugs
+class Tcl_Interp;
+
+class PTcl {
+public:
+	PTcl(Tcl_Interp* interp = 0);
+	~PTcl();
+	int alias(int argc,char** argv);
+};
+
+typedef int (PTcl::*InterpFuncP)(int,char**);
+
+struct InterpTableEntry {
+	char* name;
+	InterpFuncP func;
+};
+
+ 
+static InterpTableEntry funcTable[] = {
+	{ "alias" , &PTcl::alias  } ,
+	0, 0
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C
new file mode 100644
index 00000000000..ca9c21c2814
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptolemy2.C
@@ -0,0 +1,69 @@
+// GROUPS passed ptolemy-bugs
+#include <iostream.h>
+
+class PTcl {
+public:
+	int dispatcher(int which,int argc,char** argv);
+	// fns in the table
+	int one(int argc, char** argv);
+	int two(int argc, char** argv);
+	int three(int argc, char** argv);
+};
+
+// An InterpFuncP is a pointer to an PTcl function that takes an argc-argv
+// argument list and returns TCL_OK or TCL_ERROR.
+
+typedef int (PTcl::*InterpFuncP)(int,char**);
+
+struct InterpTableEntry {
+	char* name;
+	InterpFuncP func;
+};
+
+// Here is the function table and dispatcher function.
+// These macros define entries for the table
+
+#define quote(x) #x
+#define ENTRY(verb) { quote(verb), &PTcl::verb }
+
+static InterpTableEntry funcTable[] = {
+	ENTRY(one),
+	ENTRY(two),
+	ENTRY(three),
+	{0, 0}
+};
+
+int PTcl::dispatcher(int which, int argc, char** argv) {
+	return (this->*(funcTable[which].func))(argc, argv);
+}
+
+void printargs(char** argv) {
+//	while (*argv) {
+//		cout << " " << *argv++;
+//	}
+//	cout << "\n";
+}
+
+int PTcl::one(int, char** argv) {
+  cout << "FAIL\n";
+	printargs(argv);
+	return 0;
+}
+
+int PTcl::two(int, char** argv) {
+  cout << "PASS\n";
+	printargs(argv);
+	return 0;
+}
+
+int PTcl::three(int, char** argv) {
+  cout << "FAIL\n";
+	printargs(argv);
+	return 0;
+}
+
+main (int argc, char** argv) {
+	PTcl obj;
+	obj.dispatcher(1,argc,argv);
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C
new file mode 100644
index 00000000000..49c9f75aa1f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+class my_class 
+{
+public:
+  typedef void func_type (int num);
+  my_class (int num, func_type* proc);
+  void dispatch (void);
+private:
+  int _num;
+  func_type *_proc;
+};
+
+my_class::my_class (int num, func_type* proc) : _num(num), _proc(proc) 
+{
+}
+
+void my_class::dispatch (void)
+{
+  _proc(_num);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C
new file mode 100644
index 00000000000..2af19e04d84
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem2.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+struct C {
+  struct N {
+    int g1(int);
+    int g2(int);
+  };
+
+  typedef int (N::*pmfn)(int);
+  
+  int f1(int);
+  int f2(int);
+};
+
+int (C::*f)(int) = &C::f1;		
+
+/*
+   The compiler should not crash on the line below; this change fixes it:
+        * cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't
+        have TYPE_PTRMEMFUNC_P set before we try to build its
+        CLASSTYPE_ID_AS_LIST.
+*/
+
+C::pmfn h = &C::N::g1;			
+
+int (C::N::*g)(int) = &C::N::g2;	
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C
new file mode 100644
index 00000000000..0f6bf0bd90f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem3.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+template<class T> class TemplA {
+    T t;
+};
+
+
+template<class T> class TemplB {
+public:    
+    typedef void (T::*TClassMethod)();
+
+private:
+/*
+   This line should not crash cuz of the get_decl_list change in this:
+	* cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't
+	have TYPE_PTRMEMFUNC_P set before we try to build its
+	CLASSTYPE_ID_AS_LIST.
+	(get_decl_list): Likewise, when trying to read it.
+*/
+    TemplA<TClassMethod> Tmethod;  
+};
+
+
+class C {
+    int a;
+};
+
+int main(int, char**) {
+
+    TemplB<C> test;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C
new file mode 100644
index 00000000000..a4f792e5c07
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/ptrmem4.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed pointers-to-members
+class X   {
+ private:
+  int i;
+ public:
+  X(int k)			{ i=k; }
+  int operator=(X &a)		{ return i = a.i; }
+  int operator=(int ii)	{ return i = ii; }
+};
+int main(void)
+{
+  int (X::*op1_ptr)(X&);
+  op1_ptr = &X::operator=;    // g++ gives error 
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C b/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C
new file mode 100644
index 00000000000..93baa4490b4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/recurse.C
@@ -0,0 +1,80 @@
+// Build don't link: 
+// GROUPS passed recursive-aborts
+// types
+typedef unsigned int DBflag;   // for storing user flag value
+typedef unsigned long DBoffset; // 32-bit unsigned integer
+typedef DBoffset DBsize;  // type for storing sizes of objects
+typedef unsigned char DBbyte;   // 8-bit unsigned char
+
+class DBlink
+{
+protected:
+  DBbyte link[4];       // hold link in portable MSB first format
+public:
+  DBlink(DBoffset = 0, DBflag = 0);
+  DBlink &operator=(const DBlink &);
+  DBlink &operator=(DBoffset);
+  operator DBoffset();
+  operator const DBbyte *() { return link; }
+  void set_flag() { link[0] |= 0x80; }
+  void reset_flag() { link[0] &= 0x7f; }
+  int test_flag() const { return (link[0] & 0x80) != 0; }
+};
+
+typedef DBlink DBsizerec;       // hold data record size in portable format
+
+// constants
+const DBoffset DB_NULL = 0;
+
+class DBlinkrec
+{
+protected:
+  // offsets are stored with MSB in link[0]
+  DBlink l;  // offset into link file of right child - MSB = red bit
+  DBlink r;  // offset into link file of left child - MSB = delete
+  DBlink d;  // offset into parallel data file - MSB = user flag
+public:
+  DBlinkrec():l(DB_NULL), r(DB_NULL), d(DB_NULL) {}
+  void make_red() // set link to red
+  { l.set_flag(); }
+  void make_black() // set link to black
+  { l.reset_flag(); }
+  int is_red() const // indicates whether this is a red link
+  { return l.test_flag(); }
+  void set_discard() // set discard flag
+  { r.set_flag(); }
+  void reset_discard() // reset discard flag
+  { r.reset_flag(); }
+  int is_discarded() const // check discard flag
+  { return r.test_flag(); }
+  void set_flag() // set user flag
+  { d.set_flag(); }
+  void reset_flag() // reset user flag
+  { d.reset_flag(); }
+  int is_flag() const // check user flag
+  { return d.test_flag(); }
+
+  friend class DataBase;
+};
+
+class DBpathrec : public DBlinkrec
+{
+  DBoffset offset;    // offset of link record in LNK file
+public:
+  DBpathrec():offset(DB_NULL) { }
+  DBpathrec(DBoffset off, const DBlinkrec &lr):offset(off), DBlinkrec(lr) {}
+  operator DBoffset() { return offset; }
+  DBpathrec &operator=(DBoffset off) { offset = off; return *this; }
+  DBpathrec &operator=(const DBpathrec &pr)
+  { offset = pr.offset; (DBlinkrec)*this = (DBlinkrec)pr; return *this; }
+
+  friend class DataBase;
+};
+
+main()
+{
+  DBpathrec a(), b();
+
+  a = b;// ERROR -  non-lvalue in assignment.*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C
new file mode 100644
index 00000000000..39a432cac5f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl1.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed redeclaration
+inline int min(int x, int y) {return x < y ? x : y;}		/* 235 */// ERROR - .*
+int min(int a, int b);
+inline int min(int a, int b) {return (a < b)?a:b;}// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C
new file mode 100644
index 00000000000..58942197ddf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl2.C
@@ -0,0 +1,51 @@
+// GROUPS passed redeclaration
+// Check that if multiple declarations of the same single
+// function are present in different places in the same file,
+// and if these declarations differ (as allowed) in the number
+// of argument defaults provided, that correct values are
+// passed at all call points anyway.
+
+extern "C" void printf (char *, ...); 
+
+void receiver (int ii, int jj);
+
+void sender_1 ()
+{
+	receiver (3,7);
+}
+
+void receiver (int ii, int jj = 9);
+
+void sender_2 ()
+{
+	receiver (5);
+}
+
+int ii_sum = 0;
+int jj_sum = 0;
+
+void sender_3 ();
+
+int main ()
+{
+	sender_1 ();
+	sender_2 ();
+	sender_3 ();
+	if (ii_sum != 13 || jj_sum != 25)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+	return 0;
+}
+
+void receiver (int ii, int jj)
+{
+	ii_sum += ii;
+	jj_sum += jj;
+}
+
+void sender_3 ()
+{
+	receiver (5);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C b/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C
new file mode 100644
index 00000000000..5987e0e3172
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/redecl3.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed redeclaration
+class foo
+{
+public:
+    int bar(int a);
+};
+
+
+void bar(int &a);
+
+int foo::bar(int a)  {
+    int a = 0;			// Should this be an error ?// ERROR -  declaration.*
+
+    bar(a);
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C b/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C
new file mode 100644
index 00000000000..2a0c2939e4f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/reference1.C
@@ -0,0 +1,53 @@
+// Special g++ Options: -w
+// GROUPS passed references
+// Check that if a reference is initialized to refer to a value
+// which is returned from a function call, the actual call to
+// the function is only invoked for the original initialization
+// of the reference, and not for each subsequent use of the
+// reference.
+//
+// This test fails with G++ 1.35.0- (pre-release).
+// Reported 4/4/89 by Kim Smith
+
+extern "C" void printf (char *, ...); 
+
+struct base {
+	int data_member;
+
+	base () {}
+	void function_member ();
+};
+
+base base_object;
+
+base base_returning_function ();
+
+int call_count = 0;
+
+int main ()
+{
+	base& base_ref = base_returning_function ();
+
+	base_ref.function_member ();
+	base_ref.function_member ();
+	base_ref.data_member  = 99;
+
+	if (call_count == 1)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+
+	return 0;
+}
+
+base base_returning_function ()
+{
+	base local_base_object;
+
+	call_count++;
+	return local_base_object;
+}
+
+void base::function_member ()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C b/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C
new file mode 100644
index 00000000000..6dcdff34e36
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/rtti1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed RTTI
+#include <typeinfo>
+
+struct B                                { virtual ~B(){}  };
+struct D0 : public virtual B            { virtual ~D0(){}  };
+struct D1 : public virtual D0           { virtual ~D1(){}  };
+struct C : public virtual B, public D1  { virtual ~C() { } };
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C
new file mode 100644
index 00000000000..babbb018396
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed scoping
+int f (int i) {
+  if (i)
+    for (int j = i; j; j--)
+      ;
+  return j;	// error: j should only be in scope inside the body of `for'// ERROR - .*
+} // ERROR - non-void
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C
new file mode 100644
index 00000000000..7085716be73
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope2.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed scoping
+class A
+{
+ public:
+  A() {}
+  ~A() {}
+  virtual void f() {}
+};
+
+class B : public A
+{
+ public:
+  B() {}
+  ~B() {}
+  virtual void f() {}
+};
+
+
+B GLOBAL_B;
+
+B& foo() {return GLOBAL_B;}
+
+main()
+{
+  // build_scoped_method_call and build_scoped_ref should know how
+  // to deal with a reference for this
+  foo().A::f(); 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C
new file mode 100644
index 00000000000..cf784303171
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope3.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed scoping
+// This is fixed when NEW_CLASS_SCOPING is on.
+
+template<class T>
+class ArrayG {
+public:
+    ArrayG();
+protected:
+    const unsigned INITIAL;
+    T* array;			 
+};
+
+template<class T>
+ArrayG<T>::ArrayG():
+array(new T[INITIAL])
+{ }
+
+struct X {
+    struct Correspondence {
+	int i;
+    };
+
+    void fill(ArrayG<Correspondence>& a);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C
new file mode 100644
index 00000000000..43f90164cb6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope4.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// excess errors test - XFAIL *-*-*
+// GROUPS passed scoping
+class BitString {
+public:
+    int i;
+    int length() const;
+};
+
+typedef BitString BS;
+
+class V {
+public:
+    class BitString {
+    public:
+        static int x(const ::BitString& value);
+      static int y(const class ::BitString& value); // should be parsed ok
+        static int z(const BS& value);
+    };
+};
+
+int
+V::BitString::x(const ::BitString& value)
+{ return value.length(); }
+
+int
+V::BitString::y(const class ::BitString& value) // should be parsed ok
+{ return value.length(); }
+
+int
+V::BitString::z(const BS& value)
+{ return value.length(); }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C b/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C
new file mode 100644
index 00000000000..753236948a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/scope5.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed scoping
+class Integer {
+public:
+    int i;
+};
+
+class Type {
+    enum Class { ENUM, INTEGER };
+
+    class Description {
+    public:
+        
+    };
+
+    class Integer: public Description {
+    public:
+        ::Integer low;
+        ::Integer high;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C b/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C
new file mode 100644
index 00000000000..6a1d9d1f8e3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/shadow1.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed errors
+void f( int a) {
+  int a;	// this should be an error now// ERROR - .*
+	{
+		int a;
+	}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C
new file mode 100644
index 00000000000..c8242eb5539
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+void f() { }
+
+int
+main()
+{
+  // sizeof may not be applied to a function
+  int i = sizeof( f);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C
new file mode 100644
index 00000000000..ddac679d880
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof2.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+void f() { }
+
+struct foo { int bit : 1; };
+
+int
+main()
+{
+  // sizeof may not be applied to a bit-field
+  foo f;
+  int i = sizeof (f.bit);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C
new file mode 100644
index 00000000000..e6972ca397e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+class bar;
+
+int
+main()
+{
+  // sizeof may not be applied to an undefined class
+  int k = sizeof (bar);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C
new file mode 100644
index 00000000000..62d76c05bdd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+int
+main()
+{
+  // sizeof may not be applied to the type void
+  int l = sizeof (void);// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C
new file mode 100644
index 00000000000..0ef9d9c5ed1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sizeof5.C
@@ -0,0 +1,17 @@
+// GROUPS passed sizeof
+// ARM $5.3.2
+
+extern "C" void printf (char *, ...);
+
+class foo {};
+
+int
+main ()
+{
+  // The size of any class or class object is larger than zero.
+  int i = sizeof (foo);
+  if (i > 0)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C b/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C
new file mode 100644
index 00000000000..caa9276f8a8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/sorry1.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed old-sorry
+class a {
+public:
+	int*	foo();
+};
+
+a aa;
+a* ap;
+
+class b {
+public:
+	int	ok(int* p =aa.foo());	
+
+  // dump_init should know what to do with this NON_LVALUE_EXPR
+	int	f(int* p =ap->foo());		
+};
+
+	int
+b::ok(int *p) 
+{
+	return 0;
+}
+
+	int
+b::f(int *p) 
+{			
+	return 0;
+}
+	void
+bar()
+{
+	b b;
+	b.ok();
+	b.f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static1.C b/gcc/testsuite/g++.old-deja/g++.brendan/static1.C
new file mode 100644
index 00000000000..b30c796eb19
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static1.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed static
+class A { public: int a; };// ERROR - .*
+void foo7 () { A::a = 3; }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static2.C b/gcc/testsuite/g++.old-deja/g++.brendan/static2.C
new file mode 100644
index 00000000000..1e050e2cf6f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed static
+class A
+{
+        public:
+        void    member(void)
+        {
+        }
+
+        static void staticMember()
+        {
+	  member (); // illegal, no object for calling non-static method// ERROR - .*
+        }
+};
+
+main()
+{
+        A::staticMember();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/static3.C b/gcc/testsuite/g++.old-deja/g++.brendan/static3.C
new file mode 100644
index 00000000000..5c52f0e217d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/static3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed static
+class foo{
+public:
+  static void  bar( int i ){ value = i; }
+  static int  value;// ERROR - .*
+};
+
+const int  foo::value = 0; // should be an error.// ERROR - .*
+
+int main(){
+  foo::bar( 1 );
+  return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C b/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C
new file mode 100644
index 00000000000..5356796094a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/synth1.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors -g -Wall
+// GROUPS passed synthetics
+// excess errors test - XFAIL sparc64-*-elf
+// Check to make sure that g++ doesn't get freaked out about the use
+// of generated methods that it supposedly "can't see".
+
+class Char {
+public:
+    Char();
+    Char(char v);
+    
+    // synthetic copy-constructor and operator=
+private:
+    char value;
+};
+
+class XChar: public Char {
+public:
+    XChar();
+    XChar(char v, int serial);
+    
+    void operator=(const XChar& other);
+private:
+    int serial;
+};
+
+void
+XChar::operator=(const XChar& other)
+{
+    Char::operator=(other);
+    // serial stays the same
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template1.C b/gcc/testsuite/g++.old-deja/g++.brendan/template1.C
new file mode 100644
index 00000000000..e6609fd323b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed templates
+// g++-2.2.1: member functions returning a template type 
+
+
+template <class T> struct list { };
+
+struct A
+{
+  list<int> L;
+
+  list<int>  get_list();
+
+};
+
+
+list<int> A::get_list() { return L; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template11.C b/gcc/testsuite/g++.old-deja/g++.brendan/template11.C
new file mode 100644
index 00000000000..55fa2b20025
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template11.C
@@ -0,0 +1,47 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class Called>
+class aCallback
+{
+public:
+  aCallback(Called& obj, int (Called::*met)());
+
+  int callback();
+  
+protected:
+
+private:
+  // the object to call
+  Called&       object;
+  
+  // the method to apply
+  int (Called::*method)();
+  
+};
+
+template <class Called>
+aCallback<Called>::aCallback(Called& obj,
+                             int (Called::*met)()) :
+object(obj),
+method(met)
+{};
+
+template <class Called>
+int aCallback<Called>::callback()
+{
+  return (object.*method)();
+}
+
+struct myStruct
+{
+  int action() {return 24;};
+};
+
+main()
+{
+  myStruct toto;
+
+  aCallback<myStruct>   cb(toto, &myStruct::action);
+
+  return cb.callback();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template12.C b/gcc/testsuite/g++.old-deja/g++.brendan/template12.C
new file mode 100644
index 00000000000..2165ae29ee4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template12.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed templates
+inline void foo (const int &x) {}
+
+template <class type>
+inline void foo (const type &x) {x.eat_this_and_die();}
+
+int main (int argc, char **argv) {foo (argc);}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template13.C b/gcc/testsuite/g++.old-deja/g++.brendan/template13.C
new file mode 100644
index 00000000000..653ef215e88
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template13.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class ListS {
+public:
+    class Vix {
+    public:
+	Vix();
+    };
+};
+
+template<class T>
+ListS<T>::Vix::Vix()
+{ }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template15.C b/gcc/testsuite/g++.old-deja/g++.brendan/template15.C
new file mode 100644
index 00000000000..b830505e209
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template15.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class Stack {
+  public:
+    Stack (int s = 10);         //Comment out "= 10" and it will compile
+    ~Stack(void);               //Omitting "void" doesn't help
+}; 
+
+template<class T> Stack<T>::~Stack(void) 
+{ }
+
+//If this definition comes before the one for ~Stack, the error message
+//about redeclaration of `void Stack<int>::~Stack()' will not occur.
+template<class T> Stack<T>::Stack(int s)
+{ }
+
+int main () {
+    Stack<int> stk(10);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template16.C b/gcc/testsuite/g++.old-deja/g++.brendan/template16.C
new file mode 100644
index 00000000000..ec13a24f86e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template16.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class TList {
+   typedef void (T::*TVOIDFUNT)();
+   typedef T*   (T::*TTPFUNT)(T*);
+};
+
+class A;
+class B : TList<A> { };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template17.C b/gcc/testsuite/g++.old-deja/g++.brendan/template17.C
new file mode 100644
index 00000000000..e6c2652dce5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template17.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed templates
+struct Regex { int i; Regex(char *, int); };
+template<class KEY>
+class NDAMName {
+public:
+    static const Regex pattern;
+    static unsigned sequence_number;
+};
+
+const Regex NDAMName<'L'>::pattern("^[Ll](.*)$",   1);// ERROR -  type/value.*
+unsigned NDAMName<'L'>::sequence_number = 0;// ERROR -  type/value
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template18.C b/gcc/testsuite/g++.old-deja/g++.brendan/template18.C
new file mode 100644
index 00000000000..5c6479cbffc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template18.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T> class X;
+typedef X<int> IX;
+
+template<class T>
+class X {
+public:
+  T x;
+};
+
+struct A {
+  IX c;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template19.C b/gcc/testsuite/g++.old-deja/g++.brendan/template19.C
new file mode 100644
index 00000000000..a8b33c1b4dd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template19.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class Base
+{
+public:
+    Base() { }
+};
+
+template <class memberType, class keyType>
+class Middle : public Base<memberType>
+{
+public:
+    Middle (keyType const & (*ko) (memberType const &))
+    {
+    }
+};
+
+// EXCHANGE the following lines for this code to work.
+//template <class memberType, class keyType> class Middle;
+template <class T, class keyType> class Middle;
+
+struct Test : public Middle <int, int>
+{
+    Test();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template2.C b/gcc/testsuite/g++.old-deja/g++.brendan/template2.C
new file mode 100644
index 00000000000..07e2e66a7c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template2.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class Q>
+class Conc {
+public:
+	static int body();
+};
+
+template <class Q>
+int Conc<Q>::body() {return 0;}
+
+main () {
+	Conc<int> s2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template20.C b/gcc/testsuite/g++.old-deja/g++.brendan/template20.C
new file mode 100644
index 00000000000..7f5c4acd467
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template20.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class A, class B> class Map;
+
+class Foo
+{
+public:
+    static Map<int,int> bar;
+};
+
+template <class A, class B>
+class Map
+{
+public :
+    int find();
+};
+
+main()
+{
+    int z = Foo::bar.find();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template21.C b/gcc/testsuite/g++.old-deja/g++.brendan/template21.C
new file mode 100644
index 00000000000..9d6139191e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template21.C
@@ -0,0 +1,43 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class L {
+public:
+    L();
+
+    T x[30];
+    int doit(int i) const;
+};
+
+#ifdef BUG
+template<class T>
+int
+L<T>::doit(int i) const
+{
+    return x[i].z;
+}
+#endif
+
+class X {
+public:
+    class Y {
+    public:
+        Y();
+        Y(int);
+
+        int z;
+    };
+    
+    L<Y> ly;
+};
+
+#ifndef BUG
+template<class T>
+int
+L<T>::doit(int i) const
+{
+    return x[i].z;
+}
+#endif
+
+static X x;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template22.C b/gcc/testsuite/g++.old-deja/g++.brendan/template22.C
new file mode 100644
index 00000000000..a977e2ffacf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template22.C
@@ -0,0 +1,22 @@
+// GROUPS passed templates
+extern "C" int printf (const char *, ...);
+
+template <class T>
+class Foo
+{
+public:
+  void func (int const& i);
+};
+
+template <class T>
+void Foo<T>::
+func (int const& i)
+{}
+
+
+main ()
+{ 
+  Foo<int const> foo;
+  printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template23.C b/gcc/testsuite/g++.old-deja/g++.brendan/template23.C
new file mode 100644
index 00000000000..f38d4204685
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template23.C
@@ -0,0 +1,34 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class T_Base
+{};
+
+template <class T>
+class T_Derived
+: public T_Base<T>
+{};
+
+
+class Base
+{
+public:
+  Base (float name);
+};
+
+class Derived
+: public Base
+{
+private:
+  T_Base<int>*	data_;	// Fix (1): Change date_ from T_Base<int>* to T_Derived<int>*
+  
+public:
+  Derived (float name); 
+};
+
+
+Derived::
+Derived (float name)
+:  Base(name),
+   data_(new T_Derived<int>()) 
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template24.C b/gcc/testsuite/g++.old-deja/g++.brendan/template24.C
new file mode 100644
index 00000000000..7d677023282
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template24.C
@@ -0,0 +1,20 @@
+// GROUPS passed templates
+extern "C" void printf (char *, ...);
+
+template <class F>
+class Temp
+{
+  F  func_;
+public:
+  Temp (F f) :func_(f) {}
+};
+
+int func (int h = 1, int z = 2) { return h+z; }
+
+main ()
+{
+  Temp<int(*)(int, int)> temp (func);
+
+  printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template25.C b/gcc/testsuite/g++.old-deja/g++.brendan/template25.C
new file mode 100644
index 00000000000..5939fed5b89
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template25.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class T>
+class Temp_Base
+{};
+
+template <class T>
+class Temp_Derived
+: public Temp_Base<T>
+{
+public:
+  Temp_Derived (int i = 10) {}
+};
+
+
+class Base
+{
+  float r_;
+public:
+  Base (float r) : r_(r) {}
+};
+
+class Derived
+: public Base
+{
+private:
+  Temp_Base<int>*  boo_;	   
+public:
+  Derived (float);
+};
+
+Derived::
+Derived (float form)
+: Base(form),
+  boo_(new Temp_Derived<int>)
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template26.C b/gcc/testsuite/g++.old-deja/g++.brendan/template26.C
new file mode 100644
index 00000000000..6dc15551f81
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template26.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed templates
+class V {
+ public:
+  V();
+  V(int);
+  };
+
+template <int I> class AA: public virtual V {
+ public:
+  AA();
+  AA(int);
+  };
+
+template <int I> class BB : public virtual V {
+ public:
+  BB();
+  BB(int);
+  };
+
+template <int I> AA<I>::AA() {};
+template <int I> AA<I>::AA(int i): V(i) {};
+template <int I> BB<I>::BB() {};
+template <int I> BB<I>::BB(int i) {};
+
+class CC : public AA<1>, public BB<2> {
+ public:
+  CC();
+  CC(int);
+  };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template27.C b/gcc/testsuite/g++.old-deja/g++.brendan/template27.C
new file mode 100644
index 00000000000..a2649d439e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template27.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates
+        template<class K, class V> class MapLS { };
+        class String {};
+        class X1 { };
+        class RefProto { };
+        template<class REP> class Ref { };
+        
+        class MapLS<String, Ref<X1> >: public MapLS<String, RefProto> {
+        public:
+            ~MapLS();
+        };
+        
+        MapLS<String, Ref<X1> >::~MapLS() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template28.C b/gcc/testsuite/g++.old-deja/g++.brendan/template28.C
new file mode 100644
index 00000000000..3ae4caf4638
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template28.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed templates
+class X {
+        const char *fptr;
+public:
+        X(const char *ptr) { fptr = ptr; }
+        operator const char*() { return fptr; }
+};
+
+main(){
+        X x1("1234");
+        X x2(x1+1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template29.C b/gcc/testsuite/g++.old-deja/g++.brendan/template29.C
new file mode 100644
index 00000000000..fa81995ed74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template29.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed templates
+   template <class ElementType> class A
+    { public:
+       A(ElementType) {}
+       ElementType get() const ;
+    };
+
+    template <class ElementType> ElementType A<ElementType>::get() const
+    { return ElementType(0); }
+
+    main() { const A<short> a(3); }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template3.C b/gcc/testsuite/g++.old-deja/g++.brendan/template3.C
new file mode 100644
index 00000000000..3900421d12f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template3.C
@@ -0,0 +1,49 @@
+// GROUPS passed templates
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+int count = 0;
+
+void
+die (int x)
+{
+  if (x != ++count)
+    {
+      printf ("FAIL\n");
+      exit (1);
+    }
+}
+
+class A {
+  public:
+    void   f() const { die (-1); }
+};
+
+
+template <class Item>
+class B : public A {
+  public:
+  void f() const;
+};
+
+template <class Item>
+inline void B<Item>::f() const { die (1); }
+
+template <class Item>
+class C : public A {
+  public:
+    void f() const { die (2); }
+};
+
+
+int main()
+{
+    B<int> b;
+    C<int> c;
+
+    b.f(); //- bugged, (A::f() called instead of B::f())
+    c.f(); //- works fine (C::f() called)
+
+    printf ("PASS\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template30.C b/gcc/testsuite/g++.old-deja/g++.brendan/template30.C
new file mode 100644
index 00000000000..97357d63a80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template30.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed templates
+
+        template<class K, class V> class MapLS { };
+        class String {};
+        class X1 { };
+        class RefProto { };
+        template<class REP> class Ref { };
+        
+        class MapLS<String, Ref<X1> >: public MapLS<String, RefProto> {
+        public:
+            ~MapLS();
+        };
+        
+        MapLS<String, Ref<X1> >::~MapLS() { }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template4.C b/gcc/testsuite/g++.old-deja/g++.brendan/template4.C
new file mode 100644
index 00000000000..318cd2e10d0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template4.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed templates
+// This used to be a circularity in chainon.
+template <class ARG> struct TMPL {
+    typedef int ARG::*ARG_data_member_ptr;
+    typedef void (ARG::*ARG_func_member_ptr) ();
+};
+
+struct S { };
+
+TMPL<S> object;
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template5.C b/gcc/testsuite/g++.old-deja/g++.brendan/template5.C
new file mode 100644
index 00000000000..39b74d6a4df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template5.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed templates
+template<class T>
+class Vector
+{
+public:
+    Vector(int x);
+    ~Vector();
+    T& operator [] (int i);
+
+private:
+    T* v;
+    int sz;
+} ;
+
+template<class T>
+Vector<T>::Vector(int x)
+{
+    sz = x;
+    v = new T (sz);
+} ;
+
+template<class T>
+Vector<T>::~Vector()
+    { delete [] v; } ;
+
+template<class T>
+T &
+Vector<T>::operator [] (int i)
+    { return v[i]; } ;
+
+int
+main(int, char **)
+{
+    Vector<int> intvec(3);
+
+    intvec[0] = 1;
+    intvec[1] = 2;
+    intvec[2] = 3;
+
+    for (int i = 0; i < 3; i++)
+	intvec[i];
+
+    return 0;
+}
+
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template6.C b/gcc/testsuite/g++.old-deja/g++.brendan/template6.C
new file mode 100644
index 00000000000..96459ca355d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template6.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed templates
+struct B {
+};
+
+struct X : B {
+  ~X ();
+};
+
+struct Request {
+  X s;
+};
+
+template <class ET> class TC {
+  ET data;
+};
+
+struct TMem {
+
+  ~TMem() {}
+
+  TC<Request> *req;
+};
+
+struct FIO {
+
+  void init ();
+
+  FIO () { init(); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template7.C b/gcc/testsuite/g++.old-deja/g++.brendan/template7.C
new file mode 100644
index 00000000000..59dc4835632
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template7.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// GROUPS passed templates
+template <class ET>
+class ChainElem {
+public:
+  
+  ET data;
+};
+
+template <class ET>
+class Chain {
+public:
+
+  ChainElem<ET> *first;
+
+  virtual ~Chain() {}
+
+};
+
+struct B {
+};
+
+struct X : B {
+  ~X ();
+};
+
+struct TBNFexpression {
+};
+
+struct TCaseLabelPair {
+};
+
+struct TVariant {  
+  Chain<TCaseLabelPair> CaseLabelList;
+};
+
+struct TCaseConstruct {
+  Chain<TBNFexpression> TagFieldPrefixes;
+  Chain<TVariant> Variants;
+};
+
+struct Production {
+  X TypeName;
+};
+
+struct SimpleSyntax {
+  Chain<Production> Productions;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template8.C b/gcc/testsuite/g++.old-deja/g++.brendan/template8.C
new file mode 100644
index 00000000000..0a24617239f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template8.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed templates
+#include <stdio.h>
+
+// make sure we accept unions for templates
+template<int n>
+union Double_alignt{
+	double for_alignt;
+	char array[n];
+
+};
+
+main(){
+
+	
+	Double_alignt<20000> heap;
+
+	printf(" &heap.array[0] = %d, &heap.for_alignt = %d\n", &heap.array[0], &heap.for_alignt);
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/template9.C b/gcc/testsuite/g++.old-deja/g++.brendan/template9.C
new file mode 100644
index 00000000000..8940c17724d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/template9.C
@@ -0,0 +1,19 @@
+// GROUPS passed templates
+// Test that the compiler will emit the definition of min given just
+// the declaration.  At one point in the past, it did not.
+#include <iostream.h>
+
+template <class T> inline T min(T a, T b) { return (a < b) ? a : b;};
+
+double min(double,double);	// this should expand the template
+
+main () {
+    int a = 1, b = 2;
+    double aa = 2.0, bb = 1.2;
+    cout << min(a,b) << ", " << min(aa,bb) << "\n";
+    if (min (a, aa) == a)
+      cout << "PASS" << endl;
+    else
+      cout << "FAIL" << endl;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C b/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C
new file mode 100644
index 00000000000..5258edf36a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/temporary1.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed temporaries
+#include <stdio.h>
+
+main ()
+{
+        int a = 2;
+
+        if (----a == 0)
+                printf ("a = 0\n");
+
+        printf ("a = %d\n", a);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C b/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C
new file mode 100644
index 00000000000..2f7aa87b122
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/typedef1.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+
+class baseClassA
+{
+public:
+private:
+	class internalClassA
+	{
+	public:
+	private:
+		typedef int privateType;
+
+		privateType memberA;
+	};
+};
+
+class baseClassB
+{
+public:
+private:
+	class internalClassA
+	{
+	public:
+	private:
+		typedef unsigned int privateType;
+
+		privateType memberB;
+	};
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union1.C b/gcc/testsuite/g++.old-deja/g++.brendan/union1.C
new file mode 100644
index 00000000000..7a4df261dbf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed unions
+// This is fixed by finish_anon_union doing a string_cst_equal check on
+// the DECL_SIZE of the decls, instead of comparing the DECL_SIZE nodes.
+     unsigned
+     hash(const double d)
+     {
+        static union {
+           unsigned asint[2];
+           double asdouble;
+        };
+        asdouble = d;
+        return asint[0] ^ asint[1];
+     }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union2.C b/gcc/testsuite/g++.old-deja/g++.brendan/union2.C
new file mode 100644
index 00000000000..d913ae80321
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed unions
+class B;
+ 
+struct A {
+    A(B* x) : i(x) {}
+    A() : i(0) {}
+ 
+    union {
+        B* i;
+        B* c;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/union3.C b/gcc/testsuite/g++.old-deja/g++.brendan/union3.C
new file mode 100644
index 00000000000..ad8b840b4bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/union3.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed unions
+union alan {
+int a;
+char *b;
+alan();
+};
+ 
+alan mary;
+ 
+alan::alan()
+{
+        a=0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C
new file mode 100644
index 00000000000..7d11f875716
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility1.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed visibility
+class foo {
+protected:
+  int i;
+};
+
+class bar : public foo {
+public:
+  friend void baz (foo *);
+};
+
+void baz (foo *f)
+{
+  f->i = 1;	// error: i is protected// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C
new file mode 100644
index 00000000000..4eb3cae8050
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility10.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed visibility
+struct base
+{
+    protected:
+        void base_func() {}// ERROR - .*is protected.*
+};
+
+struct derived : public base
+{
+    protected:
+        void derived_func(base *ptr) { ptr->base_func(); }// ERROR -  within this context
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C
new file mode 100644
index 00000000000..09e0f6591ae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility2.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed visibility
+class X {
+      void g (int); // ERROR - private
+public:
+  void g (double);
+};
+	
+class Y : public X { void f() { g (1); } }; // ERROR - private
+
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C
new file mode 100644
index 00000000000..8d3f8fd81ac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility3.C
@@ -0,0 +1,38 @@
+// Build don't link: 
+// GROUPS passed visibility
+// Used to say:
+// manip.cc:17: member `_f' is a private member of class `B<int>'
+// manip.cc:17: member `_a' is a private member of class `B<int>'
+
+class A {};
+
+template <class TP>
+class B
+{
+  A &(*_f) (A &, TP);
+  TP _a;
+public:
+  B (A &(*f) (A &, TP), TP a) : _f (f), _a (a) {}
+  friend A &operator<< (A &o, const B<TP> &m);
+};
+
+template <class TP>
+inline A &
+operator<< (A &o, const B<TP> &m)
+{
+  (*m._f) (o, m._a);
+  return o;
+}
+
+A &setw (A &, int);
+B<int> setw (int n)
+{
+  return B<int> (setw, n);
+}
+
+A x;
+
+void f ()
+{
+  x << setw (2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C
new file mode 100644
index 00000000000..b9de78f1881
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility4.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed visibility
+template <class T> 
+class Feld {
+public:
+  Feld(const Feld&) {}
+};
+
+class Polynom : private Feld<double> {
+friend Polynom f(const Polynom&);
+};
+
+Polynom f(const Polynom& p) { return p; }    
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C
new file mode 100644
index 00000000000..a53881a641e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility5.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed visibility
+template<int K> class B;
+template<int K> class A {int n; friend class B<K>;};
+template<int K> class B {public: void method(A<K>) const;};
+template<int K> void B<K>::method(A<K> X) const {X.n=0;}
+typedef B<2> B2;
+ 
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C
new file mode 100644
index 00000000000..5ca62c0c6a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility6.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed visibility
+class bottom
+{
+public:
+  int b;
+};
+class middle : private bottom
+{
+public:
+  void foo () { b; }
+};
+class top : public middle
+{
+public:
+  void bar () { b; }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C
new file mode 100644
index 00000000000..670547dd2e3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility7.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed visibility
+class X
+{
+public:
+  void fn ();// ERROR - .*
+};
+class Y : private X
+{};
+
+class Unrelated
+{
+public:
+  void foo () { Y y; y.fn (); }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C
new file mode 100644
index 00000000000..a3bb856d1ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility8.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed visibility
+// Make sure private inheritance affects the visibility of
+// static members used in an inherited context.
+class foo
+{
+public:
+  static int y;
+};
+class foo1 : private foo
+{ };
+class foo2 : public foo1
+{ public:
+  void bar () { y; }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C b/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C
new file mode 100644
index 00000000000..c2599291dc8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/visibility9.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed visibility
+class A {
+public:
+        void aMethod(void) {};// ERROR - .*
+};
+
+class AA : A { };
+
+class B {
+public:
+        void thisMethod() {
+                AA ana;
+                ana.aMethod();// ERROR - .*
+        }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C b/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C
new file mode 100644
index 00000000000..984ce18ce6b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/vtables1.C
@@ -0,0 +1,42 @@
+// GROUPS passed virtual-tables
+// Check that virtual function tables are generated and used
+// even for struct's/classes which have no explicit constructors.
+
+extern "C" void printf (char *, ...); 
+
+int base_func_member_1_called = 0;
+int derived_func_member_1_called = 0;
+
+struct base {
+	virtual void func_member_1 ()
+	{
+		base_func_member_1_called++;
+	}
+};
+
+struct derived : public base {
+	virtual void func_member_1 ()
+	{
+		derived_func_member_1_called++;
+	}
+
+	virtual void func_member_2 ()
+	{
+	}
+};
+
+base* bp1;
+base* bp2;
+
+int main ()
+{
+	bp1 = new base;
+	bp2 = new derived;
+
+	bp1->func_member_1 ();
+	bp2->func_member_1 ();
+
+	printf ("PASS\n");
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C
new file mode 100644
index 00000000000..02963623a22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings1.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed warnings
+// there should be a warning about foo only defining private methods
+class foo {
+  int bar();
+};// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C
new file mode 100644
index 00000000000..78ddf77d856
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings10.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+void foo()
+{
+  int i;
+  if (1) {
+    for (int i = 0; i < 10; i++)
+      ;
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C
new file mode 100644
index 00000000000..49971d58356
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings2.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed warnings
+class K {
+public:
+        void f() {
+        }; // there should be no warning about this semicolon
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C
new file mode 100644
index 00000000000..14fe9978547
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings3.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall
+// GROUPS passed warnings
+class A {
+int i;
+public:
+        void funcA(void) { 
+                funcB(); 
+        }
+
+	// The compiler should not emit a warning about not being
+	// able to inline this function.
+        void funcB(void) { 
+                i++; 
+        }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C
new file mode 100644
index 00000000000..d733522824e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+int
+main ()
+{
+  register int x;
+  int * foo = &x; // in C++ it's perfectly legal to do this
+
+  return 0;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C
new file mode 100644
index 00000000000..5a953fd1c54
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings5.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed warnings
+enum TypeKind { ATK, BTK } ;
+
+struct Type {
+  enum TypeKind kind : 8;
+  void setBTK();
+};
+
+void Type::setBTK() { kind = BTK; }
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C
new file mode 100644
index 00000000000..785c083464a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings6.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall -ansi -pedantic
+// GROUPS passed warnings
+// should not emit this warning about func:
+// 	x.C:2: warning: invalid storage class for function `func'
+//
+template <class T> inline void func(T)
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C
new file mode 100644
index 00000000000..24e7a2cde0d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings7.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// Special g++ Options: -O2 -Wall
+// GROUPS passed warnings
+template<class T>
+class X {
+public:
+    void kill(unsigned i)
+	{ vec[i].~T(); }
+    T *vec;
+};
+
+class Y { };
+
+void
+x()
+{
+    X<int> x;
+    x.kill(0);
+    X<Y> y;
+    y.kill(0);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C
new file mode 100644
index 00000000000..5599918fd12
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings8.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -Wall
+// GROUPS passed warnings
+bool foo(unsigned char c)
+{
+  return (c & 17) != 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C b/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C
new file mode 100644
index 00000000000..c46f2a1e45d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.brendan/warnings9.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// Special g++ Options: -Wall
+// GROUPS passed warnings
+inline int foo()
+{
+  return 3;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/891229_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/891229_02.C
new file mode 100644
index 00000000000..042096c81b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/891229_02.C
@@ -0,0 +1,24 @@
+// g++ 1.36.1 bug 891229_02
+
+// g++ limits the scope of names which are declared as typedef names within
+// another type to that other type.
+
+// This conflicts with the (global) scope given to such names by cfront 2.0.
+
+// Cfront 2.0 passes this test.
+
+// Note 2/15/94:  The standard has changed; this limiting of scope is correct
+// behavior.  See 9.9.  --jason
+
+// keywords: typedef, nested types, scope
+
+struct foo {
+	foo ();
+	typedef void (*function_p) (void);
+};
+
+function_p fp;		// ERROR - no such type in scope
+
+foo::foo () {}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/891230_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/891230_01.C
new file mode 100644
index 00000000000..ac49e0bd444
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/891230_01.C
@@ -0,0 +1,20 @@
+// g++ 1.36.1 bug 891230_01
+
+// g++ gives typedefs which are nested within class declarations a scope
+// which is local to the class declaration itself.  This causes examples
+// like the following to get compile-time errors.
+
+// Cfront 2.0 passes this test.
+
+// keywords: typedef, nested types, scope
+
+struct foo {
+
+    typedef foo* foo_p;
+    void member (foo_p);
+};
+
+void foo::member (foo_p p) {	// gets bogus errors
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900107_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900107_01.C
new file mode 100644
index 00000000000..7271f1aa71e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900107_01.C
@@ -0,0 +1,37 @@
+// g++ 1.36.1 bug 900107_01
+
+// Unlike GCC and Cfront 2.0, the g++ 1.36.1 compiler gives struct, union,
+// and class declarations which are nested within blocks file scope.
+
+// Cfront 2.0 passes this test.
+
+// keywords: block scope, file scope, nested types, tagged types
+
+class c1 { int c1_member1; };
+struct s1 { int s1_member1; };
+union u1 { int u1_member1; };
+enum e1 { e1_val1 };
+typedef int t1;
+
+void foo ()
+{
+  class c1 {			// gets bogus error
+    int c1_member1;
+  } c1_local_object_0;
+
+  struct s1 {			// gets bogus error
+    int s1_member1;
+  } s1_local_object_0;
+
+  union u1 {			// gets bogus error
+    int u1_member1;
+  } u1_local_object_0;
+
+  enum e1 {		// OK using g++ or GCC, but mishandled by Cfront 2.0.
+    e1_value1
+  } e1_local_object_0;
+
+  typedef int t1;		// OK
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900119_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900119_01.C
new file mode 100644
index 00000000000..2eb8906ddd1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900119_01.C
@@ -0,0 +1,46 @@
+// g++ 1.36.1 bug 900119_01
+
+// g++ allows initializers to be included in the declaration of members
+// of classes, structs, unions (even when -pedantic is used).
+
+// This is not allowed by the C++ 2.0 Reference Manual or by Cfront 2.0.
+
+// keywords: member declaration, member initialization
+
+int global_int;
+
+class class0 {
+public:
+  int class0_member_0 = 99;			/* ERROR -  */
+  static int class0_member_1 = 99;		/* ERROR -  */
+  int &class0_member_2 = global_int;		/* ERROR -  */
+
+  class0 () : class0_member_2 (global_int) { }
+};
+
+
+struct struct0 {
+  int struct0_member_0 = 99;			/* ERROR -  */
+  static int struct0_member_1 = 99;		/* ERROR -  */
+  int &struct0_member_2 = global_int;		/* ERROR -  */
+
+  struct0 () : struct0_member_2 (global_int) { }
+};
+
+// g++ does not allow unions to have more than one member with an initializer
+
+union union0 {
+  int union0_member_0 = 99;			/* ERROR -  */
+};
+
+union union1 {
+  //static int union1_member_0 = 99;		/* definitely illegal (9.5) */
+};
+
+union union2 {
+  int &union2_member_0 = global_int;		/* ERROR -  */
+
+  union2 () : union2_member_0 (global_int) { }
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900121_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900121_01.C
new file mode 100644
index 00000000000..99ab8f6cbcf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900121_01.C
@@ -0,0 +1,16 @@
+// g++ 1.36.1 bug 900121_01
+
+// The following file causes g++ 1.36.1 (and 1.36.2) to abort.
+
+// Cfront 2.0 passes this test.
+
+// keywords: abort, incomplete types, reference types, formal parameters
+
+struct s0;
+
+void function (struct s0 &arg1, struct s0 &arg2)
+{
+  arg1 = arg2;		// ERROR - causes abort
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900121_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900121_02.C
new file mode 100644
index 00000000000..c90dfd9aaa4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900121_02.C
@@ -0,0 +1,49 @@
+// g++ 1.36.1 bug 900121_02
+
+// Assignment of structs is defined as memberwise assignment,
+// however g++ (1.36.2) and Cfront 2.0 differ on the definition
+// of assignment for unions.
+
+// (NOTE: Stroustrup now says that assignment of unions which contain either
+// members or sub-members (base classes are not allowed for unions) which
+// have non-default assignment operators defined for them will be illegal
+// in future.)
+
+// g++ (1.36.2) on the other hand, accepts this program without errors.
+
+// keywords: unions, operator=, inheritance, members
+
+struct s0 {
+
+  int i;
+
+  void operator= (s0 & arg)
+  {
+    this->i = arg.i;
+  }
+};
+
+struct s1 {
+
+  double d;
+
+  void operator= (s1 & arg)
+  {
+    this->d = arg.d;
+  }
+};
+
+union u0 {
+  s0 u0_member_0;		// ERROR - 
+  s1 u0_member_1;		// ERROR - 
+};
+
+void function ()
+{
+  u0 u0_object_0;
+  u0 u0_object_1;
+
+  u0_object_0 = u0_object_1;
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900121_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900121_05.C
new file mode 100644
index 00000000000..03155abf52e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900121_05.C
@@ -0,0 +1,30 @@
+// g++ 1.36.1 bug 900121_05
+
+// g++ allows unions to have base types (i.e. to be "derived") and it allows
+// other types to have unions as base types.  Both cases are illegal.
+
+// g++ curently does not detect such errors.
+
+// Cfront 2.0 passes this test.
+
+// keywords: unions, inheritance
+
+struct s0 {
+  int s0_member;
+};
+
+union u0 : public s0 {			/* ERROR - union has base class */
+  int u0_member_0;
+  int u0_member_1;
+};
+
+union u1 {
+  int u1_member_0;
+  int u1_member_1;
+};
+
+struct s1 : public u1 {			/* ERROR - base class is a union */
+  int s1_member_0;
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900127_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900127_01.C
new file mode 100644
index 00000000000..7c24d08bc10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900127_01.C
@@ -0,0 +1,25 @@
+// g++ 1.36.1 bug 900127_01
+
+// g++ often fails to detect (and issue errors for) ambiguous overload
+// situations.  In such cases, one of the possibilities is chosen
+// (apparently arbitrarily). Errors should be issued instead.
+
+// Cfront 2.0 passes this test.
+
+// keywords: function overloading, ambiguity
+
+void foo (int);
+int foo (void);
+
+typedef int (*f_ptr_t1) (void);
+typedef void (*f_ptr_t2) (int);
+
+void bar (f_ptr_t1);		// ERROR - 
+void bar (f_ptr_t2);		// ERROR - 
+
+void function ()
+{
+  bar (foo);			// ERROR - ambiguous
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900127_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900127_02.C
new file mode 100644
index 00000000000..61cd481cecc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900127_02.C
@@ -0,0 +1,46 @@
+// g++ 1.36.1 bug 900127_02
+
+// g++ (mostly) keeps separate name spaces for the declarations of data
+// objects and functions.
+
+// This means that a single name may be declared as both a data object and
+// a function within a given scope.
+
+// This fact allows programmers to write code which is not portable to the
+// Cfront translator (which keeps a single namespace for these entities).
+
+// This can also lead to ambiguity when the & (address-of) operator is used.
+
+// Cfront 2.0 passes this test.
+
+// keywords: name spaces, overloading
+
+int global0;			// ERROR - 
+int global0 ();			// ERROR - 
+
+int global1 ();			// ERROR - xref for below
+int global1;			// ERROR - caught
+
+struct struct_0 {
+  int class_local ();		// ERROR - 
+  int class_local;		// ERROR - 
+};
+
+struct struct_1 {
+  int class_local;		// ERROR - 
+  int class_local ();		// ERROR - 
+};
+
+void function_0 ()
+{
+	int function_0_local;	// ERROR - 
+	extern int function_0_local ();	// ERROR - 
+}
+
+void function_1 ()
+{
+	int function_1_local ();        // ERROR - 
+	extern int function_1_local;	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900205_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900205_02.C
new file mode 100644
index 00000000000..505792f0dfa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900205_02.C
@@ -0,0 +1,28 @@
+// g++ 1.36.1 bug 900205_02
+
+// g++ allows constructors to be defined which do not include
+// initializations for reference members of their associated classes.
+
+// Cfront 2.0 does not allow this.
+
+// keywords: reference members, constructors, member initialization
+
+int i;
+
+class c0 {
+  int &int_ref;
+public:
+  c0 () /* : int_ref(i) */ {	// ERROR - reference needs initializer
+  }
+};
+
+class c1 {
+  int &int_ref;
+public:
+  c1 ();
+};
+
+c1::c1() /* : int_ref(i) */ {	// ERROR - reference needs initializer
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900205_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900205_03.C
new file mode 100644
index 00000000000..4c352c87ae4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900205_03.C
@@ -0,0 +1,48 @@
+// g++ 1.36.1 bug 900205_03
+
+// Section 6.6.3 of the cfront 2.0 Reference Manual says "A return statement
+// without an expression can be used only in functions that do not return
+// a value, that is, a function with the return value type void..."
+
+// Also in 6.6.3: "Flowing off the end of a function is equivalent to a
+// return with no value; this is illegal in a value returning function."
+
+// In contrast to the manual, g++ does not generate ERRORs for cases of
+// "flowing off the end" of non-void functions.
+
+// keywords: return statements, return type, void return, implicit return
+
+// Special g++ Options: -Wreturn-type -pedantic-errors
+
+struct struct00 { };
+
+int global_function_0 () {
+}					// ERROR - 
+
+struct00 global_function_1 () {
+}					// ERROR - 
+
+struct struct0 {
+
+  int struct0_member_function_0 () {
+  }					// ERROR - 
+
+  struct0 struct0_member_function_1 () {
+  }					// ERROR - 
+};
+
+struct struct1 {
+
+  int struct1_member_function_0 ();
+
+  struct1 struct1_member_function_1 ();
+
+};
+
+int struct1_member_function_0 () {
+}					// ERROR - 
+
+struct1 struct1::struct1_member_function_1 () {
+}				        // ERROR - 
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900205_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900205_04.C
new file mode 100644
index 00000000000..f763480d45f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900205_04.C
@@ -0,0 +1,26 @@
+// g++ 1.36.1 bug 900205_04
+
+// g++ allows a class for which an implicit default X::X() constructor must
+// be created (implicitly by the compiler) to be derived from another class
+// which does not have its own default X::X() constructor.  This is illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: default constructor, inheritance
+
+struct struct0 {
+  int data_member;
+
+  struct0 (int, void *);	// suppresses implicit default constructor
+};
+
+struct0::struct0 (int, void *)
+{
+}
+
+struct struct0_derived_struct_0 : public struct0 {
+};							// ERROR - 
+
+// struct0_derived_struct_0 object;	// would give g++ error if compiled
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900207_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900207_03.C
new file mode 100644
index 00000000000..187c070acb8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900207_03.C
@@ -0,0 +1,49 @@
+// g++ 1.36.1 bug 900207_03
+
+// g++ fails to allow objects of class or struct types to be initialized
+// using "constructor syntax" in cases where an implicitly generated copy
+// constructor would be invoked for the initialization, and where there is
+// no explicitly specified constructor associated with the type of the
+// object being initialized.
+
+// Note that the type of the error changes depending upon whether or not the
+// type being initialized has any virtual functions associated with it.
+
+// Cfront 2.0 passes this test.
+
+// keywords: implicit copy constructor, initialization
+
+
+// Check construction for a type without virtual function members.
+
+struct struct0 {
+  int data_member;
+};
+
+struct0 struct0_gbl_object0;
+struct0 struct0_gbl_object1 (struct0_gbl_object0);	// gets bogus error
+
+void struct0_test ()
+{
+  struct0 struct0_lcl_object1 (struct0_gbl_object0);	// gets bogus error
+}
+
+// Check construction for a type with virtual function members.
+
+struct struct1 {
+  int data_member;
+
+  virtual void function_member ();
+};
+
+void struct1::function_member () { }
+
+struct1 struct1_gbl_object0;
+struct1 struct1_gbl_object1 (struct1_gbl_object0);	// gets bogus error
+
+void struct1_test ()
+{
+  struct1 struct1_lcl_object1 (struct1_gbl_object0);	// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900208_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900208_02.C
new file mode 100644
index 00000000000..7e99abdb00f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900208_02.C
@@ -0,0 +1,17 @@
+// g++ 1.36.1 bug 900208_02
+
+// g++ does not allow a static member of a class/struct/union to be
+// declared as an array without an explicit upper bound.
+
+// Cfront 2.0 passes this test.
+
+// keywords: static data members, arrays, dimension, array bound
+
+class class0 {
+public:
+  static int class0_data_member_0[];	// gets bogus error
+};
+
+int class0::class0_data_member_0[3] = { 1, 2, 3 };  // gets bogus error
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900208_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900208_03.C
new file mode 100644
index 00000000000..667a174de22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900208_03.C
@@ -0,0 +1,18 @@
+// g++ 1.36.1 bug 900208_03
+
+// The Cfront 2.0 reference manual (5.3.3) says "This type must be an
+// object type; functions cannot be allocated this way...".
+
+// g++ fails to detect (at compile time) cases where an attempt is made to
+// allocate a function using new.
+
+// keywords: operator new, function types
+
+typedef void (func_type) ();
+
+void global_function_0 ()
+{
+  new func_type;	// ERROR - missed by both cfront 2.0 and g++ 1.36.1
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900208_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900208_04.C
new file mode 100644
index 00000000000..bcf03973f10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900208_04.C
@@ -0,0 +1,20 @@
+// g++ 1.36.1 bug 900208_04
+
+// The Cfront 2.0 reference manual (5.3.3) says "This type must be an
+// object type; functions cannot be allocated this way...".
+
+// g++ fails to detect (at compile time) cases where an attempt is made to
+// deallocate a function using delete.
+
+// Cfront 2.0 passes this test.
+
+// keywords: operator delete, function types
+
+typedef void (func_type) ();
+
+void global_function_1 (func_type *p)
+{
+  delete p;		// ERROR - caught by Cfront 2.0 but not by g++ 1.36.1
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900209_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900209_01.C
new file mode 100644
index 00000000000..59871ab31ed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900209_01.C
@@ -0,0 +1,20 @@
+// g++ 1.36.1 bug 900209_01
+
+// g++ implicitly casts values whose types are "void*" to other pointer
+// types (just as the language rules for C permit).  Such implicit
+// conversions are not allowed by the Cfront 2.0 Reference Manual
+// however.
+
+// Cfront 2.0 passes this test.
+
+// keywords: void pointers, type conversions, pointer type conversions
+
+void * void_pointer_object;
+char * char_pointer_object;
+
+void global_function_0 ()
+{
+  char_pointer_object = void_pointer_object;	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_01.C
new file mode 100644
index 00000000000..0a98388f915
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_01.C
@@ -0,0 +1,112 @@
+// g++ 1.36.1 bug 900210_01
+
+// g++ allows pointer type values to be assigned to variables of integal
+// types.  According to the C++ Reference Manual, this is illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: pointer types, integral types, implicit type conversions
+
+int i;
+long l;
+short s;
+char c;
+float f;
+double d;
+long double ld;
+enum {enum_value_0} e;
+
+signed int si;
+signed long sl;
+signed short ss;
+signed char sc;
+
+unsigned int ui;
+unsigned long ul;
+unsigned short us;
+unsigned char uc;
+
+void* vp;
+char* cp;
+int* ip;
+enum {enum_value_1} * ep;
+struct { int member; } * sp;
+void (*fp) (void);
+
+void global_function ()
+{
+  i = vp;	/* ERROR -  */
+  i = cp;	/* ERROR -  */
+  i = ip;	/* ERROR -  */
+  i = ep;	/* ERROR -  */
+  i = sp;	/* ERROR -  */
+  i = fp;	/* ERROR -  */
+  l = vp;	/* ERROR -  */
+  l = cp;	/* ERROR -  */
+  l = ip;	/* ERROR -  */
+  l = ep;	/* ERROR -  */
+  l = sp;	/* ERROR -  */
+  l = fp;	/* ERROR -  */
+  s = vp;	/* ERROR -  */
+  s = cp;	/* ERROR -  */
+  s = ip;	/* ERROR -  */
+  s = ep;	/* ERROR -  */
+  s = sp;	/* ERROR -  */
+  s = fp;	/* ERROR -  */
+  c = vp;	/* ERROR -  */
+  c = cp;	/* ERROR -  */
+  c = ip;	/* ERROR -  */
+  c = ep;	/* ERROR -  */
+  c = sp;	/* ERROR -  */
+  c = fp;	/* ERROR -  */
+  si = vp;	/* ERROR -  */
+  si = cp;	/* ERROR -  */
+  si = ip;	/* ERROR -  */
+  si = ep;	/* ERROR -  */
+  si = sp;	/* ERROR -  */
+  si = fp;	/* ERROR -  */
+  sl = vp;	/* ERROR -  */
+  sl = cp;	/* ERROR -  */
+  sl = ip;	/* ERROR -  */
+  sl = ep;	/* ERROR -  */
+  sl = sp;	/* ERROR -  */
+  sl = fp;	/* ERROR -  */
+  ss = vp;	/* ERROR -  */
+  ss = cp;	/* ERROR -  */
+  ss = ip;	/* ERROR -  */
+  ss = ep;	/* ERROR -  */
+  ss = sp;	/* ERROR -  */
+  ss = fp;	/* ERROR -  */
+  sc = vp;	/* ERROR -  */
+  sc = cp;	/* ERROR -  */
+  sc = ip;	/* ERROR -  */
+  sc = ep;	/* ERROR -  */
+  sc = sp;	/* ERROR -  */
+  sc = fp;	/* ERROR -  */
+  ui = vp;	/* ERROR -  */
+  ui = cp;	/* ERROR -  */
+  ui = ip;	/* ERROR -  */
+  ui = ep;	/* ERROR -  */
+  ui = sp;	/* ERROR -  */
+  ui = fp;	/* ERROR -  */
+  ul = vp;	/* ERROR -  */
+  ul = cp;	/* ERROR -  */
+  ul = ip;	/* ERROR -  */
+  ul = ep;	/* ERROR -  */
+  ul = sp;	/* ERROR -  */
+  ul = fp;	/* ERROR -  */
+  us = vp;	/* ERROR -  */
+  us = cp;	/* ERROR -  */
+  us = ip;	/* ERROR -  */
+  us = ep;	/* ERROR -  */
+  us = sp;	/* ERROR -  */
+  us = fp;	/* ERROR -  */
+  uc = vp;	/* ERROR -  */
+  uc = cp;	/* ERROR -  */
+  uc = ip;	/* ERROR -  */
+  uc = ep;	/* ERROR -  */
+  uc = sp;	/* ERROR -  */
+  uc = fp;	/* ERROR -  */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_02.C
new file mode 100644
index 00000000000..f900a86db0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_02.C
@@ -0,0 +1,112 @@
+// g++ 1.36.1 bug 900210_02
+
+// g++ allows integral type values to be assigned to variables of pointer
+// types.  According to the C++ Reference Manual, this is illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: integral types, pointer types, implicit type conversions
+// Special Options: -ansi -pedantic-errors
+int i;
+long l;
+short s;
+char c;
+float f;
+double d;
+long double ld;
+enum {enum_value_0} e;
+
+signed int si;
+signed long sl;
+signed short ss;
+signed char sc;
+
+unsigned int ui;
+unsigned long ul;
+unsigned short us;
+unsigned char uc;
+
+void* vp;
+char* cp;
+int* ip;
+enum {enum_value_1} * ep;
+struct { int member; } * sp;
+void (*fp) (void);
+
+void global_function ()
+{
+  vp = i;	/* ERROR -  */
+  vp = l;	/* ERROR -  */
+  vp = s;	/* ERROR -  */
+  vp = c;	/* ERROR -  */
+  vp = si;	/* ERROR -  */
+  vp = sl;	/* ERROR -  */
+  vp = ss;	/* ERROR -  */
+  vp = sc;	/* ERROR -  */
+  vp = ui;	/* ERROR -  */
+  vp = ul;	/* ERROR -  */
+  vp = us;	/* ERROR -  */
+  vp = uc;	/* ERROR -  */
+  cp = i;	/* ERROR -  */
+  cp = l;	/* ERROR -  */
+  cp = s;	/* ERROR -  */
+  cp = c;	/* ERROR -  */
+  cp = si;	/* ERROR -  */
+  cp = sl;	/* ERROR -  */
+  cp = ss;	/* ERROR -  */
+  cp = sc;	/* ERROR -  */
+  cp = ui;	/* ERROR -  */
+  cp = ul;	/* ERROR -  */
+  cp = us;	/* ERROR -  */
+  cp = uc;	/* ERROR -  */
+  ip = i;	/* ERROR -  */
+  ip = l;	/* ERROR -  */
+  ip = s;	/* ERROR -  */
+  ip = c;	/* ERROR -  */
+  ip = si;	/* ERROR -  */
+  ip = sl;	/* ERROR -  */
+  ip = ss;	/* ERROR -  */
+  ip = sc;	/* ERROR -  */
+  ip = ui;	/* ERROR -  */
+  ip = ul;	/* ERROR -  */
+  ip = us;	/* ERROR -  */
+  ip = uc;	/* ERROR -  */
+  ep = i;	/* ERROR -  */
+  ep = l;	/* ERROR -  */
+  ep = s;	/* ERROR -  */
+  ep = c;	/* ERROR -  */
+  ep = si;	/* ERROR -  */
+  ep = sl;	/* ERROR -  */
+  ep = ss;	/* ERROR -  */
+  ep = sc;	/* ERROR -  */
+  ep = ui;	/* ERROR -  */
+  ep = ul;	/* ERROR -  */
+  ep = us;	/* ERROR -  */
+  ep = uc;	/* ERROR -  */
+  sp = i;	/* ERROR -  */
+  sp = l;	/* ERROR -  */
+  sp = s;	/* ERROR -  */
+  sp = c;	/* ERROR -  */
+  sp = si;	/* ERROR -  */
+  sp = sl;	/* ERROR -  */
+  sp = ss;	/* ERROR -  */
+  sp = sc;	/* ERROR -  */
+  sp = ui;	/* ERROR -  */
+  sp = ul;	/* ERROR -  */
+  sp = us;	/* ERROR -  */
+  sp = uc;	/* ERROR -  */
+  fp = i;	/* ERROR -  */
+  fp = l;	/* ERROR -  */
+  fp = s;	/* ERROR -  */
+  fp = c;	/* ERROR -  */
+  fp = si;	/* ERROR -  */
+  fp = sl;	/* ERROR -  */
+  fp = ss;	/* ERROR -  */
+  fp = sc;	/* ERROR -  */
+  fp = ui;	/* ERROR -  */
+  fp = ul;	/* ERROR -  */
+  fp = us;	/* ERROR -  */
+  fp = uc;	/* ERROR -  */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_03.C
new file mode 100644
index 00000000000..8711d868a06
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_03.C
@@ -0,0 +1,26 @@
+// g++ 1.36.1 bug 900210_03
+
+// g++ allows void* type values to be assigned to variables of other
+// pointer types.  According to the C++ Reference Manual, this is illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: void pointers, pointer type conversions, implicit type conversions
+
+void* vp;
+char* cp;
+int* ip;
+enum {enum_value_1} * ep;
+struct { int member; } * sp;
+void (*fp) (void);
+
+void global_function ()
+{
+  cp = vp;	/* ERROR -  */
+  ip = vp;	/* ERROR -  */
+  ep = vp;	/* ERROR -  */
+  sp = vp;	/* ERROR -  */
+  fp = vp;	/* ERROR -  */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_05.C
new file mode 100644
index 00000000000..fc0ead9b514
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_05.C
@@ -0,0 +1,37 @@
+// g++ 1.36.1 bug 900210_05
+
+// Section 18.3 of the 2.0 Reference Manual says "An implementation
+// providing { anachronistic features } should also provide a way for
+// the user to ensure that they do not occur in a source file."
+
+// The *only* proper way to "ensure" an absence of anachronstic features
+// is for C++ language processors to generate errors (rather than just
+// warnings) when such features are used. These errors could perhaps be
+// triggered by some set of command line options, or by the absence of
+// certain command line options.  (For g++, the -pedantic and -traditional
+// options come to mind.)
+
+// The use of errors rather than warnings is important because errors
+// usually result in non-zero exit status codes for language processors
+// and these non-zero exit stati can be automatically checked during
+// normal execution of a Makefile.
+
+// cfront 2.0 provides the +p option which causes errors to be generated for
+// all cases of anachronistic usage.
+
+// g++ generates neither errors nor warnings for such usage, even when the
+// -ansi and -pedantic options are used.
+
+// Cfront 2.0 passes this test.
+
+// keywords: anachronism, enum types, integral types, implicit type conversions
+
+enum enum0 { enum_value_0 } enum0_object;
+int int0_object;
+
+void function ()
+{
+  enum0_object = int0_object;	/* ERROR - */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_06.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_06.C
new file mode 100644
index 00000000000..d52f51143de
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_06.C
@@ -0,0 +1,25 @@
+// g++ 1.36.1 bug 900210_06
+
+// g++ allows values of pointer-to-const types to be assigned to variables
+// of pointer-to-non-const types.
+
+// Cfront 2.0 disallows such assignments.
+
+// g++ also allows values of pointer-to-volatile types to be assigned to
+// variables of pointer-to-non-volatile types.
+
+// Cfront 2.0 *would* disallow this (if it only supported "volatile").
+
+// keywords: pointer types, implicit type conversions
+
+const char *ccp;
+volatile char *vcp;
+char *cp;
+
+void function ()
+{
+  cp = ccp;		/* ERROR - */
+  cp = vcp;		/* ERROR - */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_07.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_07.C
new file mode 100644
index 00000000000..10130586d30
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_07.C
@@ -0,0 +1,19 @@
+// g++ 1.36.1 bug 900210_07
+
+// g++ allows values of pointer-to-signed types to be assigned to variables
+// of pointer-to-unsigned types, and vise versa.
+
+// Cfront 2.0 passes this test.
+
+// keyowrds: pointer types, implicit type conversions
+// Special Options: -ansi -pedantic-errors
+signed int *sip;
+unsigned int *uip;
+
+void function ()
+{
+  sip = uip;		// ERROR - 
+  uip = sip;		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_08.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_08.C
new file mode 100644
index 00000000000..40704d470c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_08.C
@@ -0,0 +1,18 @@
+// g++ 1.36.1 bug 900210_08
+
+// g++ allows pointer-to-const values to be implicitly converted to
+// void* values.  This causes a silent loss of the const qualifier.
+
+// Cfront 2.0 passes this test.
+
+// keywords: pointer types, implicit type conversions
+
+const char *ccp;
+void *vp;
+
+void function ()
+{
+  vp = ccp;		/* ERROR - */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_09.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_09.C
new file mode 100644
index 00000000000..ce78540565b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_09.C
@@ -0,0 +1,32 @@
+// g++ 1.36.1 bug 900210_09
+
+// g++ allows pointer to members (both data members and function members)
+// to be implicitly converted to void*.
+
+// Section 4.8 of the Cfront 2.0 Reference Manual disallows such implicit
+// conversions.
+
+// Cfront 2.0 passes this test.
+
+// keywords: member pointers, void pointers, implicit type conversions
+
+class class0 {
+public:
+  int class0_data_member_0;
+  void class0_function_member_0 ();
+};
+
+int class0::*class0_data_member_pointer;
+int (class0::*class0_function_member_pointer) ();
+
+void *vp;
+
+void global_function_0 ()
+{
+  vp = class0_data_member_pointer;		// ERROR - 
+  vp = class0_function_member_pointer;		// ERROR - 
+}
+
+int main () { return 0; }
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900210_10.C b/gcc/testsuite/g++.old-deja/g++.bugs/900210_10.C
new file mode 100644
index 00000000000..26c17218e77
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900210_10.C
@@ -0,0 +1,14 @@
+// g++ 1.36.1 bug 900210_10
+
+// g++ allows operator[] to be declared as a static member function.
+// This is illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: operator[], static function members
+
+struct struct0 {
+  static int operator[] ();		/* ERROR - */
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900211_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900211_01.C
new file mode 100644
index 00000000000..75c99b6ee0d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900211_01.C
@@ -0,0 +1,16 @@
+// g++ 1.36.1 bug 900211_01
+
+// g++ issues only warnings for calls to previously undeclared functions,
+// however such calls are actually errors.
+
+// Cfront 2.0 passes this test.
+
+// keywords: undeclared, functions
+// Build don't link: 
+
+void global_function_0 ()
+{
+  global_function_1 ();		/* ERROR - */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900211_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900211_02.C
new file mode 100644
index 00000000000..d23a9df1ab5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900211_02.C
@@ -0,0 +1,24 @@
+// g++ 1.36.1 bug 900211_02
+
+// g++ allows you to explicitly specify the return type for a type conversion
+// operator.
+
+// The Cfront 2.0 Reference Manual (12.3.2) says that this in not allowed.
+
+// Cfront 2.0 passes this test.
+
+// keywords: type conversion operators, return type
+
+struct struct0 { int member_0; };
+
+struct0 struct0_object_0;
+
+struct struct1 {
+  struct0 operator struct0 ();		/* ERROR - */
+};
+
+struct0 struct1::operator struct0 () {	// ERROR - 
+  return struct0_object_0;
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900211_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900211_03.C
new file mode 100644
index 00000000000..b805f78bd1f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900211_03.C
@@ -0,0 +1,14 @@
+// g++ 1.36.1 bug 900211_03
+
+// The following erroneous code causes g++ to segfault.
+
+// Cfront 2.0 passes this test.
+
+// keywords: segfault, operator new, arrays, undeclared, array bound
+
+void function ()
+{
+  char* new_base = new char[x];		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900211_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900211_04.C
new file mode 100644
index 00000000000..81bea9ef7f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900211_04.C
@@ -0,0 +1,27 @@
+// g++ 1.36.1 bug 900211_04
+
+// g++ fails to flag as errors attempts to compare pointer values against
+// (non-zero) integer values;
+
+// Since implicit conversions of pointer to integers (or vise versa) are
+// illegal, these comparisons are also illegal.
+
+// Cfront 2.0 passes this test.
+
+// keywords: comparison operators, pointer types, integral types
+
+int result;
+int i;
+char *p;
+
+void function ()
+{
+  result = i == p;	/* ERROR - caught by g++ */
+  result = i != p;	/* ERROR - caught by g++ */
+  result = i >  p;	/* ERROR - missed */
+  result = i <  p;	/* ERROR - missed */
+  result = i >= p;	/* ERROR - missed */
+  result = i <= p;	/* ERROR - missed */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900212_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900212_01.C
new file mode 100644
index 00000000000..03c41fb0423
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900212_01.C
@@ -0,0 +1,38 @@
+// g++ 1.36.1 bug 900212_01
+
+// g++ fails to flag as errors all attempts to add or subtract integer values
+// from pointers-to-member values.
+
+// Some cases are detected however.
+
+// Cfront 2.0 passes this test.
+
+// keywords: pointer arithmetic, member pointers
+
+struct struct0 {
+};
+
+int struct0::*p0;
+int struct0::*p1;
+
+int (struct0::*fp0) ();
+int (struct0::*fp1) ();
+
+void global_function_0 ()
+{
+  p0 = p1 + 3;			// ERROR - 
+  p0 = p1 - 3;			// ERROR - 
+  p1++;				/* ERROR - caught by g++ */
+  ++p1;				/* ERROR - caught by g++ */
+  p1--;				/* ERROR - caught by g++ */
+  --p1;				/* ERROR - caught by g++ */
+
+  fp0 = fp1 + 3;		// ERROR - 
+  fp0 = fp1 - 3;		// ERROR - 
+  fp1++;			/* ERROR - */
+  ++fp1;			/* ERROR - */
+  fp1--;			/* ERROR - */
+  --fp1;			/* ERROR - */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900212_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900212_02.C
new file mode 100644
index 00000000000..d997b61e26e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900212_02.C
@@ -0,0 +1,27 @@
+// g++ 1.36.1 bug 900212_02
+
+// g++ fails to flag as errors attempts to take the difference of two values
+// of some compatible pointer-to-member type.
+
+// Cfront 2.0 passes this test.
+
+// keywords: pointer arithmetic, subtraction, member pointers
+
+struct struct0 {
+};
+
+int struct0::*p0;
+int struct0::*p1;
+
+int (struct0::*fp0) ();
+int (struct0::*fp1) ();
+
+int result;
+
+void global_function_0 ()
+{
+  result = (p0 - p1);		// ERROR - 
+  result = (fp0 - fp1);		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900212_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900212_03.C
new file mode 100644
index 00000000000..479e32c795c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900212_03.C
@@ -0,0 +1,33 @@
+// g++ 1.36.1 bug 900212_03
+
+// g++ segfaults on any attempt to use the ->* operator.
+
+// Cfront 2.0 passes this test.
+
+// keywords: member pointers, operator->*
+
+struct struct0 {
+  int data_member;
+  void function_member ();
+};
+
+void struct0::function_member ()
+{
+}
+
+int i;
+
+int struct0::*dmp;
+void (struct0::*fmp) ();
+
+struct0 *ptr;
+
+void global_function_0 ()
+{
+  i = ptr->*dmp;				// causes segfault
+  (ptr->*fmp) ();				// causes segfault
+  // i = ptr->*(&struct0::data_member);		// too complicated for cfront
+  // (ptr->*(&struct0::function_member)) ();	// too complicated for cfront
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900213_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900213_01.C
new file mode 100644
index 00000000000..309a41943da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900213_01.C
@@ -0,0 +1,26 @@
+// g++ 1.36.1 bug 900213_01
+
+// g++ incorrectly diagnoses the error when an attempt is made to reference
+// a non-static data-member without an object indication.
+
+// Similar attempts to reference non-static function-members are correctly
+// diagnosed by g++.
+
+// Cfront 2.0 passes this test.
+
+// keywords: non-static members, member pointers, scope resolution
+
+struct struct0 {
+  int struct0_data_member_0;		/* ERROR - gets error from below */
+  int struct0_function_member_0 ();
+};
+
+int i;
+
+void global_function_0 ()
+{
+  i = struct0::struct0_data_member_0;		/* ERROR - mishandled by g++ */
+  //i = struct0::struct0_function_member_0 ();	/* gets caught by g++ */
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900213_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900213_02.C
new file mode 100644
index 00000000000..c4263f99cd9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900213_02.C
@@ -0,0 +1,21 @@
+// g++ 1.36.1 bug 900213_02
+
+// The following erroneous code causes g++ to abort.
+
+// Cfront 2.0 passes this test.
+
+// keywords: abort, member pointers, operator*
+
+struct struct0 {
+  int data_member;
+};
+
+int i;
+int struct0::*dmp;
+
+void global_function_0 ()
+{
+  i = *dmp;			// ERROR - causes abort
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900213_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900213_03.C
new file mode 100644
index 00000000000..d25a8b2f7f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900213_03.C
@@ -0,0 +1,28 @@
+// g++ 1.36.1 bug 900213_03
+
+// g++ fails to detect an error when the address of a "bound" function is
+// assigned to a pointer-to-member-function variable.
+
+// It does however correctly detect a similar errors for data-members.
+
+// keywords: bound function, operator&, member pointers
+// Build don't link: 
+
+struct struct0 {
+  int data_member;
+  int function_member ();
+};
+
+int i;
+int struct0::*dmp;
+int (struct0::*fmp) ();
+
+struct0 *ptr;
+
+void global_function_0 ()
+{
+  fmp = &ptr->function_member;	// ERROR - missed by g++, warned by cfront, XFAIL *-*-*
+  //dmp = &ptr->data_member;	//  caught by g++, missed by cfront
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900214_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900214_01.C
new file mode 100644
index 00000000000..3aac764f86e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900214_01.C
@@ -0,0 +1,22 @@
+// g++ 1.36.1 bug 900214_01
+
+// g++ allows function members of incomplete types to be declared to be
+// friends of other types.
+
+// Cfront 2.0 passes this test.
+
+// keywords: friends, incomplete types, function members
+
+struct A;
+
+struct B {
+  friend void A::foo();		// ERROR - type A is incomplete
+};
+
+void A::foo();			/* ERROR - also illegal */
+
+struct A {
+  void foo() {}
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900215_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900215_01.C
new file mode 100644
index 00000000000..ff16b2082e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900215_01.C
@@ -0,0 +1,39 @@
+// g++ 1.36.1 bug 900215_01
+
+// g++ allows the definition of a type conversion operator `operator void'
+// for class types, but subsequently fails to generate calls (where needed)
+// for such type conversion operators.
+
+// Cfront 2.0 does generate such calls.
+
+// The following program exits with status 0 when compiled with Cfront 2.0
+// but exits with status 1 when compiled with g++.
+
+// Cfront 2.0 passes this test.
+
+// 4/27/94 (jason): The pre-San Diego working paper prohibits operator
+// void, so we can go back to just ignoring void values.
+
+// keywords: user-defined type conversion operators, void type, explicit casts
+
+struct struct0 {
+
+  operator void ();		// ERROR - operator void
+};
+
+int exit_status = 1;
+
+struct0::operator void ()
+{				// ERROR - operator void
+  exit_status = 0;
+}
+
+struct struct0 s0_object;
+
+int test ()
+{
+  (void) s0_object;
+  return exit_status;
+}
+
+int main () { return test (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900215_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900215_02.C
new file mode 100644
index 00000000000..fb08df3bd33
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900215_02.C
@@ -0,0 +1,47 @@
+// g++ 1.36.1 bug 900215_02
+
+// g++ allows global objects (which happen to be pointers to members of some
+// class X)  to be dereferenced without prefix object specifications within
+// member functions of class X.
+
+// In effect, g++ treats any dereference of a pointer-to-member which appears
+// within the context of a member function (and which is not preceeded by
+// either ->* or .*) as if it had been implicitly prefixed with this->*.
+
+// The 2.0 Reference Manual only provides that such implicit prefixing
+// takes place for *members* of the containing class, and *not* for
+// global objects that happen to have certain types (i.e. pointer-to-member
+// of the containing class).
+
+// Also, cfront 2.0 provides implicit this-> prefixes *only* for *members*
+// of the containing class.
+
+// Cfront 2.0 passes this test.
+
+// keywords: member pointers, this, dereference, members
+
+struct struct0 {
+  int data_member;
+  void function_member ();
+};
+
+int struct0::*dmp;
+int (struct0::*fmp) ();
+int i;
+
+struct struct1 {
+  int data_member;
+
+  void function_member ();
+};
+
+void struct0::function_member ()
+{
+  i = (this->*fmp) ();		// perfectly legal - for both cfront and g++
+  i = this->*dmp;		// perfectly legal - for both cfront and g++
+
+  i = (*fmp) ();		// ERROR - 
+  i = *dmp;			// ERROR - , XFAIL *-*-*
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900220_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900220_01.C
new file mode 100644
index 00000000000..df7e641fe5f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900220_01.C
@@ -0,0 +1,36 @@
+// g++ 1.36.1 bug 900220_01
+
+// Ref: 12.8
+
+// Section 12.8 says:
+
+//	"That is, X::operator=() will be generated only if no assignment
+//	operation is explicitly declared and an object of class X is actually
+//	assigned an object of class X (or an object of a class derived from X)
+//	or if the address of X::operator= is taken.
+
+// g++ does not allow you to take the address of an implicitly generated
+// operator=
+
+// keywords: operator=, implicit copy operator, operator&
+
+struct struct0 {
+  int data_member;
+};
+
+typedef struct0& (struct0::*member_func_t) (const struct0&);
+
+member_func_t member_func;
+
+void global_function_0 (member_func_t member_f)
+{						// gets bogus error - ref from below
+}
+
+void global_function_1 ()
+{
+  member_func = &struct0::operator=;		// gets bogus error
+
+  global_function_0 (&struct0::operator=);	// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900220_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900220_02.C
new file mode 100644
index 00000000000..cf039f646bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900220_02.C
@@ -0,0 +1,30 @@
+// g++ 1.36.1 bug 900220_02
+
+// g++ treats plain `char' and `unsigned char' as different types, however
+// it fails to treat `signed char' as being a different type from plain
+// `char' as called for by both the ANSI C standard and the C++ reference
+// manual.
+
+// keywords: plain char type, signed char type, unsigned char type, overloading
+
+void overloaded (char) {
+}
+
+void overloaded (signed char) {		// gets bogus error
+}
+
+void overloaded (unsigned char) {
+}
+
+void global_function ()
+{
+  char c = 0;
+  signed char sc = 0;
+  unsigned char uc = 0;
+
+  overloaded (c);
+  overloaded (sc);
+  overloaded (uc);
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900220_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900220_03.C
new file mode 100644
index 00000000000..532fc84b52e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900220_03.C
@@ -0,0 +1,51 @@
+// g++ 1.36.1 bug 900220_03
+
+// g++ does not properly disambiguate calls to overloaded functions
+// which are nearly identical except that one take a reference to a
+// type `T' object and another takes a reference to a type `const T'
+// object.
+
+// (Note that the volatile stuff is commented out here because cfront
+// does not yet grok volatile.)
+
+// Cfront 2.0 passes this test.
+
+// keywords: references, overloading, type qualifiers, pointers
+
+int c_call_count = 0;
+int cc_call_count = 0;
+//int vc_call_count = 0;
+
+void overloaded (char&)
+{
+  c_call_count++;
+}
+
+void overloaded (const char&)
+{
+  cc_call_count++;
+}
+
+//void overloaded (volatile char&)
+//{
+//  vc_call_count++;
+//}
+
+int test ()
+{
+  char c = 0;
+  const char cc = 0;
+  //volatile char vc = 0;
+
+  char& cr = c;
+  const char& ccr = cc;
+  //volatile char& vcr = vc;
+
+  overloaded (c);		// OK
+  overloaded (cc);		// gets bogus error
+  //overloaded (vc);		// OK
+
+  return (c_call_count != 1 || cc_call_count != 1 /* || vc_call_count != 1 */);
+}
+
+int main () { return test (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900221_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900221_01.C
new file mode 100644
index 00000000000..92c56fc08ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900221_01.C
@@ -0,0 +1,21 @@
+// g++ 1.36.1 bug 900221_01
+
+// Ref: 3.2
+//
+// Section 3.2 of the C++ 2.0 Reference Manual says:
+//
+//	"Names of formal arguments for a function are treated as if they
+//	were declared in the outermost block of that function"
+//
+// g++ does not enforce this treatment.
+
+// Cfront 2.0 passes this test.
+
+// keywords: scope, formal parameters
+
+void function (int arg1)
+{
+  int arg1;		// ERROR - redeclaration of arg1
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900227_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900227_01.C
new file mode 100644
index 00000000000..77ac1002893
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900227_01.C
@@ -0,0 +1,38 @@
+// g++ 1.37.1 bug 900227_01
+
+// g++ allows pointer type values to be converted to integral types which are
+// not actually large enough to hold the converted values.
+
+// Section 3.3.4 of the ANSI C standard says:
+
+//	A pointer may be converted to an integral type.  The size of the
+//	integer required and the results are implementation defined.  If
+//	the space provided is not long enough, the behavior is undefined.
+
+// I believe that the only proper thing to do in such cases is to generate
+// errors.  After all, if the converted value gets truncated, it is not
+// likely to be useful after that.
+
+// Furthermore, as the following example demonstrates, allowing pointers
+// to be converted to integral types which are not of sufficient size to
+// completely hold the converted values may cause additional troubles.
+
+// I tried the following code on 5 different machines and it failed on
+// all five (unless I also use the GNU assembler and the GNU linker).  Three
+// of the five (Sun3, Sun4, and Symmetry) got link-time errors about byte
+// offset overflows.  The other two (368/SystemV and AViiON) got assembly
+// time errors about relocatable names used in "constant" expressions.
+
+// keywords: casts, pointer types, integral types
+
+// Update 2/10/95: The compiler will now compute these expressions at
+// runtime.  I think this is in the spirit of the GNU compilers (jason).
+
+// Special g++ Options:
+
+int main ();
+
+short s = (short) &main;
+char c = (char) &main;
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900321_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900321_01.C
new file mode 100644
index 00000000000..56a333f532b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900321_01.C
@@ -0,0 +1,29 @@
+// g++ 1.37.1 bug 900321_01
+
+// cfront flags ERRORs on each of the lines indicated below. g++ does not
+// flag either ERRORs or warnings.
+
+// Although I cannot find where in the current C++ Reference Manual this
+// topic is covered, I am sure that these statements should get ERRORs in
+// a "strongly typed" language.
+
+// Cfront 2.0 passes this test.
+
+// keywords: array types, array bound, pointers
+
+int (*ptr_to_array_of_ints)[];
+int (*ptr_to_array_of_3_ints) [3];
+int (*ptr_to_array_of_5_ints) [5];
+
+void function_0 ()
+{
+  // we miss the first two because typeck.c (comp_array_types) deems
+  // it okay if one of the sizes is null
+  ptr_to_array_of_ints = ptr_to_array_of_3_ints;	// ERROR - , XFAIL *-*-*
+  ptr_to_array_of_3_ints = ptr_to_array_of_ints;	// ERROR - , XFAIL *-*-*
+
+  ptr_to_array_of_3_ints = ptr_to_array_of_5_ints;	// ERROR - 
+  ptr_to_array_of_5_ints = ptr_to_array_of_3_ints;	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900321_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900321_02.C
new file mode 100644
index 00000000000..d635ba3d1e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900321_02.C
@@ -0,0 +1,27 @@
+// g++ 1.37.1 bug 900321_02
+
+// The following program exits with a non-zero status because the constructor
+// is not called 3 times as it should be.  This program exits with a zero
+// status when compiled with cfront 2.0.
+
+// Cfront 2.0 passes this test.
+
+// keywords: arrays, initialization, default constructor, operator new
+
+int call_count = 0;
+
+struct struct0 {
+  struct0 ();
+};
+
+struct0::struct0 () { call_count++; }
+
+typedef struct0 array[3];	// known dimension
+
+int test ()
+{
+  new array;
+  return (call_count != 3);
+}
+
+int main () { return test (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900321_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900321_04.C
new file mode 100644
index 00000000000..5f3d5a1471a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900321_04.C
@@ -0,0 +1,16 @@
+// g++ 1.37.1 bug 900321_04
+
+// The following code causes g++ to segfault.
+
+// Cfront 2.0 passes this test.
+
+// keywords: segfault, object declaration, pointer, array, incomplete type
+
+struct incomplete;
+
+void function ()
+{
+  struct incomplete (*ptr)[];		// causes segfault
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900321_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900321_05.C
new file mode 100644
index 00000000000..8f417e892fc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900321_05.C
@@ -0,0 +1,20 @@
+// g++ 1.37.1 bug 900321_05
+
+// The following code is legal as far as the ANSI C standard, GCC, and
+// cfront are concerned, however g++ issues errors for the lines indicated.
+
+// Cfront 2.0 passes this test.
+
+// keywords: operator[], pointers, index
+
+char c;
+char *cp;
+int i;
+
+void function ()
+{
+  c = 3["abcdef"];	// gets bogus error
+  c = i[cp];		// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900322_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900322_01.C
new file mode 100644
index 00000000000..961d95c08a9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900322_01.C
@@ -0,0 +1,51 @@
+// g++ 1.37.1 bug 900322_01
+
+// The ANSI C standard, in section 3.1.2.5 (first paragraph) differentiates
+// types into three disjoint sets, i.e object types, function types, and
+// incomplete types.
+
+// Also in 3.1.2.5 (page 24) the standard says that the element type of
+// an array type is an object type.
+
+// Later in that same section the standard also notes that array types with
+// unknown size are considered incomplete types (page 25).  (Struct & union
+// types which have only been "forward declared" are also incomplete types.)
+
+// Some experts infer this to mean that it is not legal to specify or to
+// construct an array *type* whose element type is an incomplete type.
+
+// This interpretation suggests that the statements indicated below contain
+// errors.
+
+// g++ fails to flag all of the indicated statements with errors (even when
+// the -pedantic option is used).
+
+// keywords: incomplete types, arrays, element types
+
+extern int extern_two_d [] [];		// ERROR - , XFAIL *-*-*
+int tenative_two_d [] [];		// ERROR - caught by g++
+static int static_two_d [] [];		// ERROR - caught by g++
+
+int (*pointer_to_two_d)[][];		// ERROR - , XFAIL *-*-*
+
+void function_0 (int arg [] []) {	/* ERROR - */
+}
+
+typedef int int_one_d_type [];
+typedef int_one_d_type int_two_d_type[];// ERROR - , XFAIL *-*-*
+
+struct s;
+
+extern struct s extern_s_array [10];	// ERROR - , XFAIL *-*-*
+struct s tenative_s_array [10];		/* ERROR - caught by g++ */
+static struct s static_s_array [10];	/* ERROR - caught by g++ */
+
+struct s (*pointer_to_s_array) [];	// ERROR - , XFAIL *-*-*
+
+void function_1 (struct s arg []) {	// ERROR - , XFAIL *-*-*
+}
+
+typedef struct s s_type;
+typedef s_type s_one_d_type [10];	// ERROR - , XFAIL *-*-*
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900324_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900324_02.C
new file mode 100644
index 00000000000..56ff7b738d1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900324_02.C
@@ -0,0 +1,18 @@
+// g++ 1.37.1 bug 900324_02
+
+// The following erroreous code causes g++ to segfault.
+
+// Cfront 2.0 passes this test.
+
+// keywords: segfault, function pointer, conditional operator ?:
+
+void function_0 (int i) { }
+
+void (*fp)(void);
+
+void function_1 ()
+{
+  fp = 1 ? function_0 : fp;		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900324_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900324_03.C
new file mode 100644
index 00000000000..69d9b58f039
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900324_03.C
@@ -0,0 +1,21 @@
+// g++ 1.37.1 bug 900324_03
+
+// g++ is unable to correctly parse declarations of non-global function-pointer
+// variables and/or function-pointer formal parameters.
+
+// Cfront 2.0 passes this test.
+
+// keywords: syntax, function pointers, block local, formal
+
+void (*p0)();				// OK
+
+void function_0 ()
+{
+  void (*p1)();				// gets bogus errors
+}
+
+void function_1 (void (*p2)());		// gets bogus errors
+
+void (*function_2 ()) ();		// OK
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900324_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900324_04.C
new file mode 100644
index 00000000000..c874897e68a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900324_04.C
@@ -0,0 +1,25 @@
+// g++ 1.37.1 bug 900324_04
+
+// g++ implements an extension which supports the copying of array objects.
+
+// This extension is not described in the current C++ Reference Manual, and
+// it is not implemented by cfront (2.0).
+
+// g++ should generate errors for the use of this extension when -pedantic
+// is used, however it does not.
+
+// Cfront 2.0 passes this test.
+
+// keywords: extension, pedantic, arrays, copy
+
+typedef int int_array[20];
+
+int_array ia1;
+int_array ia2;
+
+void function_0 ()
+{
+  ia1 = ia2;		// ERROR - gnu extension
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900324_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900324_05.C
new file mode 100644
index 00000000000..32f691d3719
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900324_05.C
@@ -0,0 +1,21 @@
+// g++ 1.37.1 bug 900324_05
+
+// The following erroneous code causes g++ to segfault.
+
+// Cfront 2.0 passes this test.
+
+// keywords: segfault, arrays, references, assignment operator=
+
+typedef int int_array[];
+
+extern int_array int_array_object;
+
+int_array &left = int_array_object;
+int_array &right = int_array_object;
+
+void function ()
+{
+  left = right;		// ERROR - causes segfault
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900324_06.C b/gcc/testsuite/g++.old-deja/g++.bugs/900324_06.C
new file mode 100644
index 00000000000..5a1938af8b8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900324_06.C
@@ -0,0 +1,28 @@
+// g++ 1.37.1 bug 900324_06
+
+// g++ is unable to use context information (i.e. the required type of the
+// expression) to disambiguate a possibly overloaded function name when that
+// name is used as either the second or the third operand of a ?: operator.
+
+// It is also unable to use the fact that the given name is not in fact
+// overloaded (and has only one possible interpretation).
+
+// This results in improper errors being generated.
+
+// keywords: overloading, function pointers, disambiguation, operator?:
+
+int i;
+void (*p)();
+
+void function_0 ()
+{
+}
+
+void function_1 ()
+{
+  p = i ? function_0 : 0;		// gets bogus error
+  p = i ? 0 : function_0;		// gets bogus error
+  p = i ? function_1 : function_0;	// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900325_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900325_01.C
new file mode 100644
index 00000000000..f11ec189039
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900325_01.C
@@ -0,0 +1,17 @@
+// g++ 1.37.1 bug 900325_01
+
+// g++ fails to generate errors for attempts to declare a formal argument to
+// be of a void type.
+
+// keywords: formal parameter, void type
+
+typedef void __void;
+typedef __void Void;
+
+void function0 (void arg1) {	// ERROR - missed
+}
+
+void function1 (Void arg1) {	// ERROR - missed
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900330_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900330_01.C
new file mode 100644
index 00000000000..651d370ef14
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900330_01.C
@@ -0,0 +1,52 @@
+// g++ 1.37.1 bug 900330_01
+//
+// As indicated by the example at the end of the section 3.5.3 of the ANSI
+// C standard, when a type qualifier (i.e. "const" or "volatile") is applied
+// to an array type, the effect should be as if the element type had been
+// qualified with the given qualifier.
+//
+// This rule applies to C++ also.
+//
+// In section 7.1.6 of the C++ Reference Manual it says "Each element of a
+// const array is const..."
+//
+// It appears however that when a name already exists for a given array type
+// (i.e. a typedef name) and when that name is qualified by a type qualifier,
+// (i.e. "const" or "volatile"), gcc & g++ may act as if the qualifier applied
+// to the named (array) type rather that to the elements of that type.
+//
+// The result is that (even with the -ansi and -pedantic options) g++
+// generates no errors or warnings for the lines indicated (even though it
+// should).
+//
+// Due to the incorrect associations, gcc & g++ will also issue inappropriate
+// warnings in some cases (as illustrated below).
+
+// keywords: type qualifiers, arrays
+
+typedef const int const_int;
+typedef const_int array_of_const_int[3];
+array_of_const_int *ptr_to_array_of_consts;
+
+typedef int array_of_int[3];
+typedef const array_of_int const_array_of_int;
+const_array_of_int *ptr_to_const_array;
+
+void function_0 ()
+{
+  ptr_to_array_of_consts = ptr_to_const_array;	/* gets bogus warning */
+  ptr_to_const_array = ptr_to_array_of_consts;	/* gets bogus warning */
+}
+
+/* The following example is taken from ANSI 3.5.3 */
+
+typedef int A[2][3];
+const A a = {{4, 5, 6}, {7, 8, 9}};
+int *pi;
+
+void function_1 ()
+{
+  pi = a[0];	// ERROR - a[0] has type "const int *"
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900330_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900330_02.C
new file mode 100644
index 00000000000..85c40f0e8d9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900330_02.C
@@ -0,0 +1,29 @@
+// g++ 1.37.1 bug 900330_02
+
+// The C++ Reference Manual says in section 13.1:
+
+// "Two function declarations of the same name refer to the same function
+// if they are in the same scope and have identical argument types.  A
+// function member of a derived class is *not* in the same scope as a function
+// member of the same name in a base class."
+
+// g++ fails to correctly detect the error indicated.
+
+// Cfront 2.0 passes this test.
+
+// keywords: function, member, overloading, hiding
+
+struct B {
+  int f(int);
+};
+
+struct D : public B {
+  int f(struct B);		// ERROR - referred to below
+};
+
+void h(D* pd)
+{
+  pd->f(1);		// ERROR - D::f(struct B) hides B::f(int)
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900331_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900331_02.C
new file mode 100644
index 00000000000..11884db2e48
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900331_02.C
@@ -0,0 +1,27 @@
+// g++ 1.37.1 bug 900331_02
+
+// g++ fails to treat conditional expressions which yield composite type
+// (i.e. struct type, union type, or class type) lvalues as if they did
+// in fact yield lvalues in all cases.
+
+// Cfront 2.0 passes this test.
+
+// keywords: conditional operator?:, lvalues, composite types
+
+struct struct0 {
+  int data_member;
+};
+
+struct0 object0;
+struct0 object1;
+struct0 object2;
+
+int i;
+
+void function0 ()
+{
+  (i ? object0 : object1).data_member = 99;	// gets bogus error
+  (i ? object0 : object1) = object2;		// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900331_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900331_03.C
new file mode 100644
index 00000000000..a73d6856040
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900331_03.C
@@ -0,0 +1,31 @@
+// g++ 1.37.1 bug 900331_03
+
+// Special Options: -ansi
+
+// The following code causes g++ to abort.
+
+// Curiously, the abort does not occur if the -pedantic option is used.
+
+// Cfront 2.0 passes this test.
+
+// Keywords: abort, conditional operator?:, lvalues, composite types
+
+struct struct0 {
+  int data_member;
+
+  virtual void function_member () {}	// contributes to the abort
+};
+
+struct0 object0;
+struct0 object1;
+struct0 object2;
+
+int i;
+
+void function0 ()
+{
+  object2 = (i ? object0 : object1);		// OK
+  (i ? object0 : object1) = object2;		// causes abort
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900331_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900331_04.C
new file mode 100644
index 00000000000..f8a14c69390
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900331_04.C
@@ -0,0 +1,32 @@
+// g++ 1.37.1 bug 900331_04
+
+// g++ is unable to correctly parse declarations of formal parameters and
+// local objects which have pointer-to-array types or reference-to-array
+// types.
+
+// Cfront 2.0 passes this test.
+
+// keywords: syntax, arrays, pointers, references, local, formal
+
+int array[10];
+
+int (*global_array_ptr)[10] = &array;
+int (&global_array_ref)[10] = array;
+
+void function0 (int (*formal_array_ptr)[10]) {	// gets bogus errors
+}
+
+void function1 (int (&formal_array_ref)[10]) {	// gets bogus errors
+}
+
+void function2 ()
+{
+  int (*local_array_ptr)[10] = &array;		// gets bogus errors
+}
+
+void function3 ()
+{
+  int (&local_array_ref)[10] = array;		// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900401_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900401_01.C
new file mode 100644
index 00000000000..18ecd614e7a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900401_01.C
@@ -0,0 +1,15 @@
+// g++ 1.37.1 bug 900401_01
+
+// The following erroneous code causes g++ to abort.
+
+// Cfront 2.0 passes this test.
+
+// keywords: abort, bit-fields, arrays
+
+typedef unsigned nibble_array[4];
+
+struct whole {
+  nibble_array nibbles:16;	// ERROR - 
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900402_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900402_01.C
new file mode 100644
index 00000000000..4e636b5ece9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900402_01.C
@@ -0,0 +1,15 @@
+// g++ 1.37.1 bug 900402_01
+
+// The following erroneous code causes g++ to abort.
+
+// Cfront 2.0 passes this test.
+
+// keywords: abort, bit-fields, function types
+
+typedef void (func_type) ();
+
+struct s {
+  func_type f:32;	// ERROR - XFAIL *-*-*
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900402_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900402_02.C
new file mode 100644
index 00000000000..705cbf22d01
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900402_02.C
@@ -0,0 +1,21 @@
+// g++ 1.37.1 bug 900402_02
+
+// g++ fails to correctly flag all attempts to construct an array type
+// of zero length as errors.
+
+// keywords: arrays, array bound, zero length
+
+typedef int array_type[0];		// ERROR - gets warning only
+
+int array_object_1[0];			// ERROR - gets warning only
+
+void function_0 (int formal_array[0])
+{					// ERROR - gets warning only
+}
+
+void function_2 ()
+{
+  int local_object_array_0[0];		// ERROR - gets warning only
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900403_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900403_01.C
new file mode 100644
index 00000000000..608d8f92bd5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900403_01.C
@@ -0,0 +1,19 @@
+// g++ 1.37.1 bug 900403_01
+
+// g++ allows casts to be treated as lvalues (even when the -pedantic
+// option is used).  Neither the C++ Reference Manual nor cfront 2.0
+// allow this.  (gcc gives warnings for such usage with -pedantic).
+
+// Cfront 2.0 passes this test.
+
+// keywords: lvalues, casts
+
+int i, j;
+
+void f ()
+{
+  (int) i = j;		// ERROR - 
+  ((int) i) = j;	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900403_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900403_04.C
new file mode 100644
index 00000000000..c68e4c2d88f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900403_04.C
@@ -0,0 +1,12 @@
+// g++ 1.37.1 bug 900403_04
+
+// The following erroneous code causes g++ to abort.
+
+// keywords: abort, bit-fields, zero length
+
+struct s {
+  unsigned int foo:0;		// ERROR - This is the real line
+  unsigned int field;
+};
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900404_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900404_01.C
new file mode 100644
index 00000000000..f728865961f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900404_01.C
@@ -0,0 +1,15 @@
+// g++ 1.37.1 bug 900404_01
+
+// g++ allows string initializers for known-length character arrays to be
+// one character longer (counting the terminating null) than the actual
+// length of the array to be initialized.
+
+// The C++ Reference Manual (section 8.4.2) expressly prohibits this.
+
+// Cfront 2.0 passes this test.
+
+// keywords: arrays, initialization, array bounds
+
+char cv[4] = "asdf";		// ERROR - missed
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900404_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900404_02.C
new file mode 100644
index 00000000000..4099daa31e4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900404_02.C
@@ -0,0 +1,24 @@
+// g++ 1.37.1 bug 900404_02
+
+// g++ fails to treat multicharacter literals as type "int" as required by
+// section 2.5.2 of the C++ Reference Manual.
+
+// The result is that the following program will exit with a non-zero
+// exit status.
+
+// keywords: character literals, multi-character literals, int type
+
+int exit_status = 0;
+
+void function0 (int i)		// function that should be called
+{
+  i = i;
+}
+
+void function0 (char c)		// function that is actually called
+{
+  c = c;
+  exit_status++;
+}
+
+int main () { function0 ('abcd'); return exit_status; }		// WARNING - 
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900404_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900404_03.C
new file mode 100644
index 00000000000..98a33d717bb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900404_03.C
@@ -0,0 +1,27 @@
+// g++ 1.37.1 bug 900404_03
+
+// g++ fails to be able to properly flag errors for even simple cases of
+// ambiguous overload resolution (such as the one shown below).
+
+// Cfront 2.0 passes this test.
+
+// keywords: overloading, ambiguity, resolution
+
+void function0 (int i, char c)
+{				// ERROR - 
+  i = c;
+}
+
+void function0 (char c, int i)
+{				// ERROR - 
+  i = c;
+}
+
+char c;
+
+void test ()
+{
+  function0 (c,c);		// ERROR - missed
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900404_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900404_04.C
new file mode 100644
index 00000000000..b6d4830b14d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900404_04.C
@@ -0,0 +1,20 @@
+// g++ 1.37.1 bug 900404_04
+
+// The ANSI C does not allow vacuous statements (i.e. just semicolons)
+// at the file-scope level.
+
+// The current C++ Reference Manual does not indicate whether these should
+// be considered legal or not.
+
+// I am forced to conclude that C++ will follow ANSI C in this regard,
+// and that these are therefore not legal.
+
+// g++ fails to flag errors for such usage.
+
+// keywords: semicolon, vacuous, file scope, declaration
+
+int i;
+
+;			// ERROR - , XFAIL *-*-*
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900404_07.C b/gcc/testsuite/g++.old-deja/g++.bugs/900404_07.C
new file mode 100644
index 00000000000..c07a5775189
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900404_07.C
@@ -0,0 +1,17 @@
+// g++ 1.37.1 bug 900404_07
+
+// It is illegal to use a cast to attempt to convert an object type
+// to a non-scalar type (e.g. an array type).
+
+// g++ fails to properly flag as errors such illegal uses of array types.
+
+// keywords: array types, casts, type conversion
+
+typedef int array_type[10];
+
+array_type *ap;
+
+void foo ()
+{
+  int i = *((array_type) *ap);	/* ERROR - missed */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900405_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900405_01.C
new file mode 100644
index 00000000000..346db0c556d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900405_01.C
@@ -0,0 +1,19 @@
+// g++ 1.37.1 bug 900405_01
+
+// The C++ Reference Manual says (in section 5.4) "Types may not be defined
+// in casts."
+
+// g++ fails to flag errors for cases where an attempt is made to define
+// a struct, class, union, or enum type within a cast.
+
+// keywords: casts, type definitions, tagged types
+
+void f ()
+{
+  (enum e { red, green } *) 0;		// ERROR - type defined in cast
+  (struct s { int member; } *) 0;	// ERROR - type defined in cast
+  (union u { int member; } * ) 0;	// ERROR - type defined in cast
+  (class c { int member; } *) 0;	// ERROR - type defined in cast
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900406_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900406_01.C
new file mode 100644
index 00000000000..93e7af3f378
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900406_01.C
@@ -0,0 +1,19 @@
+// g++ 1.37.1 bug 900406_01
+
+// The following code causes g++ to segfault.
+
+// cfront 2.0 passes this test.
+
+// keywords: segfault, operator new, array types, array bounds
+
+void function0 ()
+{
+  new int[];		// ERROR - causes segfault
+}
+
+void function1 ()
+{
+  new int (*)[];	// ERROR - no size specified 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900406_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900406_02.C
new file mode 100644
index 00000000000..daf46a14e86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900406_02.C
@@ -0,0 +1,25 @@
+// g++ bug 900406_02
+
+// g++ fails to correctly parse some type specifications within casts.
+
+// This results in incorrect errors being issued.
+
+// These errors are not issued for identical code by either cfront or
+// by gcc.
+
+// cfront 2.0 passes this test.
+
+// keywords: syntax, array types, casts
+
+int (*ipp)[];
+int (**ippp)[];
+
+int function ()
+{
+  ipp = (int (*)[]) 0;			// OK
+  ippp = (int (**)[]) 0;		// gets bogus error (syntax)
+  return 0;
+}
+
+int main () { return 0; }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900407_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900407_01.C
new file mode 100644
index 00000000000..988642f4ad3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900407_01.C
@@ -0,0 +1,36 @@
+// g++ 1.37.1 bug 900407_01
+
+// g++ fails to flag errors for uses of anachronistic features such as the
+// invocation of a base class constructor in a ctor-initializer list without
+// explicitly giving its name.
+
+// Errors should probably be issued for such usage unless the -traditional
+// option is used.
+
+// Warnings are however issued.
+
+// Cfront 2.0 flags such usage as an error when the +p (pure-language) option
+// is used.
+
+// Cfront 2.0 passes this test.
+
+// keywords: anachronism, inheritance, initialization, mem-initializer
+
+struct s0 {
+  int member;
+
+  s0 ();
+};
+
+s0::s0() { }
+
+struct s1 : public s0 {
+  int member;
+
+  s1 ();
+};
+
+s1::s1() : () {		// ERROR - anachronism used
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900407_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900407_02.C
new file mode 100644
index 00000000000..20a323f932f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900407_02.C
@@ -0,0 +1,32 @@
+// g++ 1.37.1 bug 900407_02
+
+// g++ flags errors for attempts to assign to the "this" parameter within
+// class constructors (regardless of whether or not the -traditional)
+// option is used).
+
+// Such errors should probably not be issued when the -traditional option is
+// used.
+
+// Special g++ Options: -fthis-is-variable
+// Special CC Options:
+
+// Cfront only flags errors for such usage whin the +p (pure language)
+// option is used.
+
+// cfront 2.0 passes this test.
+
+// keywords: anachronism, this, assignment
+
+struct s0 {
+
+  int member;
+
+  s0 ();
+};
+
+s0::s0 ()
+{
+  this = this;		// OK - anachronism allowed with -traditional
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900428_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900428_01.C
new file mode 100644
index 00000000000..b46fc466529
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900428_01.C
@@ -0,0 +1,51 @@
+// g++ 1.37.1 bug 900428_01
+
+// g++ fails to issue error messages for cases where an incomplete type
+// object must be evaluated if the value of such an evaluation is not
+// actually used in the given context.
+
+// In the case where such an object is volatile, it is obvious that this
+// could be a problem, however I believe that errors should be issued
+// for such cases regardless of whether or not such values are volatile
+// because the abstract semantics seem to require the evaluation of such
+// values whether they are volatile or not.
+
+// keywords: incomplete types, evaluation, volatile qualifier
+// Build don't link: 
+
+int i;
+
+void *pv;
+volatile void *pvv;
+struct s;
+extern struct s es, *ps;
+extern volatile struct s evs, *pvs;
+
+void pv_test ()
+{
+  *pv;			// ERROR - , XFAIL *-*-*
+  (i ? *pv : *pv);	// ERROR - , XFAIL *-*-*
+  *pv, *pv;		// ERROR - , XFAIL *-*-*
+
+  *pvv;			// ERROR - , XFAIL *-*-*
+  (i ? *pvv : *pvv);	// ERROR - , XFAIL *-*-*
+  *pvv, *pvv;		// ERROR - , XFAIL *-*-*
+
+  es;			// ERROR - , XFAIL *-*-*
+  (i ? es : es);	// ERROR - , XFAIL *-*-*
+  es, es;		// ERROR - , XFAIL *-*-*
+
+  evs;			// ERROR - , XFAIL *-*-*
+  (i ? evs : evs);	// ERROR - , XFAIL *-*-*
+  evs, evs;		// ERROR - , XFAIL *-*-*
+
+  *ps;			// ERROR - , XFAIL *-*-*
+  (i ? *ps : *ps);	// ERROR - , XFAIL *-*-*
+  *ps, *ps;		// ERROR - , XFAIL *-*-*
+
+  *pvs;			// ERROR - , XFAIL *-*-*
+  (i ? *pvs : *pvs);	// ERROR - , XFAIL *-*-*
+  *pvs, *pvs;		// ERROR - , XFAIL *-*-*
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900428_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900428_02.C
new file mode 100644
index 00000000000..9da709fdc81
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900428_02.C
@@ -0,0 +1,27 @@
+// g++ 1.37.1 bug 900428_02
+
+// g++ fails to issue either errors or warnings (even with -pedantic) for
+// attempts to perform either pre or post increment or decrement operations
+// on variables which have either pointer-to-void types or pointer-to-function
+// types.
+
+// cfront 2.0 passes this test.
+
+// keywords: pointer arithmetic, increment, decrement
+// Build don't link:
+
+void *vp;
+void (*fp) ();
+
+void test ()
+{
+  vp++;		/* ERROR - */
+  ++vp;		/* ERROR - */
+  vp--;		/* ERROR - */
+  --vp;		/* ERROR - */
+
+  fp++;		/* ERROR - */
+  ++fp;		/* ERROR - */
+  fp--;		/* ERROR - */
+  --fp;		/* ERROR - */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900428_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900428_03.C
new file mode 100644
index 00000000000..74e55860d29
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900428_03.C
@@ -0,0 +1,44 @@
+// g++ 1.37.1 bug 900428_03
+
+// g++ fails to detect cases where a constructor for a derived class invokes
+// (either explicitly or implicitly) a private constructor for a base class.
+
+// cfront 2.0 passes this test.
+
+// keywords: inheritance, private, accessability, constructors
+
+struct struct_0 {
+  int struct_0_data_member;
+
+private:
+  struct_0 (int, int);
+public:
+  struct_0 (int);
+};
+
+struct_0::struct_0 (int i) { }
+struct_0::struct_0 (int, int) { } // ERROR - xref from below
+
+struct struct_1 : public struct_0 {
+
+  struct_1 ();
+};
+
+struct_1::struct_1 () : struct_0 (8,9)
+{				// ERROR - 
+}
+
+struct struct_2 {
+  struct_0 struct_2_data_member;
+
+  struct_2 ();
+};
+
+// g++ catches the following error (but does so only at the line with the 
+// closing curly brace).
+
+struct_2::struct_2 () : struct_2_data_member (8,9)
+{				// ERROR - should be up one line
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900511_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900511_01.C
new file mode 100644
index 00000000000..e4488d9bad1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900511_01.C
@@ -0,0 +1,42 @@
+// g++ 1.37.1 bug 900511_01
+
+// g++ fails to properly apply user-defined type conversion operators
+// in cases where is it not obvious that the given conversion is
+// appropriate for the context (i.e. operator and other operands)
+// where the conversion should take place.
+
+// cfront 2.0 passes this test.
+
+struct struct_1 {
+  int member;
+
+  operator int ();
+};
+
+struct_1::operator int ()
+{
+  return 0;
+}
+
+struct struct_2 {
+  int member;
+
+  operator float ();
+};
+
+struct_2::operator float ()
+{
+  return 0.0;
+}
+
+struct_1 struct_1_object;
+struct_2 struct_2_object;
+double d;
+
+void test ()
+{
+  d = struct_2_object + struct_1_object;	// OK
+  d = struct_1_object + struct_2_object;	// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900511_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900511_02.C
new file mode 100644
index 00000000000..0154bfe4140
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900511_02.C
@@ -0,0 +1,21 @@
+// g++ 1.37.1 bug 900511_02
+
+// g++ does not properly shadow names of types with names of data members
+// in cases where the type names in question are used in the context of
+// formal parameters lists for member functions.
+
+// keywords: typedef names, shadowing, scope, formal parameter list
+
+// cfront 2.0 passes this test.
+
+enum enum0 { enum0_value_0 };	// ERROR - 
+
+struct struct0 {
+  int enum0;			// ERROR - 
+  void member_function (enum0 e);
+};
+
+void class0::member_function (enum0 e) {	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900511_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900511_03.C
new file mode 100644
index 00000000000..d8a549aa82c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900511_03.C
@@ -0,0 +1,19 @@
+// g++ 1.37.1 bug 900511_03
+
+// g++ does not properly shadow names of types with names of data members
+// in cases where the type names in question are used in the context of
+// formal parameters lists for member functions.
+
+// keywords: typedef names, shadowing, scope, formal parameter list
+
+class class0;				// ERROR - 
+
+struct struct1 {
+  int class0;			// ERROR - 
+  void member_function (class0 *);
+};
+
+void class1::member_function (class0 *p) {	// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900514_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900514_03.C
new file mode 100644
index 00000000000..7274bb72990
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900514_03.C
@@ -0,0 +1,115 @@
+// g++ 1.37.1 bug 900514_03
+
+// g++ fails to flag ERRORs on the following erroneous code.
+
+// In Section 12.3.2 it says "Defining conversion by both a constructor and
+// a conversion function can lead to ambiguities."  However in the case below,
+// the explicit cast syntax disambiguates the constructor as one which
+// invokes the type conversion operator rather than the conversion.
+
+// cfront 2.0 passes this test.
+
+// keywords: user-defined type conversion operator, constructor
+
+struct t_0_st_0;
+
+struct t_0_st_1 {
+  int member;
+
+  t_0_st_1 (t_0_st_0&);// ERROR - 
+  t_0_st_1 ();
+};// ERROR - 
+
+struct t_0_st_0 {
+  int member;
+
+  operator t_0_st_1 ();// ERROR - 
+};
+
+t_0_st_0 t_0_st_0_obj0;
+
+void t_0_assignment ()
+{
+  t_0_st_1 t_0_st_1_obj0;
+  t_0_st_1 t_0_st_1_obj1;
+  t_0_st_1 t_0_st_1_obj2;
+
+  t_0_st_1_obj0 = t_0_st_0_obj0;			// ERROR - caught
+  t_0_st_1_obj1 = t_0_st_1 (t_0_st_0_obj0);
+}
+
+void t_0_local_init ()
+{
+  t_0_st_1 t_0_st_1_obj0 = t_0_st_0_obj0;		// ERROR - 
+  t_0_st_1 t_0_st_1_obj1 = t_0_st_1 (t_0_st_0_obj0);
+}
+
+struct t_1_st_0;
+
+struct t_1_st_1 {
+  int member;
+
+  t_1_st_1 (t_1_st_0&);					// ERROR - 
+  t_1_st_1 ();
+  void operator= (t_1_st_1&);				// ERROR - 
+};
+
+struct t_1_st_0 {
+  int member;
+
+  operator t_1_st_1 ();					// ERROR - 
+};
+
+t_1_st_0 t_1_st_0_obj0;
+
+void t_1_assignment ()
+{
+  t_1_st_1 t_1_st_1_obj0;
+  t_1_st_1 t_1_st_1_obj1;
+  t_1_st_1 t_1_st_1_obj2;
+
+  t_1_st_1_obj0 = t_1_st_0_obj0;			// ERROR - 
+  t_1_st_1_obj1 = t_1_st_1 (t_1_st_0_obj0);		// ERROR - 
+}
+
+void t_1_local_init ()
+{
+  t_1_st_1 t_1_st_1_obj0 = t_1_st_0_obj0;		// ERROR - 
+  t_1_st_1 t_1_st_1_obj1 = t_1_st_1 (t_1_st_0_obj0);
+}
+
+// These are not ambiguous because the binding of the this parm for the conv
+// is better than the arg binding for the ctor.
+
+struct t_2_st_0;
+
+struct t_2_st_1 {
+  int member;
+
+  t_2_st_1 (t_2_st_0);
+  t_2_st_1 ();
+};
+
+struct t_2_st_0 {
+  int member;
+
+  operator t_2_st_1 ();
+};
+
+t_2_st_0 t_2_st_0_obj0;
+
+void t_2_assignment ()
+{
+  t_2_st_1 t_2_st_1_obj0;
+  t_2_st_1 t_2_st_1_obj1;
+  t_2_st_1 t_2_st_1_obj2;
+
+  t_2_st_1_obj0 = t_2_st_0_obj0;
+  t_2_st_1_obj1 = t_2_st_1 (t_2_st_0_obj0);
+}
+
+void t_2_local_init ()
+{
+  t_2_st_1 t_2_st_1_obj0 = t_2_st_0_obj0; 
+  t_2_st_1 t_2_st_1_obj1 = t_2_st_1 (t_2_st_0_obj0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_01.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_01.C
new file mode 100644
index 00000000000..9641d1d615c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_01.C
@@ -0,0 +1,16 @@
+// g++ 1.37.1 bug 900519_01
+
+// g++ fails to flag errors for some attempts to declare or define non-member
+// type conversion operators.
+
+// cfront 2.0 passes this test.
+
+// keywords: user-defined type conversion operator, non-member
+
+extern operator int ();		// ERROR - 
+
+extern operator int () {	// ERROR - 
+  return 0;
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_02.C
new file mode 100644
index 00000000000..90dc16a42ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_02.C
@@ -0,0 +1,32 @@
+// g++ 1.37.1 bug 900519_02
+
+// The C++ Reference Manual says (in section 8.4.3) "A reference to a plain
+// T can only be initialized with a plain T" however g++ allows the
+// initialization of plain references with qualified objects in many cases.
+
+// keywords: references, initialization, type qualifiers
+
+extern const int cint_obj = 9;
+volatile int vint_obj = 9;
+
+void take_int_ref (int& arg) { } // ERROR - referenced by errors below
+
+int& global_int_ref0 = cint_obj;		// ERROR - 
+int& global_int_ref1 = vint_obj;		// ERROR - 
+
+extern const int& cint_ref;
+extern volatile int& vint_ref;
+
+void test_0 ()
+{
+  int& local_int_ref0 = cint_obj;		// ERROR - 
+  int& local_int_ref1 = vint_obj;		// ERROR - 
+
+  take_int_ref (cint_obj);			// ERROR - caught
+  take_int_ref (vint_obj);			// ERROR - 
+
+  take_int_ref (cint_ref);			// ERROR - 
+  take_int_ref (vint_ref);			// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_03.C
new file mode 100644
index 00000000000..114d90960bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_03.C
@@ -0,0 +1,47 @@
+// g++ 1.37.1 bug 900519_03
+
+// The C++ Reference Manual says (in section 8.4.3) "A reference to a 
+// volatile T can be initialized with a volatile T or a plain T but not a
+// const T.  A reference to a const T can be initialized with a const T or
+// a plain T or something that can be converted into a plain T, but not a
+// volatile T."
+
+// g++ fails to disgnose such errors in most cases.
+
+// keywords: references, initialization, type qualifiers
+
+extern const int cint_obj;
+extern volatile int vint_obj;
+
+void take_cint_ref (const int& arg) { }	// ERROR - 
+void take_vint_ref (volatile int& arg) { } // ERROR - 
+
+const int& global_cint_ref2 = vint_obj;		// ERROR - 
+
+volatile int& global_vint_ref1 = cint_obj;	// ERROR - 
+
+extern const int& extern_cint_ref;
+extern volatile int& extern_vint_ref;
+
+void test_0 ()
+{
+  const int& local_cint_ref2 = vint_obj;	// ERROR - 
+
+  volatile int& local_vint_ref1 = cint_obj;	// ERROR - 
+} 
+
+void test_1 ()
+{
+  take_cint_ref (vint_obj);			// ERROR - 
+
+  take_vint_ref (cint_obj);			// ERROR - caught
+}
+
+void test_2 ()
+{
+  take_cint_ref (extern_vint_ref);		// ERROR - 
+
+  take_vint_ref (extern_cint_ref);		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_04.C
new file mode 100644
index 00000000000..53867a1b2b0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_04.C
@@ -0,0 +1,21 @@
+// g++ 1.37.1 bug 900519_04
+
+// The following legal code causes g++ to segfault.
+
+// cfront 2.0 passes this test.
+
+// keywords: segfault, references, initialization
+
+int cint_obj = 9;
+
+void take_cint_ref (int& arg) { }
+
+int& cint_ref_0 = cint_obj;
+int& cint_ref_1 = cint_obj;
+
+void test_0 ()
+{
+  take_cint_ref (cint_ref_1);	// causes segfault
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_05.C
new file mode 100644
index 00000000000..05d2ea03d3d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_05.C
@@ -0,0 +1,18 @@
+// g++ 1.37.1 bug 900519_05
+
+// g++ fails to allow the use of function-reference types.
+
+// cfront 2.0 passes this test.
+
+// keywords: function types, reference types
+
+typedef void (func_type) (int, int);
+typedef func_type& func_ref_type;		// gets bogus error, XFAIL *-*-*
+
+void function (int arg1, int arg2)
+{
+}
+
+func_type& global_func_ref1 = function;		// gets bogus error, XFAIL *-*-*
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_06.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_06.C
new file mode 100644
index 00000000000..5704c3f9520
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_06.C
@@ -0,0 +1,22 @@
+// g++ 1.37.1 bug 900519_06
+
+// g++ allows the type given in an invocation of operator new to be a
+// reference type.
+
+// Since pointers to reference types are illegal, the required return type
+// from such an invocation (of operator new) is illegal, and thus (it seems)
+// the entire call to new should be treated as being illegal.
+
+typedef int& int_ref;
+
+void test (int n)
+{
+  new int&;		// ERROR - missed
+  new int_ref;		// ERROR - missed
+  new int&[n];		// ERROR - missed
+  new int_ref[n];	// ERROR - missed
+  new int&[3];		// ERROR - missed
+  new int_ref[3];	// ERROR - missed
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_07.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_07.C
new file mode 100644
index 00000000000..f5ea6bcb8d8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_07.C
@@ -0,0 +1,16 @@
+// g++ 1.37.1 bug 900519_07
+
+// It is illegal to specify or to use array-of-reference types, yet g++
+// allows them to be specified (in typedef statements and in declarations)
+// and to be used (in declarations).
+
+// keywords: reference types, array types
+
+int i;
+int j;
+
+typedef int& int_ref;
+typedef int_ref int_ref_array_type[2];		// ERROR - missed
+
+int& int_ref_array_obj0[2] = { i, j };		// ERROR - missed
+int_ref int_ref_array_obj1[2] = { i, j };	// ERROR - missed
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_08.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_08.C
new file mode 100644
index 00000000000..ed99ae62ad1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_08.C
@@ -0,0 +1,15 @@
+// g++ 1.37.1 bug 900519_08
+
+// g++ fails to accept the following legal syntax for an invocation of the
+// new operator, in which the type specifier is implicitly "int".
+
+// cfront 2.0 passes this test.
+
+// keywords: syntax, operator new, type specifier, type qualifier
+
+void test ()
+{
+   new const /* int */ (1);				// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_09.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_09.C
new file mode 100644
index 00000000000..3bff70eed74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_09.C
@@ -0,0 +1,29 @@
+// g++ 1.37.1 bug 900519_09
+
+// g++ allows the allocation of const objects via operator new even when
+// these uses of operator new do not include initializations.
+
+// This is inconsistant within the restrictions placed on the construction
+// of class, struct, and union types which have constant members.
+
+// Since there is no completely valid way of initializing such objects
+// after the invocation of new, these cases should all be illegal.
+
+// keywords: operator new, initialization, const qualifier
+
+struct struct_0 {
+  int member;
+};
+
+typedef const int const_int;
+typedef const struct struct_0 const_struct_0;
+
+void test ()
+{
+  new const int;		// ERROR - 
+  new const_int;		// ERROR - 
+  new const struct_0;		// ERROR - 
+  new const_struct_0;		// ERROR - 
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_12.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_12.C
new file mode 100644
index 00000000000..112b989b805
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_12.C
@@ -0,0 +1,11 @@
+// g++ 1.37.1 bug 900519_12
+
+// The following erroneous code causes g++ to segfault.
+
+// cfront 2.0 passes this test.
+
+// keywords: segfault, typedef, pointer type, function type
+
+typedef eek void (*)();		// ERROR - 
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900519_13.C b/gcc/testsuite/g++.old-deja/g++.bugs/900519_13.C
new file mode 100644
index 00000000000..8161b59b801
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900519_13.C
@@ -0,0 +1,35 @@
+// g++ 1.37.1 bug 900519_13
+
+// If multiple inheritance creates a situation in which a given name is
+// inherited from more than one base class, and if the inherited declarations
+// for the name are for different categories of members (e.g. object members,
+// function members, enumeral members), then g++ will (in some cases) fail
+// to flag errors when the ambiguous name is used.
+
+// cfront 2.0 passes this test.
+
+// keywords: inheritance, ambiguity resolution, members
+
+struct base_0 {
+  enum { base_member };
+};
+
+struct base_1 {
+  int base_member;
+};
+
+struct base_2 {
+  int base_member ();
+};
+
+struct derived_0 : public base_0, public base_1 {
+  void member () { base_member; }			// ERROR - 
+};
+
+struct derived_1 : public base_0, public base_2 {
+  void member () { base_member; }			// ERROR - missed
+};
+
+struct derived_2 : public base_1, public base_2 {
+  void member () { base_member; }			// ERROR - missed
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900520_02.C b/gcc/testsuite/g++.old-deja/g++.bugs/900520_02.C
new file mode 100644
index 00000000000..05c880d2e3c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900520_02.C
@@ -0,0 +1,34 @@
+// g++ 1.37.1 bug 900520_02
+
+// g++ fails to allow a reference to an unbounded array type to be passed
+// into a formal parameter whose type is pointer-to-bounded-array type.
+
+// Cases other than parameter passing in which similar initializations
+// take place are allowed however.
+
+// cfront 2.0 passes this test.
+
+// keywords: reference types, initialization, parameter passing
+
+typedef int b_array[3];
+typedef int u_array[];
+
+typedef b_array &b_array_ref;
+typedef u_array &u_array_ref;
+
+void take_b_array_ref (b_array_ref arg) { }
+
+extern u_array u_array_gbl_obj;
+
+u_array_ref u_array_ref_gbl_obj0 = u_array_gbl_obj;
+
+b_array_ref b_array_ref_gbl_obj0 = u_array_ref_gbl_obj0;	// OK
+
+void test_passing ()
+{
+  take_b_array_ref (u_array_ref_gbl_obj0);	// gets bogus error
+}
+
+b_array u_array_gbl_obj;
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900520_03.C b/gcc/testsuite/g++.old-deja/g++.bugs/900520_03.C
new file mode 100644
index 00000000000..b1f05c95b14
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900520_03.C
@@ -0,0 +1,49 @@
+// g++ 1.37.1 bug 900520_03
+
+// The C++ Reference Manual says (in section 8.2.4):
+
+//	When an identifier of array type appears in an expression, except
+//	as the operand of sizeof or & or used to initialize a reference,
+//	it is converted into a pointer to the first member of the array.
+
+// One must assume from the verbage, that when the name of a non-const array
+// object appears in one of the exempted contexts mentioned in this passage,
+// that it is *not* automatically converted into a pointer value, but rather
+// that it remains as an array type value, and that it may therefore also
+// still be an lvalue, and may be used to initialize references.
+
+// As the following code demonstrates, g++ does in fact treat the names
+// of non-const array objects as valid initializers for reference-to-array
+// type object in some (but not all) contexts.
+
+// The exception is that g++ does not allow names which designate objects
+// on incomplete array types to be used as actual parameters in function
+// calls where the corresponding formal parameter is of a reference-to-array
+// type.
+
+// g++ does however allow other similar sorts of initializations of non-formal
+// reference objects.
+
+// 5/16/94 (jason): The 1/25/94 WP explicitly states in section 8.3.5 that
+// parameter types may not contain pointers or references to arrays of unknown
+// bound.  g++ is correct.
+
+// keywords: reference types, array types, initialization, parameter passing
+
+typedef int u_array[];
+typedef u_array &u_array_ref;
+
+void take_u_array_ref (u_array_ref arg) { } // ERROR - reference to array of unknown bound in parmtype
+
+extern u_array u_array_gbl_obj;
+u_array_ref u_array_ref_gbl_obj0 = u_array_gbl_obj;	// OK
+
+void test_local_initialization ()
+{
+  u_array_ref u_array_ref_lcl_obj0 = u_array_gbl_obj;	// OK
+}
+
+void test_passing ()
+{
+  take_u_array_ref (u_array_gbl_obj);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900520_04.C b/gcc/testsuite/g++.old-deja/g++.bugs/900520_04.C
new file mode 100644
index 00000000000..d9488cf9b53
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900520_04.C
@@ -0,0 +1,40 @@
+// g++ 1.37.1 bug 900520_04
+
+// g++ does not yet support the initialization of scalar type objects
+// (including built-in arithmetic types, enum types, and pointer types)
+// via constructor initialization syntax except within a call to operator
+// new.
+
+// keywords: unimplemented, syntax, initialization, scalar types
+
+enum e_type { e_value };
+
+typedef char *charp;
+
+charp cp;
+
+int global_i (1);				// gets bogus error
+double global_d (9.9);				// gets bogus error
+charp global_cp0 (cp);				// gets bogus error
+charp global_cp1 (0);				// gets bogus error
+enum e_type global_e (e_value);			// gets bogus error
+
+void func0 ()
+{
+  int local_i (1);				// gets bogus error
+  double local_d (9.9);				// gets bogus error
+  charp local_cp0 (cp);				// gets bogus error
+  charp local_cp1 (0);				// gets bogus error
+  enum e_type local_e (e_value);		// gets bogus error
+}
+
+void func1 ()
+{
+  int* ip = new int (1);			// gets bogus error
+  double* dp = new double (9.9);		// gets bogus error
+  charp* cpp0 = new charp (cp);			// gets bogus error
+  charp* cpp1 = new charp (0);			// gets bogus error
+  enum e_type* ep = new e_type (e_value);	// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900520_05.C b/gcc/testsuite/g++.old-deja/g++.bugs/900520_05.C
new file mode 100644
index 00000000000..5ddc9fda507
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900520_05.C
@@ -0,0 +1,23 @@
+// g++ 1.37.1 bug 900520_05
+
+// The following legal code gets syntax errors from g++.
+
+// keywords: syntax, unimplemented, operator new, initialization, pointer types
+
+struct struct_0 {
+};
+
+char *cp;
+struct_0 *sp;
+
+void test0 ()
+{
+  new char * (cp);		// gets bogus error
+}
+
+void test1 ()
+{
+  new struct_0 * (sp);		// gets bogus error
+}
+
+int main () { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.bugs/900520_06.C b/gcc/testsuite/g++.old-deja/g++.bugs/900520_06.C
new file mode 100644
index 00000000000..aa4ec9a320e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.bugs/900520_06.C
@@ -0,0 +1,78 @@
+// g++ 1.37.1 bug 900520_06
+
+// When an object of a class type is passed into a formal parameter of the
+// same class type (in a function call) the language definition calls for
+// this action to be treated like any other form of an initialization of
+// an object of the given class type.
+
+// g++ fails however to invoke the (compiler-supplied) copy constructor for
+// the class type when a parameter of the class type is passed as an
+// actual parameter.
+
+// This causes the following program to exit with a non-zero exit status.
+
+// cfront 2.0 passes this test.
+
+int base_copy_ctor_called = 0;
+int member_copy_ctor_called = 0;
+
+struct struct_0 {
+  struct_0 ();
+  struct_0 (const struct_0&);
+};
+
+struct_0::struct_0 ()
+{
+}
+
+struct_0::struct_0 (const struct_0&)
+{
+  base_copy_ctor_called++;
+}
+
+struct struct_1 {
+  struct_1 ();
+  struct_1 (const struct_1&);
+};
+
+struct_1::struct_1 ()
+{
+}
+
+struct_1::struct_1 (const struct_1&)
+{
+  member_copy_ctor_called++;
+}
+
+struct struct_2 : public struct_0 {
+  struct_2 ();
+  struct_1 struct_1_member;
+#ifdef MAKE_COPY_CONSTRUCTOR_EXPLICIT
+  struct_2 (const struct_2&);
+#endif
+};
+
+struct_2::struct_2 ()
+{
+}
+
+#ifdef MAKE_COPY_CONSTRUCTOR_EXPLICIT
+struct_2::struct_2 (const struct_2& arg) :
+  struct_0 ((struct_0&)arg),
+  struct_1_member (arg.struct_1_member)
+{
+}
+#endif
+
+void take_struct_2 (struct_2 arg)
+{
+}
+
+int test ()
+{
+  struct_2 struct_2_object0;
+  take_struct_2 (struct_2_object0);
+  return (base_copy_ctor_called != 1 || member_copy_ctor_called != 1);
+}
+
+int main () { return test (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/array1.C b/gcc/testsuite/g++.old-deja/g++.ext/array1.C
new file mode 100644
index 00000000000..808eb534403
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/array1.C
@@ -0,0 +1,22 @@
+// Testcase for assignment of non-array to array (assigns the same value to
+// each member)
+// Build don't link:
+// Special Options: 
+
+typedef struct {} ct2d_rigid, ct2d_rigid_a[1];
+class ccInspection
+{
+protected:
+  ct2d_rigid_a _dev2phys;	 
+};
+class ccBgaInspection : public ccInspection
+{
+public:
+  int reinspect (unsigned long diagFlags);
+};
+int
+ccBgaInspection::reinspect (unsigned long diag_flags) 
+{
+  ct2d_rigid physTdev;		 
+  _dev2phys = physTdev; // ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/array2.C b/gcc/testsuite/g++.old-deja/g++.ext/array2.C
new file mode 100644
index 00000000000..13679af63b2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/array2.C
@@ -0,0 +1,13 @@
+// This testcase used to cause a crash on the Alpha.
+// Special g++ Options: 
+// Build don't link:
+
+struct A {
+  int i;
+  ~A() { }
+};
+
+A f (int n)
+{
+  A a[n];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/arrnew.C b/gcc/testsuite/g++.old-deja/g++.ext/arrnew.C
new file mode 100644
index 00000000000..ef051d265a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/arrnew.C
@@ -0,0 +1,5 @@
+// PRMS Id: 4992
+// Build don't link:
+// Special g++ Options:
+
+	int *f(){ return new int[1] = { 1 };   }
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/constructor.C b/gcc/testsuite/g++.old-deja/g++.ext/constructor.C
new file mode 100644
index 00000000000..cdf9f1da98b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/constructor.C
@@ -0,0 +1,19 @@
+// Testcase for constructor expressions (GNU extension)
+// Special g++ Options:
+
+struct Any {
+    int *type;
+    int *addr;
+};
+
+int i, j;
+
+main () {
+  struct Any *ap = (struct Any *)
+    __builtin_alloca (sizeof(struct Any));
+  *ap = ((struct Any){ &i, &j }) ;
+
+  if (ap->type != &i || ap->addr != &j)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/default.C b/gcc/testsuite/g++.old-deja/g++.ext/default.C
new file mode 100644
index 00000000000..24f336e5882
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/default.C
@@ -0,0 +1,26 @@
+// PRMS Id: 5353
+// This may be an extension, but it's a very common one...
+
+extern "C" int printf (const char *, ...);
+
+class A {
+public:
+  static A*func (int = 3);
+  static A*(*ptr)(int = 4);
+};
+
+A*(*A::ptr)(int) = &A::func;
+
+main()
+{
+  A foo;
+
+  A::ptr();
+  A::ptr(47);
+}
+
+A*A::func(int i)
+{
+  printf("I = %d\n",i);
+  return (A*)0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/memconst.C b/gcc/testsuite/g++.old-deja/g++.ext/memconst.C
new file mode 100644
index 00000000000..5b42d8ff905
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/memconst.C
@@ -0,0 +1,24 @@
+// From: Ove.Ewerlid@syscon.uu.se (Ove Ewerlid)
+// Subject: ss-940630:cc1plus: internal error
+// Date: Sat, 2 Jul 1994 05:07:20 +0200
+// Special g++ Options:
+// Build don't link:
+
+class qwerty {
+public:
+    qwerty (const unsigned short userkey[8]);
+   ~qwerty ();
+};
+
+class foo {
+private:
+    const unsigned char * const dummy_key = (unsigned char*)"ThisIs a dummy!";
+public:
+    void bar ();
+};
+
+void
+foo::bar ()
+{
+    qwerty QWERTY ((unsigned short*)dummy_key);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/null1.C b/gcc/testsuite/g++.old-deja/g++.ext/null1.C
new file mode 100644
index 00000000000..6650cbedde8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/null1.C
@@ -0,0 +1,8 @@
+// Test for overloading with g++ NULL.
+
+void f (int *) { }
+void f (char, char);
+main ()
+{
+  f (__null);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.ext/pretty.C b/gcc/testsuite/g++.old-deja/g++.ext/pretty.C
new file mode 100644
index 00000000000..d7951324c62
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.ext/pretty.C
@@ -0,0 +1,43 @@
+// Test for PRETTY_FUNCTION
+// Build don't link:
+
+class SV;
+
+class SVTable // : public Debug
+{
+  // It is an array to pointer to a SV.
+  SV ** array;
+
+  // This is the size of array.
+  int maxCount; 
+
+  // This is the current element count.
+  int count;
+
+  void fatal_error (const char *f, ...);
+
+public:
+  SVTable (int size, const char *d);
+  SVTable ();
+  SVTable (const SVTable &);
+  ~SVTable () {}
+
+};
+
+
+SVTable::SVTable (int size, const char *d)
+	: maxCount (size), count (0)// , Debug (d)
+{
+  if (size < 0)
+  {
+    fatal_error (__PRETTY_FUNCTION__ ": Invalid size: %d\n", size);
+  }
+
+  array = (SV **) new SV * [size];
+
+  if (array == 0)
+  {
+    fatal_error (__PRETTY_FUNCTION__
+	": Failed to allocate array\n");
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/README b/gcc/testsuite/g++.old-deja/g++.gb/README
new file mode 100644
index 00000000000..db118908b26
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/README
@@ -0,0 +1,20 @@
+These are my C++ signature and class-scoping tests.
+
+In changing my signature tests to DejaGnu style, I reduced the number
+of tests from 40 to 25.  They should still test the same features,
+though.  All of these tests are run.  I don't have any tests yet to
+check correct reporting of errors/warnings.
+
+The class scoping tests were in part derived from Vince Russo's
+Renaissance operating system and in part written by myself in helping
+Niklas Hallqvist test his rewrite of the scoping code.  I had shared
+some of these tests with Niklas, others were included in bug reports I
+had sent to {g++,gcc}@cygnus.com.  It is, therefore, possible that
+these tests duplicate tests in other directories.
+
+All files in this directory, including this file, are Copyright FSF 1995
+and fall under the GPL version 2.0 or later.
+
+Gerald Baumgartner
+gb@cs.purdue.edu
+March 1, 1995
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope01.C b/gcc/testsuite/g++.old-deja/g++.gb/scope01.C
new file mode 100644
index 00000000000..e22dd394979
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope01.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct c { typedef int t; };
+struct d { typedef char t; };
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope02.C b/gcc/testsuite/g++.old-deja/g++.gb/scope02.C
new file mode 100644
index 00000000000..678b73e2251
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope02.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct c {
+  typedef int t;
+  struct d {
+    void foo (t &);
+  };
+};
+
+void c::d::foo (t & x) { }
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope03.C b/gcc/testsuite/g++.old-deja/g++.gb/scope03.C
new file mode 100644
index 00000000000..09fe16aed86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope03.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct c {
+  class t { };
+  struct d {
+    void foo (t &);
+  };
+};
+
+void c::d::foo (t & x) { }
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope04.C b/gcc/testsuite/g++.old-deja/g++.gb/scope04.C
new file mode 100644
index 00000000000..f63775bdb49
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope04.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct a {
+  struct c {
+    struct d {
+      static int foo (int);
+    };
+  };
+
+  struct b {
+    int foo (int x) { return c::d::foo (x); }
+  };
+};
+
+int a::c::d::foo (int) { return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope05.C b/gcc/testsuite/g++.old-deja/g++.gb/scope05.C
new file mode 100644
index 00000000000..60f0b02a58d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope05.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct C {
+  void foo (int);
+  void foo (char);
+
+  struct D {
+    void foo ();
+  };
+};
+
+void C::D::foo () { }
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope06.C b/gcc/testsuite/g++.old-deja/g++.gb/scope06.C
new file mode 100644
index 00000000000..46c9d07b5da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope06.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct C {
+  struct D {
+    int x;
+    void foo ();
+  };
+      const int Ok = 0; // ERROR - initialization forbidden
+};
+
+void C::D::foo ()
+{
+  x = Ok;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope07.C b/gcc/testsuite/g++.old-deja/g++.gb/scope07.C
new file mode 100644
index 00000000000..051bbb5fb50
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope07.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed gb scope
+struct D {
+  friend class A;
+  friend class B;
+  friend class C;
+
+  void foo ();
+};
+
+void D::foo () { }
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope08.C b/gcc/testsuite/g++.old-deja/g++.gb/scope08.C
new file mode 100644
index 00000000000..2451965f053
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope08.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed gb scope
+template <class X> class C {
+public:
+  int f (X ob) { return 0; }
+  int g (X ob) { return f (ob); }
+};
+
+class D {
+public:
+  class E { public: E (); };
+
+  C <E> x;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope09.C b/gcc/testsuite/g++.old-deja/g++.gb/scope09.C
new file mode 100644
index 00000000000..cc17afc9fe2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope09.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed gb scope
+class enclose {
+  int e;
+protected:
+  class nested {
+    int n;
+  };
+};
+
+class derived : public enclose {
+protected:
+  class nested_derived : public nested {
+    int nd;
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope10.C b/gcc/testsuite/g++.old-deja/g++.gb/scope10.C
new file mode 100644
index 00000000000..32caa6084a1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope10.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed gb scope
+void Foo (void)
+{
+  class C {
+  public:
+    virtual int foo (void) { return 0; };
+  };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope11.C b/gcc/testsuite/g++.old-deja/g++.gb/scope11.C
new file mode 100644
index 00000000000..19229df9f25
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope11.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed gb scope
+template<class T, int N> class fixed_array {
+public:
+  T _array[N];
+};
+
+class Hash {
+public:
+  Hash (int);
+};
+
+typedef fixed_array<char, 4> ipAddress_t;
+
+class IPAddress {
+protected:
+  long _i;
+public:
+  IPAddress (ipAddress_t ip) { }
+  IPAddress () { }
+  IPAddress netMask () { return *this; }
+  operator Hash ();
+};
+
+IPAddress::operator Hash ()
+{
+  return Hash (_i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope12.C b/gcc/testsuite/g++.old-deja/g++.gb/scope12.C
new file mode 100644
index 00000000000..52916b955b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope12.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed gb scope
+template<class T, int N> class FixedArray_t {
+public:
+  T _array[N];
+
+  FixedArray_t () { }
+};
+
+typedef FixedArray_t<unsigned char, 4> IPAddress_t;
+
+class IPAddress {
+public:
+  IPAddress (IPAddress_t ip) { }
+
+  operator IPAddress_t ()
+  {
+    IPAddress_t rv;
+    return rv;
+  }
+
+  IPAddress () { }
+};
+
+class DatagramHeader {
+public:
+  IPAddress _src;
+
+  void setHeader (IPAddress);
+};
+
+void
+DatagramHeader::setHeader (IPAddress)
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/scope13.C b/gcc/testsuite/g++.old-deja/g++.gb/scope13.C
new file mode 100644
index 00000000000..9ca5ba8ac25
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/scope13.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed gb scope
+class X {
+public:
+};
+
+class Y {
+public:
+  void X();
+  ::X X(int);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig01.C b/gcc/testsuite/g++.old-deja/g++.gb/sig01.C
new file mode 100644
index 00000000000..a3e927743f3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig01.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment
+// Test assignment to local signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C a;
+  S * p;
+
+  p = &a;
+
+  printf ("%s%s\n", p->f (), p->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig02.C b/gcc/testsuite/g++.old-deja/g++.gb/sig02.C
new file mode 100644
index 00000000000..f739a282c1b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig02.C
@@ -0,0 +1,45 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment
+// Test assigning objects of different classes to local signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+};
+
+class D
+{
+public:
+  char * f (void) { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+};
+
+int main (void)
+{
+  C a;
+  D b;
+  S * p;
+  int i;
+
+  for (i = 0; i < 2; i++)
+    {
+      if (i == 0)
+	p = &a;
+      else
+	p = &b;
+      printf ("%s", p->f ());
+    }
+  printf ("\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig03.C b/gcc/testsuite/g++.old-deja/g++.gb/sig03.C
new file mode 100644
index 00000000000..d791c7edbef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig03.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr overloading
+// Test overloading of signature member functions.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * f (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * f (int);
+};
+
+int main (void)
+{
+  C a;
+  S * p;
+
+  p = &a;
+
+  printf ("%s%s\n", p->f (), p->f (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig04.C b/gcc/testsuite/g++.old-deja/g++.gb/sig04.C
new file mode 100644
index 00000000000..af549591591
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig04.C
@@ -0,0 +1,46 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr this
+// Test passing of 'this' pointer through signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C;
+int inc_mod_4 (C *);
+
+class C
+{
+public:
+  char * text[4];
+  int    i;
+  int    get_i (void) { return i; }
+  char * msg   (void) { i = inc_mod_4 (this);  return text[i]; }
+};
+
+signature S
+{
+  char * msg (void);
+};
+
+int inc_mod_4 (C * p)
+{
+  return (p->get_i () + 1) % 4;
+}
+
+int main (void)
+{
+  C o = { "P", "A", "S", "S", -1 };
+  S * p;
+  int i;
+
+  p = &o;
+
+  for (i = 0; i < 4; i++)
+    printf ("%s", p->msg ());
+
+  printf ("\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig05.C b/gcc/testsuite/g++.old-deja/g++.gb/sig05.C
new file mode 100644
index 00000000000..3023e348dfb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig05.C
@@ -0,0 +1,31 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr initialization
+// Test initialization of a local signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C a;
+  S * p = &a;
+
+  printf ("%s%s\n", p->f (), p->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig06.C b/gcc/testsuite/g++.old-deja/g++.gb/sig06.C
new file mode 100644
index 00000000000..b6476d5f905
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig06.C
@@ -0,0 +1,31 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr initialization
+// Test initialization of a local signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+C a;
+S * p = &a;
+
+int main (void)
+{
+  printf ("%s%s\n", p->f (), p->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig07.C b/gcc/testsuite/g++.old-deja/g++.gb/sig07.C
new file mode 100644
index 00000000000..18a47be7e6e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig07.C
@@ -0,0 +1,29 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr default-argument
+// Test calling a signature member function with default argument.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (char * text) { return text; }
+};
+
+signature S
+{
+  char * f (char * text = "PA");
+};
+
+C a;
+S * p = &a;
+
+int main (void)
+{
+  printf ("%s%s\n", p->f (), p->f ("SS"));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig08.C b/gcc/testsuite/g++.old-deja/g++.gb/sig08.C
new file mode 100644
index 00000000000..2d5d14d9970
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig08.C
@@ -0,0 +1,40 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr argument return-value
+// Test passing a signature pointer to a function and returning it from one.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * text;
+  char * get_msg (void) const { return text; }
+};
+
+const C a = { "PA" };
+const C b = { "SS" };
+
+signature S
+{
+  char * get_msg (void) const;
+};
+
+char * f (const S * p)
+{
+  return p->get_msg ();
+}
+
+const S * g (const C * p)
+{
+  return p;
+}
+
+int main (void)
+{
+  printf ("%s%s\n", f(&a), g(&b)->get_msg ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig09.C b/gcc/testsuite/g++.old-deja/g++.gb/sig09.C
new file mode 100644
index 00000000000..a2e3b33e192
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig09.C
@@ -0,0 +1,34 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment initialization new
+// Test assignment to/initialization of signature pointer with run-time value.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  int f (void) { return 1; }
+};
+
+signature S
+{
+  int f (void);
+};
+
+S * p1 = new C;
+
+int main (void)
+{
+  S * p2 = new C;
+  S * p3;
+
+  p3 = new C;
+
+  if (p1->f () + p2->f () + p3->f () == 3)
+    printf ("PASS\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig10.C b/gcc/testsuite/g++.old-deja/g++.gb/sig10.C
new file mode 100644
index 00000000000..e16f2eeb095
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig10.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr argument return-value new
+// Test passing a signature pointer to a function and returning it from one.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+  char * text;
+public:
+  C (char * s) { text = s; }
+  char * get_msg (void) const { return text; }
+};
+
+signature S
+{
+  char * get_msg (void) const;
+};
+
+char * f (const S * p)
+{
+  return p->get_msg ();
+}
+
+const S * g (const C * p)
+{
+  return p;
+}
+
+int main (void)
+{
+  printf ("%s%s\n", f(new C ("PA")), g(new C ("SS"))->get_msg ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig11.C b/gcc/testsuite/g++.old-deja/g++.gb/sig11.C
new file mode 100644
index 00000000000..892695f3fa3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig11.C
@@ -0,0 +1,34 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr array
+// Test a signature pointer array.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+};
+
+class D
+{
+public:
+  char * f (void) { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+};
+
+int main (void)
+{
+  S * p[2] = { new C, new D };
+
+  printf ("%s%s\n", p[0]->f (), p[1]->f ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig12.C b/gcc/testsuite/g++.old-deja/g++.gb/sig12.C
new file mode 100644
index 00000000000..2747a805915
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig12.C
@@ -0,0 +1,40 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr structure
+// Test a signature pointer structure.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+};
+
+class D
+{
+public:
+  char * f (void) { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+};
+
+struct SP
+{
+  S * p;
+  S * q;
+};
+
+int main (void)
+{
+  SP o = { new C, new D };
+
+  printf ("%s%s\n", o.p->f (), o.q->f ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig13.C b/gcc/testsuite/g++.old-deja/g++.gb/sig13.C
new file mode 100644
index 00000000000..f5da9f80888
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig13.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment initialization
+// Test assignment of/initialization with same type signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  int f (void) { return 1; }
+};
+
+signature S
+{
+  int f (void);
+};
+
+C a;
+S * p1 = &a;
+S * q1 = p1;
+
+int main (void)
+{
+  C a;
+  S * p2 = &a;
+  S * q2 = p2;
+  S * q3;
+
+  q3 = p2;
+
+  if (q1->f () + q2->f () + q3->f () == 3)
+    printf ("PASS\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig14.C b/gcc/testsuite/g++.old-deja/g++.gb/sig14.C
new file mode 100644
index 00000000000..6ce1d02d1bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig14.C
@@ -0,0 +1,55 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment initialization
+// Test assignment of/initialization with different type signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  int f (void) { return 1; }
+  int g (int)  { return 2; }
+};
+
+signature S
+{
+  int f (void);
+  int g (int);
+};
+
+signature T
+{
+  int f (void);
+};
+
+signature U
+{
+  int g (int);
+};
+
+C a;
+S * p1 = &a;
+T * q1 = p1;
+U * r1 = p1;
+
+int main (void)
+{
+  C a;
+  S * p2 = &a;
+  T * q2 = p2;
+  U * r2 = p2;
+  T * q3;
+  U * r3;
+
+  q3 = p2;
+  r3 = p2;
+
+  if (q1->f () + q2->f () + q3->f () == 3
+      && r1->g (0) + r2->g (0) + r3->g (0) == 6)
+    printf ("PASS\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig15.C b/gcc/testsuite/g++.old-deja/g++.gb/sig15.C
new file mode 100644
index 00000000000..f0ae52e9ea7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig15.C
@@ -0,0 +1,35 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr cast
+// Test casting a signature pointer to a class pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C a;
+  S * p;
+  C * q;
+
+  p = &a;
+  q = (C *) p;
+
+  printf ("%s%s\n", q->f (), q->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig16.C b/gcc/testsuite/g++.old-deja/g++.gb/sig16.C
new file mode 100644
index 00000000000..35475e9f504
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig16.C
@@ -0,0 +1,44 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr cast
+// Test casting a class pointer to an anonymous signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "S"; }
+  char * h (void) { return "FAIL"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+signature T
+{
+  char * f (void);
+};
+
+C a;
+signature { char * g (int); } * r1 =
+  (signature { char * h (void); char * g (int); } *) &a;
+
+int main (void)
+{
+  C a;
+  S * p = &a;
+  T * q = p;
+  signature { char * g (int); } * r2 =
+    (signature { char * h (void); char * g (int); } *) &a;
+
+  printf ("%s%s%s\n", q->f (), r1->g (0), r2->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig17.C b/gcc/testsuite/g++.old-deja/g++.gb/sig17.C
new file mode 100644
index 00000000000..6d1d1d94df6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig17.C
@@ -0,0 +1,54 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr cast
+// Test casting a class pointer through a chain of signature pointers.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+class D : public C
+{
+public:
+  char * h (void) { return "FAIL"; }
+};
+
+class E : public C
+{
+public:
+  int foo (int) { return 0; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+signature T
+{
+  char * f (void);
+};
+
+int main (void)
+{
+  D a;
+  S * p;
+  T * q;
+  signature { char * g (int); } * r;
+
+  p = &a;
+  q = (T*) (signature { char * f (void); int foo (int); } *) (E*) (S*) (C*) p;
+  r = (signature { char * h (void); char * g (int); } *) &a;
+
+  printf ("%s%s\n", q->f (), r->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig18.C b/gcc/testsuite/g++.old-deja/g++.gb/sig18.C
new file mode 100644
index 00000000000..ba0ec8689cd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig18.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment virtual
+// Test assignment of object from virtual class to signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  virtual char * f (void) { return "PA"; }
+  virtual char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C a;
+  S * p;
+
+  p = &a;
+
+  printf ("%s%s\n", p->f (), p->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig19.C b/gcc/testsuite/g++.old-deja/g++.gb/sig19.C
new file mode 100644
index 00000000000..160a4a3bd49
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig19.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr initialization virtual
+// Test initialization of signature pointer with object from abstract class.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  virtual char * f (void) = 0;
+  virtual char * g (int)  = 0;
+};
+
+class D : public C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C * p = new D;
+  S * q = p;
+
+  printf ("%s%s\n", q->f (), q->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig20.C b/gcc/testsuite/g++.old-deja/g++.gb/sig20.C
new file mode 100644
index 00000000000..a8228de74b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig20.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr initialization virtual
+// Test initialization of signature pointer with object from virtual class.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  virtual char * f (void) { return "FA"; }
+  virtual char * g (int)  { return "IL"; }
+};
+
+class D : public C
+{
+public:
+  char * f (void) { return "PA"; }
+  char * g (int)  { return "SS"; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (int);
+};
+
+int main (void)
+{
+  C * p = new D;
+  S * q = p;
+
+  printf ("%s%s\n", q->f (), q->g (0));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig21.C b/gcc/testsuite/g++.old-deja/g++.gb/sig21.C
new file mode 100644
index 00000000000..faad45b6403
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig21.C
@@ -0,0 +1,56 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment virtual
+// Test assignment of objects of different types to same signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  virtual char * f (void) = 0;
+};
+
+class D : public C
+{
+public:
+  char * f (void) { return "P"; }
+};
+
+class E
+{
+public:
+  char * f (void) { return "AS"; }
+};
+
+class F : public C
+{
+public:
+  char * f (void) { return "S"; }
+};
+
+signature S
+{
+  char * f (void);
+};
+
+int main (void)
+{
+  E a;
+  C * p = new D;
+  S * q;
+
+  q = p;
+  printf ("%s", q->f ());
+
+  q = &a;
+  printf ("%s", q->f ());
+
+  p = new F;
+  q = p;
+  printf ("%s\n", q->f ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig22.C b/gcc/testsuite/g++.old-deja/g++.gb/sig22.C
new file mode 100644
index 00000000000..25b0a1aa5d1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig22.C
@@ -0,0 +1,59 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment initialization
+// Test assignment to/init of sigptr that requires copying sigtable slots.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  int f (void) { return 1; }
+  int g (int)  { return 2; }
+  int h (void) { return 666; }
+};
+
+signature S
+{
+  int f (void);
+  int g (int);
+  int h (void);
+};
+
+signature T
+{
+  int f (void);
+  int h (void);
+};
+
+signature U
+{
+  int h (void);
+  int g (int);
+};
+
+C a;
+S * p  = &a;
+T * q1 = p;
+U * r1 = p;
+
+int main (void)
+{
+  C a;
+  S * p  = &a;
+  T * q2 = p;
+  U * r2 = p;;
+  T * q3;
+  U * r3;
+
+  q3 = p;
+  r3 = p;
+
+  if (q1->f () + q2->f () + q3->f () == 3
+      && r1->g (0) + r2->g (0) + r3->g (0) == 6)
+    printf ("PASS\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig23.C b/gcc/testsuite/g++.old-deja/g++.gb/sig23.C
new file mode 100644
index 00000000000..767cfa31281
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig23.C
@@ -0,0 +1,53 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment local-signature
+// Test assignment to signature pointer of local signature.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+char * PA (void)
+{
+  class C
+  {
+  public:
+    char * f (void) { return "PA"; }
+  };
+
+  signature S
+  {
+    char * f (void);
+  };
+
+  C a;
+  S * p = &a;
+
+  return p->f ();
+}
+
+char * SS (void)
+{
+  class C
+  {
+  public:
+    char * f (void) { return "SS"; }
+  };
+
+  signature S
+  {
+    char * f (void);
+  };
+
+  C a;
+  S * p = &a;
+
+  return p->f ();
+}
+
+int main (void)
+{
+  printf ("%s%s\n", PA (), SS ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig24.C b/gcc/testsuite/g++.old-deja/g++.gb/sig24.C
new file mode 100644
index 00000000000..2dca6f994ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig24.C
@@ -0,0 +1,36 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr opaque-type
+// Test calling member functions taking/returning opaque type through sigptr.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+signature S
+{
+  typedef t;
+  char * f (t);
+  t g (void);
+  t h (void);
+};
+
+class C
+{
+public:
+  typedef char * t;
+  char * f (t text) { return text; }
+  t g (void) { return "PA"; }
+  t h (void) { return "SS"; }
+};
+
+int main (void)
+{
+  C a;
+  S *  p = &a;
+  S::t w = p->h ();
+
+  printf ("%s%s\n", p->f (p->g ()), p->f (w));
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig25.C b/gcc/testsuite/g++.old-deja/g++.gb/sig25.C
new file mode 100644
index 00000000000..d00ef57ca5e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig25.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr default-implementation
+// Test calling default implementation through signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C { };
+
+class D
+{
+public:
+  char * f (void) { return "SS"; }
+};
+
+signature S
+{
+  char * f (void) { return "PA"; }
+};
+
+int main (void)
+{
+  C a;
+  D b;
+  S * p = &a;
+  S * q = &b;
+
+  printf ("%s%s\n", p->f (), q->f ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig26.C b/gcc/testsuite/g++.old-deja/g++.gb/sig26.C
new file mode 100644
index 00000000000..399737b4a37
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig26.C
@@ -0,0 +1,34 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr default-implementation
+// Test calling default implementation through signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C { };
+
+class D
+{
+public:
+  char * f (void) { return "SS"; }
+};
+
+signature S
+{
+  char * f (void) { return "PA"; }
+  char * g (void) { return f (); }
+};
+
+int main (void)
+{
+  C a;
+  D b;
+  S * p = &a;
+  S * q = &b;
+
+  printf ("%s%s\n", p->g (), q->g ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig27.C b/gcc/testsuite/g++.old-deja/g++.gb/sig27.C
new file mode 100644
index 00000000000..7b9e7d29617
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig27.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr multiple-inheritance
+// Test class defined by multiple inheritance as implementation of signature.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * f (void) { return "PA"; }
+};
+
+class D
+{
+public:
+  char * g (void) { return "SS"; }
+};
+
+class E : public C, public D { };
+
+signature S
+{
+  char * f (void);
+  char * g (void);
+};
+
+int main (void)
+{
+  E a;
+  S * p = &a;
+
+  printf ("%s%s\n", p->f (), p->g ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig28.C b/gcc/testsuite/g++.old-deja/g++.gb/sig28.C
new file mode 100644
index 00000000000..4edff680ce8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig28.C
@@ -0,0 +1,46 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr multiple-inheritance
+// Test correct adjustment of `this' pointer in case of multiple inheritance.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+  char * text;
+public:
+  C () { text = "PA"; }
+  char * f (void) { return text; }
+};
+
+class D
+{
+  char * text;
+public:
+  D () { text = "SS"; }
+  char * g (void) { return text; }
+};
+
+class E : public C, public D
+{
+public:
+  E () : C (), D () { }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (void);
+};
+
+int main (void)
+{
+  E a;
+  S * p = &a;
+
+  printf ("%s%s\n", p->f (), p->g ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig29.C b/gcc/testsuite/g++.old-deja/g++.gb/sig29.C
new file mode 100644
index 00000000000..e5c5e392643
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig29.C
@@ -0,0 +1,46 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr multiple-inheritance
+// Test calling virtual function from MI class through signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+  char * text;
+public:
+  C () { text = "PA"; }
+  virtual char * f (void) { return text; }
+};
+
+class D
+{
+  char * text;
+public:
+  D () { text = "SS"; }
+  virtual char * g (void) { return text; }
+};
+
+class E : public C, public D
+{
+public:
+  E () : C (), D () { }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (void);
+};
+
+int main (void) 
+{ 
+  E a;
+  S * p = &a;
+
+  printf ("%s%s\n", p->f (), p->g ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig30.C b/gcc/testsuite/g++.old-deja/g++.gb/sig30.C
new file mode 100644
index 00000000000..3e93e114b86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig30.C
@@ -0,0 +1,48 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr multiple-inheritance
+// Test calling overwritten virtual functions through signature pointer.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  char * text1;
+  C () { text1 = "PA"; }
+  virtual char * f (void) = 0;
+};
+
+class D
+{
+public:
+  char * text2;
+  D () { text2 = "SS"; }
+  virtual char * g (void) = 0;
+};
+
+class E : public C, public D
+{
+public:
+  E () : C (), D () { };
+  char * f (void) { return text1; }
+  char * g (void) { return text2; }
+};
+
+signature S
+{
+  char * f (void);
+  char * g (void);
+};
+
+int main (void)
+{
+  E a;
+  S * p = &a;
+
+  printf ("%s%s\n", p->f (), p->g ());
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.gb/sig31.C b/gcc/testsuite/g++.old-deja/g++.gb/sig31.C
new file mode 100644
index 00000000000..90fa9e9d47a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.gb/sig31.C
@@ -0,0 +1,52 @@
+// Special g++ Options: -fhandle-signatures
+// GROUPS passed gb sigptr assignment sigsigtable
+// Test use of multiple signature-signature tables for same signature pair.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+class C
+{
+public:
+  virtual int f (void) { return 1; }
+  int g (int)          { return 2; }
+};
+
+class D : public C
+{
+public:
+  int f (void) { return 3; }
+  int g (int)  { return 4; }
+};
+
+signature S
+{
+  int f (void);
+  int g (int);
+};
+
+signature T
+{
+  int g (int);
+  int f (void);
+};
+
+int main (void)
+{
+  S * p = new C;
+  T * q = p;
+  T * r;
+
+  p = new D;
+  r = p;
+
+  if (q->f () == 1 && q->g (0) == 2
+      && r->f () == 3 && r->g (0) == 4)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/2371.C b/gcc/testsuite/g++.old-deja/g++.jason/2371.C
new file mode 100644
index 00000000000..08e72f084aa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/2371.C
@@ -0,0 +1,583 @@
+// GROUPS passed templates nested-classes
+// Special g++ Options: 
+//
+// The SetLS template test
+//
+// Wendell Baker, Berkeley CAD Group, 1993 (wbaker@ic.Berkeley.EDU)
+//
+
+
+#pragma implementation "ListS.h"
+#pragma implementation "SetLS.h"
+
+#include <stdlib.h>
+#include <iostream.h>
+# 1 "../../templates/SetLS.h" 1
+// -*- C++ -*-
+
+
+
+//
+// A Set Template - implemented with an ListS
+//
+// Wendell Baker, Berkeley CAD Group, 1993 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+#pragma interface
+
+
+// $Source: /egcs/carton/cvsfiles/egcs/gcc/testsuite/g++.old-deja/g++.jason/2371.C,v $
+// $Author: law $
+// $Revision: 1.1 $
+// $Date: 1997/08/19 07:35:23 $
+
+
+
+#define XTRUE true
+#define XFALSE false
+
+# 37 "../../templates/SetLS.h"
+
+
+# 1 "../../templates/ListS.h" 1
+// -*- C++ -*-
+
+
+
+//
+// A List Template - providing a singly linked capability
+//
+// Wendell Baker, Berkeley CAD Group, 1993 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+#pragma interface
+
+
+// $Source: /egcs/carton/cvsfiles/egcs/gcc/testsuite/g++.old-deja/g++.jason/2371.C,v $
+// $Author: law $
+// $Revision: 1.1 $
+// $Date: 1997/08/19 07:35:23 $
+
+
+
+
+# 1 "/projects/gnu-cygnus/gnu-cygnus-14/mips/lib/gcc-lib/decstation/cygnus-reno-1/g++-include/bool.h" 1 3
+// Defining XTRUE and XFALSE is usually a Bad Idea,
+// because you will probably be inconsistent with anyone
+// else who had the same clever idea.
+// Therefore:  DON'T USE THIS FILE.
+
+
+
+
+
+
+
+
+
+# 26 "../../templates/ListS.h" 2
+
+# 37 "../../templates/ListS.h"
+
+
+
+// g++ reno-1 is not yet capable of creating templates with nested
+// classes which instantiate the template arguments.
+template<class T>
+struct ListS_link {
+    T item;
+    ListS_link<T> *next;
+
+    ListS_link(const T& i, ListS_link<T> *n = 0): item(i), next(n)
+	{ }
+};
+
+
+//
+// For now, errors are raised by ::abort() because exceptions
+// are not well implemented in cxx or at all in CC 3.0.1
+//
+template<class T>
+class ListS {
+public:
+    ListS();
+    ListS(const ListS<T>&);
+    ~ListS();
+
+    void operator=(const ListS<T>&);
+    
+    unsigned length() const
+	{ return count; }
+    
+    void prepend(const T& item);
+    void append(const T& item);
+    void clear();
+
+    const T& head() const
+	{ ensure_1();
+	  return head_link->item; }
+    T& head()
+	{ ensure_1();
+	  return head_link->item; }
+    void head(T& fill) const
+	{ ensure_1();
+	  fill = head_link->item; }
+    void remove_head()
+	{ remove_head_filling(0); }
+    void remove_head(T& fill)
+	{ remove_head_filling(&fill); }
+
+    const T& tail() const
+	{ ensure_1();
+	  return tail_link->item; }
+    T& tail()
+	{ ensure_1();
+	  return tail_link->item; }
+    void tail(T& fill) const
+	{ ensure_1();
+	  fill = tail_link->item; }
+
+    class Vix {
+    public:
+	Vix(): owner(0), index(0)
+	    { }
+	
+	// These are friend functions so that v == x is the same as x == v
+	friend int operator==(void *v, const Vix& x)
+	    { return v == x.index; }
+	friend int operator==(const Vix& x, void *v)
+	    { return v == x.index; }
+	friend int operator!=(void *v, const Vix& x)
+	    { return v != x.index; }
+	friend int operator!=(const Vix& x, void *v)
+	    { return v != x.index; }
+	friend int operator==(const Vix& x1, const Vix& x2)
+	    { return x1.owner == x2.owner && x1.index == x2.index; }
+	friend int operator!=(const Vix& x1, const Vix& x2)
+	    { return x1.owner != x2.owner || x1.index != x2.index; }
+    private:
+        friend class ListS<T>;
+	
+
+	Vix(const ListS<T> *o, ListS_link<T> *i): owner(o), index(i)
+	    { }
+
+
+
+
+	
+	const ListS<T> *owner;
+
+	ListS_link<T> *index;
+
+
+
+    };
+    
+    Vix first() const
+	{ return Vix(this, head_link); }
+    void next(Vix& x) const
+	{ check(x);
+	  if (x.index != 0)
+	      x.index = x.index->next; }
+    T& operator()(const Vix& x)
+	{ check(x);
+	  return x.index->item; }
+    const T& operator()(const Vix& x) const
+	{ check(x);
+	  return x.index->item; }
+protected:
+# 154 "../../templates/ListS.h"
+
+
+    unsigned count;
+
+    ListS_link<T> *head_link;	// 0 for a zero-length list
+    ListS_link<T> *tail_link;	// 0 for a zero-length list
+
+
+
+
+
+private:
+    // fill may be 0 (then don't fill)
+    void remove_head_filling(T *fill);
+
+    void ensure_1() const
+	{ if (0 == head_link)
+	      ::abort(); }
+    void check(const Vix& x) const
+	{ if (this != x.owner)
+	      ::abort();
+	  if (0 == x.index)
+	      ::abort(); }
+};
+
+template<class T>
+ListS<T>::ListS():
+count(0),
+head_link(0),
+tail_link(0)
+{ }
+
+template<class T>
+ListS<T>::ListS(const ListS<T>& other):
+count(0),
+head_link(0),
+tail_link(0)
+{
+    for (Vix x=other.first(); 0 != x; other.next(x))
+	append(other(x));
+}
+
+template<class T>
+ListS<T>::~ListS()
+{
+    clear();
+}
+
+template<class T>
+void
+ListS<T>::operator=(const ListS<T>& other)
+{
+    clear();
+    for (Vix x=other.first(); 0 != x; other.next(x))
+	append(other(x));
+}
+
+template<class T>
+void
+ListS<T>::prepend(const T& item)
+{
+
+    head_link = new ListS_link<T>(item, head_link);
+
+
+
+    if (0 == tail_link)
+	tail_link = head_link;
+    count++;
+}
+
+template<class T>
+void
+ListS<T>::append(const T& item)
+{
+
+    ListS_link<T> *new_link = new ListS_link<T>(item); 
+
+
+
+    if (0 == tail_link) {
+	head_link = new_link;
+	tail_link = new_link;
+    } else {
+	tail_link->next = new_link;
+	tail_link = tail_link->next;
+    }
+    count++;
+}
+
+template<class T>
+void
+ListS<T>::clear()
+{
+
+    ListS_link<T> *next, *l;
+
+
+
+    for (l=head_link; 0 != l; l=next) {
+	next = l->next;
+	delete l;
+    }
+
+    count = 0;
+    head_link = 0;
+    tail_link = 0;
+}
+
+template<class T>
+void
+ListS<T>::remove_head_filling(T* fill)
+// fill may be 0 in which case don't assign into it
+{
+    ensure_1();
+
+    ListS_link<T> *ohead = head_link;
+
+
+
+    if (0 != fill)
+	*fill = ohead->item;
+    head_link = ohead->next;
+    if (0 == head_link)
+	tail_link = 0;
+    count--;
+    delete ohead;
+}
+
+
+# 39 "../../templates/SetLS.h" 2
+
+
+# 62 "../../templates/SetLS.h"
+
+template<class T>
+class SetLS {
+public:
+    SetLS();
+    
+    void add(const T& item);
+    // There is no remove(const T& item) for this set
+    bool contains(const T& item) const;
+
+    unsigned length() const
+	{ return list.length(); }
+
+    void clear()
+	{ list.clear(); }
+
+    class Vix {
+    public:
+	Vix(): owner(0), vix()
+	    { }
+
+	// These are friend functions so that v == x is the same as x == v
+	friend int operator==(void *v, const Vix& x)
+	    { return v == x.vix; }
+	friend int operator==(const Vix& x, void *v)
+	    { return v == x.vix; }
+	friend int operator!=(void *v, const Vix& x)
+	    { return v != x.vix; }
+	friend int operator!=(const Vix& x, void *v)
+	    { return v != x.vix; }
+	friend int operator==(const Vix& x1, const Vix& x2)
+	    { return x1.owner == x2.owner && x1.vix == x2.vix; }
+	friend int operator!=(const Vix& x1, const Vix& x2)
+	    { return x1.owner != x2.owner || x1.vix != x2.vix; }
+    private:
+	friend class SetLS<T>;
+
+	Vix(const SetLS<T> *o, const ListS<T>::Vix& x): owner(o), vix(x)
+	    { }
+
+	const SetLS<T> *owner;
+	ListS<T>::Vix vix;
+    };
+    friend class Vix;
+    
+    Vix first() const
+	{ return Vix(this, list.first()); }
+    void next(Vix& x) const
+	{ check(x);
+	  list.next(x.vix); }
+    const T& operator()(const Vix& x) const
+	{ check(x);
+	  return list(x.vix); }
+    // There is item no remove(const Vix&) for this set
+protected:
+    ListS<T> list;
+
+private:
+    void check(const Vix& x) const
+	{ if (this != x.owner)
+	      ::abort(); }
+};
+
+
+template<class T>
+SetLS<T>::SetLS():
+
+
+
+list()
+
+{ }
+
+template<class T>
+void
+SetLS<T>::add(const T& item)
+{
+    if ( ! contains(item) ) {
+
+
+
+	list.append(item);
+
+    }
+}
+
+template<class T>
+bool
+SetLS<T>::contains(const T& item) const
+{
+    for (Vix x=first(); 0 != x; next(x)) {
+	if (operator()(x) == item)
+	    return XTRUE;
+    }
+    return XFALSE;
+}
+
+
+# 14 "SetLS.cc" 2
+
+
+// $Source: /egcs/carton/cvsfiles/egcs/gcc/testsuite/g++.old-deja/g++.jason/2371.C,v $
+// $Author: law $
+// $Revision: 1.1 $
+// $Date: 1997/08/19 07:35:23 $
+
+# 1 "/projects/gnu-cygnus/gnu-cygnus-14/mips/lib/gcc-lib/decstation/cygnus-reno-1/g++-include/iostream.h" 1 3
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+# 211 "/projects/gnu-cygnus/gnu-cygnus-14/mips/lib/gcc-lib/decstation/cygnus-reno-1/g++-include/iostream.h" 3
+
+# 21 "SetLS.cc" 2
+
+
+// In (most versions of) g++ 2.X, this use of typedefs has the effect
+// of causing the instantiation of the templates, thereby testing the
+// templates
+
+class test {
+public:
+    test(): value(0)
+	{ }
+    test(int v): value(v)
+	{ }
+
+    void print(ostream& out) const
+	{ out << value; }
+
+    friend int operator==(const test& a, const test& b);
+private:
+    int value;
+};
+
+int
+operator==(const test& a, const test& b)
+{
+    return a.value == b.value;
+}
+
+ostream&
+operator<<(ostream& o, const test& t)
+{
+    t.print(o);
+    return o;
+}
+
+typedef SetLS<test> SLS;
+
+static ostream&
+operator<<(ostream& o, const SLS& s)
+{
+    o << "set of " << s.length() << " = {";
+
+    bool first;
+    SetLS<test>::Vix x;
+    for (first=XTRUE, x=s.first(); 0 != x; s.next(x), first=XFALSE) {
+	if ( ! first )
+	    o << ',';
+	o << ' ';
+	s(x).print(o);
+    }
+    o << '}';
+
+    return o;
+}
+
+SLS gsls;
+const SLS gcsls;
+
+foo()
+{
+    const unsigned SIZE = 20;
+
+    //
+    // SetLS()
+    // SetLS(const SetLS<T>&)
+    // 
+    SLS sls;
+    {
+	// Fill sls with some interesting values
+	for (unsigned i=0; i<SIZE; i++) {
+	    test t = i;
+	    sls.add(t);
+	}
+    }
+
+    const SLS csls(sls);
+
+    //
+    // void operator=(const SetLS<T>&);
+    //
+    sls = csls;
+
+    //
+    // bool contains(const T& item) const
+    //
+    for (unsigned i=0; i<SIZE; i++) {
+	test t = i;
+
+	int contains = sls.contains(t);
+    }
+
+    //
+    // void clear()
+    //
+    sls.clear();
+    if (sls.length() != 0)
+	::abort();
+
+    sls = csls;
+
+    //
+    // Vix first() const
+    // void next(Vix& x) const
+    // T& operator()(const Vix& x)
+    // const T& operator()(const Vix& x) const
+    //
+    SetLS<test>::Vix cx;
+    for (cx=csls.first(); 0 != cx; sls.next(cx)) {
+	if ( ! sls.contains(csls(cx)) )
+	    ::abort();
+    }
+
+    cout << "gsls:\t" << gsls << '\n';
+    cout << "gcsls:\t" << gcsls << '\n';
+    cout << "sls:\t" << sls << '\n';
+    cout << "csls:\t" << csls << '\n';
+}
+
+// Dummy function so it'll run
+main()
+{
+  cout << "PASS" << endl;
+}
+
+template class ListS<test>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/3523.C b/gcc/testsuite/g++.old-deja/g++.jason/3523.C
new file mode 100644
index 00000000000..f47bd7b5bf3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/3523.C
@@ -0,0 +1,40 @@
+// Build don't link: 
+// GROUPS passed assignment
+class ccUnwind 
+{
+public:
+    virtual ~ccUnwind (); // comment out virtual, and void diag changes
+};
+
+template<class T>
+class ccHandle : public ccUnwind // similarly comment out inheritance
+{   
+public:
+    ccHandle& operator = (const ccHandle& h);
+};
+
+class cc_Image;		 
+
+class ccImage : public ccHandle<cc_Image>
+{
+public:
+//  reversing the order of the next two lines changes the diagnostic
+//  printed about the def of ccDisplay::image 
+    ccImage    (const  ccImage  &);
+    ccImage    (const  cc_Image &);
+};
+
+class ccDisplay 
+{
+public:
+    ccImage img;
+//ccImage image ( ccImage i) {img = i; return img;}
+// above line  compiles 
+    ccImage image ( ccImage i) { return img = i;} /* this gets void* error */
+};
+
+
+
+// vd.C: In method `class ccImage ccDisplay::image (class ccImage)':
+// vd.C:31: bad argument 1 for function `ccImage::ccImage (const class cc_Image&)' (type was void *)
+// vd.C:31: in base initialization for class `ccImage'
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access1.C b/gcc/testsuite/g++.old-deja/g++.jason/access1.C
new file mode 100644
index 00000000000..fff77f25749
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access1.C
@@ -0,0 +1,17 @@
+// Bug: access declarations are broken.
+// Build don't link:
+
+class A {
+public:
+  void foo ();
+};
+
+class B: private A {
+public:
+  A::foo;
+};
+
+void foo() {
+  B b;
+  b.foo ();			// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access10.C b/gcc/testsuite/g++.old-deja/g++.jason/access10.C
new file mode 100644
index 00000000000..6db610c5010
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access10.C
@@ -0,0 +1,14 @@
+// PRMS Id: 4839
+// Bug: The initializer of a static member of a class has the same acess
+// rights as a member function.  g++ doesn't realize that.
+// Build don't link:
+
+class X 
+{
+  X (int);
+  static X foo;
+public:
+  void dummy();
+};
+
+X X::foo = 9;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access11.C b/gcc/testsuite/g++.old-deja/g++.jason/access11.C
new file mode 100644
index 00000000000..31a89b2ede8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access11.C
@@ -0,0 +1,12 @@
+// PRMS Id: 4900
+// Bug: g++ doesn't apply access control uniformly to type conversion operators
+// Build don't link:
+
+struct A {
+protected:
+  operator int * () const;
+};
+
+struct B : public A {
+  int * foo () { return A::operator int *(); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access12.C b/gcc/testsuite/g++.old-deja/g++.jason/access12.C
new file mode 100644
index 00000000000..71e336180e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access12.C
@@ -0,0 +1,16 @@
+// PRMS Id: 4694
+// Bug: g++ doesn't realize that A::i refers to a member of `this' in B().
+// Build don't link:
+
+class A {
+protected:
+  int i;
+};
+
+struct B : public A {
+  B () { A::i = 0; }
+};
+
+struct C : public B {
+  C () { B::i = 0; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access13.C b/gcc/testsuite/g++.old-deja/g++.jason/access13.C
new file mode 100644
index 00000000000..c12dd81dc87
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access13.C
@@ -0,0 +1,15 @@
+// PRMS Id: 4955
+// Build don't link:
+
+struct A {
+ protected:
+  int i;
+  void f ();
+};
+
+struct B: public A {
+  void g () {
+    this->A::i = 1;		// gets bogus error - access control failure
+    this->A::f();		// gets bogus error - access control failure
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access14.C b/gcc/testsuite/g++.old-deja/g++.jason/access14.C
new file mode 100644
index 00000000000..f181906ec97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access14.C
@@ -0,0 +1,10 @@
+// Build don't link:
+
+template <class T> struct A { T t; };
+
+template <class T> class B: private T {
+ public:
+  T::t;			   // gets bogus error - doesn't recognize access decl
+};
+
+template class B<A<int> >;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access15.C b/gcc/testsuite/g++.old-deja/g++.jason/access15.C
new file mode 100644
index 00000000000..4380998521f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access15.C
@@ -0,0 +1,18 @@
+// Bug: g++ complains about Z being a private base when trying to
+// initialize B::foo.
+// Build don't link:
+
+struct Z {
+  Z();
+  Z(int);
+};
+
+struct A : private Z { };
+struct B : public A
+{
+    Z foo;
+    B();
+    B(const B&);
+};
+
+B::B() : foo(1) { }		// gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access16.C b/gcc/testsuite/g++.old-deja/g++.jason/access16.C
new file mode 100644
index 00000000000..16a132a5b9f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access16.C
@@ -0,0 +1,20 @@
+// Bug: g++ uses the same binfo for the a subobject of c and the a subobject
+// of b, so basetype_paths get bashed improperly.
+// Build don't link:
+
+class a {
+protected:
+	virtual void foo() { }	// gets bogus error
+};
+
+class b : public virtual a {};
+
+class c : public b {
+public:
+	void bar() { b::foo(); } // gets bogus error
+};
+
+main() {
+	c test;
+	test.bar();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access17.C b/gcc/testsuite/g++.old-deja/g++.jason/access17.C
new file mode 100644
index 00000000000..9ed7d30d2a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access17.C
@@ -0,0 +1,24 @@
+// Make sure definitions of static members have the right access.
+// Build don't link:
+
+struct A {
+protected:
+  int i;
+  int f ();			// ERROR - 
+};
+
+struct B: public A {
+  static int A::*p;
+  static int (A::*fp)();
+};
+
+int A::* B::p = &A::i;
+int (A::* B::fp)() = &A::f;
+
+struct C {
+  static int A::*p;
+  static int (A::*fp)();
+};
+
+int A::* C::p = &A::i;		// ERROR - 
+int (A::* C::fp)() = &A::f;	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access18.C b/gcc/testsuite/g++.old-deja/g++.jason/access18.C
new file mode 100644
index 00000000000..11b7e10ed47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access18.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5073
+// Bug: g++ doesn't catch access violations in base initializers.
+// Special g++ Options: -w
+
+int r = 0;
+class A {
+  private:
+    A() { r = 1; }		// ERROR - 
+    ~A() {}			// ERROR - 
+};
+    
+class B : public A {
+  public:
+    B(): A() {}			// ERROR - 
+    B(const B&) {}		// ERROR - 
+    ~B() { }			// ERROR - private dtor
+};
+
+main()
+{
+  B b;
+  return r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access2.C b/gcc/testsuite/g++.old-deja/g++.jason/access2.C
new file mode 100644
index 00000000000..cacfbe1c6a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access2.C
@@ -0,0 +1,11 @@
+// Bug: g++ doesn't deal with friends also being derived classes.
+// Build don't link:
+
+class A {
+  int i;
+  friend class B;
+};
+
+class B : public A {
+  void f () { i = 1; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access20.C b/gcc/testsuite/g++.old-deja/g++.jason/access20.C
new file mode 100644
index 00000000000..96093dc0190
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access20.C
@@ -0,0 +1,39 @@
+// PRMS Id: 6662
+// Bug: we crash trying to check the access on anglesSinesCosines.
+// Build don't link:
+
+#define Double double
+
+class GCTransform
+{
+  protected:
+    struct angle
+    {
+	Double phi1 ;
+	Double phi2 ;
+    } ;
+
+    struct sineAndCosine
+    {
+	Double cosine1 ;
+	Double cosine2 ;
+	Double sine1 ;
+	Double sine2 ;
+    } ;
+
+    union anglesSinesCosines
+    {
+	struct angle a ;
+	struct sineAndCosine siCo ;
+    } ;
+};
+
+class GCTransTransmit : public GCTransform
+{
+  protected:
+
+    struct GCTransTransmitDataTemp
+    {
+	union anglesSinesCosines t ; // causes abort
+    } ;
+} ;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access21.C b/gcc/testsuite/g++.old-deja/g++.jason/access21.C
new file mode 100644
index 00000000000..340ed61fe97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access21.C
@@ -0,0 +1,22 @@
+// PRMS Id: 6877
+// Build don't link:
+
+typedef __SIZE_TYPE__ size_t;
+class aa {
+public:
+        aa();
+        ~aa();
+private:
+        int iaa;
+        void operator delete(void*, size_t);
+};
+
+class bb {
+public:
+        aa caa;
+};				// gets bogus error - calling private delete
+
+void
+f(){
+        bb abb;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access22.C b/gcc/testsuite/g++.old-deja/g++.jason/access22.C
new file mode 100644
index 00000000000..736a053a591
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access22.C
@@ -0,0 +1,21 @@
+// PRMS Id: 8518
+// Bug: Call to foo is not checked for accessibility
+
+class A
+{
+  private:
+    static void foo() {}	// ERROR - 
+  public:
+    void goo() {}
+};
+
+struct B : public A
+{
+    void func() { foo(); }	// ERROR - 
+};
+
+main()
+{
+    B b;
+    b.func();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access23.C b/gcc/testsuite/g++.old-deja/g++.jason/access23.C
new file mode 100644
index 00000000000..57331687b7a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access23.C
@@ -0,0 +1,79 @@
+// PRMS Id: 9127
+// Bug: members of anonymous unions are not access-controlled.
+
+#include <stdio.h>
+
+struct Foo {
+public:
+  union {
+    long A;
+    void *pX;
+  };
+  union X {
+    long A;
+    void *pX;
+  } PUB ;
+  int PUB_A;
+protected:
+  union {
+    long B;
+    void *pY;
+  } ;
+  union Y {
+    long B;
+    void *pY;
+  } PRT;
+  int PRT_A;
+private:
+  union {
+    long C;
+    void *pZ;
+  };
+  union Z {
+    long C;
+    void *pZ;
+  } PRV;
+  int PRV_A;
+};
+
+struct Bar : public Foo {
+public:
+  DoSomething() {
+    PUB_A = 0;
+    Foo::A = 0;
+    printf("%x\n",pX);  
+    Foo::PUB.A = 0;
+    printf("%x\n",PUB.pX);  
+    B = 0;			
+    printf("%x\n",Foo::pY);  
+    PRT_A = 0;
+    PRT.B = 0;		
+    printf("%x\n",Foo::PRT.pY);	
+    PRV_A = 0;			// ERROR - 
+    Foo::C = 0;			// ERROR - 
+    printf("%x\n",pZ);  	// ERROR - 
+    Foo::PRV.C = 0;		// ERROR - 
+    printf("%x\n",PRV.pZ); 	// ERROR - 
+  }
+};
+
+main()
+{
+  Foo a;
+
+  a.PUB_A = 0;
+  a.A = 0;
+  printf("%x\n",a.pX);  
+  a.PRT_A = 0;			// ERROR - 
+  a.B = 0;			// ERROR - 
+  printf("%x\n",a.pY);  	// ERROR - 
+  a.PRV_A = 0;			// ERROR - 
+  a.C = 0;			// ERROR - 
+  printf("%x\n",a.pZ);  	// ERROR - 
+  a.PUB.A = 0;
+  printf("%x\n",a.PUB.pX);  
+  a.PRT.B = 0;			// ERROR - 
+  printf("%x\n",a.PRT.pY);  	// ERROR - 
+  a.PRV.C = 0;			// ERROR - 
+  printf("%x\n",a.PRV.pZ);  	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access24.C b/gcc/testsuite/g++.old-deja/g++.jason/access24.C
new file mode 100644
index 00000000000..7c423598723
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access24.C
@@ -0,0 +1,11 @@
+// Bug: forward reference to friend doesn't work in template.
+// Build don't link:
+
+template <class T> class A {
+  static int i;
+  friend struct B;
+};
+
+struct B {
+  void f () { A<int>::i = 0; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access3.C b/gcc/testsuite/g++.old-deja/g++.jason/access3.C
new file mode 100644
index 00000000000..fae6c9323e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access3.C
@@ -0,0 +1,12 @@
+// Simple testcase for access control.
+// Build don't link:
+
+class A {
+ protected:
+  void f ();
+};
+
+class B : public A {
+ public:
+  void f () { A::f(); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access4.C b/gcc/testsuite/g++.old-deja/g++.jason/access4.C
new file mode 100644
index 00000000000..51f5fb10f8e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access4.C
@@ -0,0 +1,14 @@
+// Simple testcase for access control.
+// Build don't link:
+
+class A {
+protected:
+  static int i;
+};
+
+class B: public A { };
+
+class C: public B {
+public:
+  void g () { B b; b.i; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access5.C b/gcc/testsuite/g++.old-deja/g++.jason/access5.C
new file mode 100644
index 00000000000..5eec43d936e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access5.C
@@ -0,0 +1,12 @@
+// Simple testcase for access control.
+// Build don't link:
+
+class A {
+ protected:
+  void f ();
+};
+
+class B : public A { };
+class C : public B {
+ void f () { B::f(); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access6.C b/gcc/testsuite/g++.old-deja/g++.jason/access6.C
new file mode 100644
index 00000000000..24676d4050b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access6.C
@@ -0,0 +1,12 @@
+// Simple testcase for access control.
+// Build don't link:
+
+class A {
+ public:
+  void f ();
+};
+
+class B: protected A { };
+class C: protected B {
+  void g() { f (); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access7.C b/gcc/testsuite/g++.old-deja/g++.jason/access7.C
new file mode 100644
index 00000000000..708fa0fb626
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access7.C
@@ -0,0 +1,13 @@
+// Simple testcase for access control.
+// Build don't link:
+
+class A {
+ protected:
+  static void f ();
+};
+
+class B: public A {};
+class C: public A {};
+class D: public C, public B {
+  void g () { A::f(); }		// gets bogus error - wrongly ambiguous static member call, XFAIL *-*-*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access8.C b/gcc/testsuite/g++.old-deja/g++.jason/access8.C
new file mode 100644
index 00000000000..c8addcd73a1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access8.C
@@ -0,0 +1,29 @@
+// From: smidt@dd.chalmers.se (Peter Smidt)
+// Date: 25 Jan 1994 23:41:33 -0500
+// Bug: g++ forgets access decls after the definition.
+// Build don't link:
+
+class inh {
+        int a;
+protected:
+        void myf(int);
+};
+
+class mel : private inh {
+protected:
+        int t;
+	inh::myf;
+};
+
+class top_t : protected mel {
+public:
+        void myf(int);
+};
+
+void inh::myf(int i) {
+        a = i;
+}
+
+void top_t::myf(int i) {
+        inh::myf(i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/access9.C b/gcc/testsuite/g++.old-deja/g++.jason/access9.C
new file mode 100644
index 00000000000..f9c2797d72b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/access9.C
@@ -0,0 +1,9 @@
+// Bug: g++ doesn't allow const objects to be constructed.
+// Build don't link:
+
+struct B { B(); };
+
+const B foo()
+{
+  return B();			// gets bogus error - constructing const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/aggregate.C b/gcc/testsuite/g++.old-deja/g++.jason/aggregate.C
new file mode 100644
index 00000000000..b451b23ef7c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/aggregate.C
@@ -0,0 +1,13 @@
+struct A { int i; };
+
+main()
+{
+  A a1 = { 42 };
+  A a2 (a1);
+  A a3 = { 137 };
+  a1 = a3;
+
+  if (a1.i == 137 && a2.i == 42 && a3.i == 137)
+    return 0;
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ambig1.C b/gcc/testsuite/g++.old-deja/g++.jason/ambig1.C
new file mode 100644
index 00000000000..4551dc7d6e4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ambig1.C
@@ -0,0 +1,6 @@
+// Testcase for ambiguity between functional cast and abstract declarator.
+// This ambiguity accounts for 6 of the r/r conflicts.
+// Special g++ Options: -pedantic-errors
+
+int i = sizeof (int ());	// ERROR - sizeof applied to fn type
+int j = sizeof (int () + 1);
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ambig2.C b/gcc/testsuite/g++.old-deja/g++.jason/ambig2.C
new file mode 100644
index 00000000000..c6da7528bd3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ambig2.C
@@ -0,0 +1,11 @@
+// Testcase for ambiguity between cast and parmlist.
+// This ambiguity accounts for 1 of the r/r conflicts.
+// Do not compile with -pedantic so that the compiler will accept taking
+// the sizeof a function type.
+// Special g++ Options: -Wno-pointer-arith
+// Build don't link:
+
+void f(){
+  (void)sizeof(int((int)1.2));
+  (void)sizeof(int((int)));		// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ambig3.C b/gcc/testsuite/g++.old-deja/g++.jason/ambig3.C
new file mode 100644
index 00000000000..3f01660bf98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ambig3.C
@@ -0,0 +1,16 @@
+// Testcase for ambiguity between function and variable declaration (8.2).
+// Build don't link:
+
+struct A {
+  A (int, int);
+  int k;
+};
+
+void f ()
+{
+  int i[2], j;
+  A a (int (i[1]), j);		// gets bogus error - late parsing XFAIL *-*-*
+  A b (int (i[1]), int j);	// function
+  a.k = 0;			// gets bogus error - late parsing XFAIL *-*-*
+  b (i, j);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/anon.C b/gcc/testsuite/g++.old-deja/g++.jason/anon.C
new file mode 100644
index 00000000000..63d17a8cb2d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/anon.C
@@ -0,0 +1,18 @@
+// Bug: g++ has trouble copying anonymous structs.
+
+typedef struct { int i; } foo;
+struct A : public foo { 
+  struct { int i; } x;
+};
+
+int main ()
+{
+  A a;
+  a.i = 5;
+  a.x.i = 42;
+  A b (a);
+  a = b;
+  if (a.i != 5 || a.x.i != 42)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/anon2.C b/gcc/testsuite/g++.old-deja/g++.jason/anon2.C
new file mode 100644
index 00000000000..55d68988e5c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/anon2.C
@@ -0,0 +1,7 @@
+// g++ should not complain about anonymous bitfields.
+// Build don't link:
+
+struct A
+{
+  int : 2;	 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/anon3.C b/gcc/testsuite/g++.old-deja/g++.jason/anon3.C
new file mode 100644
index 00000000000..b3f05f8ad14
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/anon3.C
@@ -0,0 +1,25 @@
+// Bug: g++ dies.
+// Build don't link:
+
+class cl {
+public:
+  cl();
+  void set(void *, char *, int);
+private:
+  union {
+    float vf;
+    struct ff {
+      void *ptr;
+      char *name;
+      int sz;
+    } *vff;
+  };
+};
+
+void cl::set(void *p, char *n, int sz)
+{
+    vff = new ff; // This procude an internal compiler error.
+    vff->ptr = p;
+    vff->name = n;
+    vff->sz = sz;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/anon4.C b/gcc/testsuite/g++.old-deja/g++.jason/anon4.C
new file mode 100644
index 00000000000..de0b40e2aec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/anon4.C
@@ -0,0 +1,14 @@
+// PRMS Id: 5371
+// Bug: g++ screws up the alignment of buff and dies.
+// Build don't link:
+// Special g++ Options: -O
+
+main()
+{
+  union {
+    double a;
+    char buff[sizeof(double)];
+  };
+
+  void *p = buff;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/binding.C b/gcc/testsuite/g++.old-deja/g++.jason/binding.C
new file mode 100644
index 00000000000..0a013abd73e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/binding.C
@@ -0,0 +1,11 @@
+// Bug: g++ only looks in the current temporary binding level for a name.
+
+struct T { ~T(); };
+
+main()
+{
+  foo:
+   T t;				// ERROR - redeclared
+  bar:
+   T t;				// ERROR - redeclaration
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/binding2.C b/gcc/testsuite/g++.old-deja/g++.jason/binding2.C
new file mode 100644
index 00000000000..e56a0544b47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/binding2.C
@@ -0,0 +1,15 @@
+// Bug: g++ screws up binding levels in a switch statement with cleanups.
+// Build don't link:
+
+struct A {
+  ~A() { }
+};
+
+int f (int i)
+{
+  switch (i) {
+  default:
+    A a;
+  }
+  return 1;
+}				// causes compiler segfault
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/binding3.C b/gcc/testsuite/g++.old-deja/g++.jason/binding3.C
new file mode 100644
index 00000000000..3cd358fb7af
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/binding3.C
@@ -0,0 +1,20 @@
+// Bug: g++ fails to clear out the IDENTIFIER_CLASS_VALUEs of various names
+// after a class definition.
+// Build don't link:
+
+struct A {
+  typedef double T;
+  virtual T f () = 0;
+};
+
+class B {
+  B (const B&);
+  void operator=(const B&);
+public:
+  B ();
+  typedef void * T;
+};
+
+struct C : public A {
+  T f ();			// gets bogus error
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool.C b/gcc/testsuite/g++.old-deja/g++.jason/bool.C
new file mode 100644
index 00000000000..e446f12fab6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool.C
@@ -0,0 +1,46 @@
+// Testcase for uses of bool.
+// Build don't link:
+
+int i,j,k;
+
+/* Check that types of certain expressions are bool.  */
+void f ()
+{
+  i ? j == k : true;
+  i ? j < k : true;
+  i ? j && k : true;
+}
+
+/* Check that g++ can find a conversion to bool when one exists.  */
+struct A { operator char * (); } a;
+struct B { operator int (); } b;
+struct C { operator float (); } c;
+struct D { operator bool (); } d;
+struct E { operator int E::* (); } e;
+
+void g ()
+{
+  a || true;
+  b || true;
+  c || true;			// gets bogus error
+  d || true;
+  e || true;
+}
+
+/* Check for support in templates.  */
+template <class T> struct F { };
+template class F<bool>;
+
+template <class T> void f (T, bool) { };
+template void f (bool, bool);
+
+/* Special cases.  */
+void h ()
+{
+  /* Used to cause infinite recursion.  */
+  i&1 || true;
+  /* Should find conversion path to int.  */
+  d == true;
+}
+
+bool boo = -1;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool2.C b/gcc/testsuite/g++.old-deja/g++.jason/bool2.C
new file mode 100644
index 00000000000..4c0edcb3596
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool2.C
@@ -0,0 +1,14 @@
+// Make sure that bool bitfields promote to int properly.
+
+struct F {
+  bool b1 : 1;
+  bool b2 : 7;
+};
+
+main()
+{
+  F f = { true, true };
+
+  if (int (f.b1) != 1)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool3.C b/gcc/testsuite/g++.old-deja/g++.jason/bool3.C
new file mode 100644
index 00000000000..d8e95147b75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool3.C
@@ -0,0 +1,13 @@
+// From: panisset@cae.ca (Jean-Francois Panisset)
+// Subject: Problem with constant expressions for bitfields
+// Date: Mon, 6 Jun 94 14:00:01 EDT
+
+// Bug: g++ doesn't treat boolean true and false as constant values.
+// Build don't link:
+
+enum E { e1,e2,e3,e4,e5 };
+
+struct X
+{
+        unsigned int bits : ((e5 > 4) ? 8 : 4);	// gets bogus error - constant expression
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool4.C b/gcc/testsuite/g++.old-deja/g++.jason/bool4.C
new file mode 100644
index 00000000000..36a2180c927
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool4.C
@@ -0,0 +1,10 @@
+// Test for allowing conversion to bool.
+
+struct A { };
+
+main ()
+{
+  bool b = (void*)0;
+  b = (int A::*)0;
+  b = (int (A::*)())0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool5.C b/gcc/testsuite/g++.old-deja/g++.jason/bool5.C
new file mode 100644
index 00000000000..79d848c0b19
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool5.C
@@ -0,0 +1,10 @@
+main ()
+{
+  bool b = false;
+  int i = b++;
+  if (i != false || b != true)
+    return 1;
+  i = b++;
+  if (i != true || b != true)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool6.C b/gcc/testsuite/g++.old-deja/g++.jason/bool6.C
new file mode 100644
index 00000000000..b8db8722b8f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool6.C
@@ -0,0 +1,9 @@
+// Bug:  The conversion from bool to int gets stripped.
+// Build don't link:
+
+bool b;
+
+main ()
+{
+  return ((!b) != 0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/bool7.C b/gcc/testsuite/g++.old-deja/g++.jason/bool7.C
new file mode 100644
index 00000000000..1ecb68d4e04
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/bool7.C
@@ -0,0 +1,29 @@
+// Build don't link:
+
+struct A
+{
+  operator bool () const;
+  operator const void * () const;
+};
+
+struct B
+{
+  A a;
+  int foo1 ();
+  int foo2 ();
+};
+
+int
+B::foo1 ()
+{
+  return a ? 0 : 1;  // ambiguous default type conversion for `operator !='
+}
+
+int
+B::foo2 ()
+{
+  if (a)
+    return 0;
+  else
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/builtin.C b/gcc/testsuite/g++.old-deja/g++.jason/builtin.C
new file mode 100644
index 00000000000..0e0cc48c691
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/builtin.C
@@ -0,0 +1,10 @@
+// Bug: g++ overloads strlen instead of bashing the builtin version.
+// Special g++ Options: -w
+// Build don't link:
+
+extern "C" void strlen (const char *);
+
+void f ()
+{
+  strlen("Hi");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/builtin2.C b/gcc/testsuite/g++.old-deja/g++.jason/builtin2.C
new file mode 100644
index 00000000000..698d0a12112
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/builtin2.C
@@ -0,0 +1,8 @@
+// Build don't link:
+
+inline void strlen (const char *) { }
+
+void f ()
+{
+  strlen("Hi");			// gets bogus error - wrongful overload
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/byval.C b/gcc/testsuite/g++.old-deja/g++.jason/byval.C
new file mode 100644
index 00000000000..45fb1e2836b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/byval.C
@@ -0,0 +1,19 @@
+// Bug: a is destroyed in both foo() and main()
+
+int count;
+
+struct A {
+  double a,b;
+  A(int) { count++; }
+  A(const A&) { count++; }
+  ~A() { count--; }
+};
+
+void foo (A a)
+{ }
+
+main()
+{
+  foo (1);
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/byval2.C b/gcc/testsuite/g++.old-deja/g++.jason/byval2.C
new file mode 100644
index 00000000000..490e625805d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/byval2.C
@@ -0,0 +1,23 @@
+// From: panisset@cae.ca (Jean-Francois Panisset)
+// Subject: 2.6.0 pre-rel, internal error, regression, mips-sgi-irix4
+// Date: Thu, 14 Jul 94 23:34:21 EDT
+// Build don't link:
+
+class Char
+{
+protected:
+  char          rep;
+public:
+  Char (const char ) {};
+  operator char() const;
+  void  operator -= (const Char   );
+};
+
+inline  Char  operator -  (const Char    a, const Char    b) {}
+inline  char  operator == (const Char    a, const char b) {}
+
+char mystrcmp(Char s[31], Char t[31])
+{
+  for (; *s == *t; ++s, ++t) if (*s == '\0') return 0;
+  return char(*s - *t);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/byval3.C b/gcc/testsuite/g++.old-deja/g++.jason/byval3.C
new file mode 100644
index 00000000000..7c2a798ed47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/byval3.C
@@ -0,0 +1,14 @@
+// Test to make sure that value return of classes with cleanups works; it
+// has been broken at various times on PCC_STATIC_STRUCT_RETURN targets.
+// Build don't link:
+
+struct A {};
+
+struct R : virtual A { virtual ~R(); };
+
+R g();
+
+void encode()
+{
+    g();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/c-inline.C b/gcc/testsuite/g++.old-deja/g++.jason/c-inline.C
new file mode 100644
index 00000000000..7e90c4ea027
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/c-inline.C
@@ -0,0 +1,11 @@
+// Bug: the compiler gets hopelessly confused.
+// Build don't link:
+
+#line 1 "c-inline.h"
+#pragma interface
+inline double abs (double) { return 0.0; }
+inline short abs (short) { return 0; }
+#line 2 "c-inline.C"
+extern "C" {
+  inline int abs (int) { return 0; } // causes segfault - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/c2.C b/gcc/testsuite/g++.old-deja/g++.jason/c2.C
new file mode 100644
index 00000000000..ba7f0ed0d55
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/c2.C
@@ -0,0 +1,18 @@
+// PRMS Id: 3134
+// g++ understands C redeclaration semantics.  Sun CC 2.0.1 doesn't.
+// Special g++ Options:
+// Build don't link:
+
+extern "C" {
+  int foo();
+  int foo(int);
+
+  int bar(int);
+  int bar();
+}
+
+main()
+{
+  foo (1);
+  bar (1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cast1.C b/gcc/testsuite/g++.old-deja/g++.jason/cast1.C
new file mode 100644
index 00000000000..4e987eafece
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cast1.C
@@ -0,0 +1,8 @@
+// Bug: g++ fails to grok functional casts in all situations.
+// Build don't link:
+
+class A  {
+public:
+  typedef int B;
+  static B foo() { return B(1); } // gets bogus error - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cast2.C b/gcc/testsuite/g++.old-deja/g++.jason/cast2.C
new file mode 100644
index 00000000000..02495b346d1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cast2.C
@@ -0,0 +1,15 @@
+// Build don't link:
+// The compiler tried to build up a double with a NOP_EXPR from
+// integer_zero_node, which fails.
+
+template <class T>
+class vector  {
+public:
+    vector (int n, const T& value = T()) {}
+};
+
+void
+foo (void)
+{
+  vector<double> v (10);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cast3.C b/gcc/testsuite/g++.old-deja/g++.jason/cast3.C
new file mode 100644
index 00000000000..5d599805aa3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cast3.C
@@ -0,0 +1,16 @@
+// PRMS Id: 7088
+// Build don't link:
+
+struct string
+{
+  int length () const;
+  string (string &);
+  string (char * = 0);
+  int operator [] (int);
+  ~string ();
+};
+
+string _cook(const   string     raw, bool for_postscript)
+{
+  unsigned char c = (unsigned) ((string &)raw)[1];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cleanup.C b/gcc/testsuite/g++.old-deja/g++.jason/cleanup.C
new file mode 100644
index 00000000000..d9adddec2e8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cleanup.C
@@ -0,0 +1,23 @@
+// Bug: continue over object decl calls destructor but not constructor.
+
+int c = 0;
+int d = 0;
+extern "C" int printf(const char *,...);
+
+class Foo {
+public:
+  Foo(){ c++; }
+  ~Foo(){ d++; }
+};
+
+int main()
+{
+  for(int i=0;i<2;i++){
+    continue;
+    Foo bar;
+  }
+  printf ("%d %d\n", c, d);
+  if (c == d && d == 0)
+    return 0;
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cleanup2.C b/gcc/testsuite/g++.old-deja/g++.jason/cleanup2.C
new file mode 100644
index 00000000000..21addfe67d7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cleanup2.C
@@ -0,0 +1,15 @@
+// PRMS Id: 6303
+// Bug: compiler crashes processing the cleanup for arrayOfClass.
+// Build don't link:
+
+class Class {
+public:
+  ~Class();		// This dtor MUST be declared to generate the error...
+};
+
+Class varOfClass;
+
+main() {
+  // This MUST be 'const' to generate the error...
+  const Class	arrayOfClass[1] = { varOfClass }; // causes abort
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/complete1.C b/gcc/testsuite/g++.old-deja/g++.jason/complete1.C
new file mode 100644
index 00000000000..0f140e16114
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/complete1.C
@@ -0,0 +1,12 @@
+// PRMS Id: 4695
+// Bug: g++ wrongly requires A to be complete here.
+// Build don't link:
+
+struct A;
+
+void foo(const A &);
+
+void bar(A *p)
+{
+  foo(*p);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cond.C b/gcc/testsuite/g++.old-deja/g++.jason/cond.C
new file mode 100644
index 00000000000..8f4da347bb6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cond.C
@@ -0,0 +1,39 @@
+// Build don't link: 
+// GROUPS passed rtti
+// Negative testcase for decls in conditions.
+
+main()
+{
+  float i;
+  
+  if (int i = 1)		// ERROR - , XFAIL *-*-*
+    {
+      char i;			// ERROR - , XFAIL *-*-*
+      char j;
+    }
+  else
+    {
+      short i;			// ERROR - , XFAIL *-*-*
+      char j;
+    }
+
+  if (struct A { operator int () { return 1; } } *foo = new A) // ERROR - 
+    ;
+
+  A bar;			// ERROR - 
+  
+  if (enum A { one, two, three } foo = one) // ERROR - 
+    ;
+
+  struct B { operator int () { return 2; } };
+
+  if (struct B * foo = new B)
+    ;
+
+  if (int f () = 1)		// ERROR - 
+    ;
+  
+  if (int a[2] = {1, 2})	// ERROR - 
+    ;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/cond2.C b/gcc/testsuite/g++.old-deja/g++.jason/cond2.C
new file mode 100644
index 00000000000..890c3193d3d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/cond2.C
@@ -0,0 +1,65 @@
+// Positive testcase for decls in conditions.
+
+extern "C" int printf(const char *, ...);
+
+int up = 0;
+int down = 0;
+
+struct T
+{
+  int i;
+  T(int j) { i = j; printf("UP\n"); up++; }
+  T(const T& t) { i = t.i; printf("unwanted copy\n"); }
+  ~T() { printf ("DOWN\n"); down++; }
+  operator int () { return i; }
+};
+
+main ()
+{
+  int t;
+
+  if (T t = 1)
+    ;
+
+  printf ("\n");
+  
+  int j = 3;
+  while (T t = j--)
+    ;
+  
+  printf ("\n");
+  
+  j = 3;
+  while (1)
+    {
+      T t = j--;
+      if (t) continue;
+      break;
+    }
+  
+  printf ("\n");
+  
+  j = 3;
+  for (;T t = j--;)
+    ;
+
+  printf ("\n");
+  
+  for (int k = 3; T t = k--;)
+    ;
+
+  printf ("\n");
+  
+  switch (T t = 34)
+    {
+    case 34:
+      ;
+    }
+
+  printf ("\n");
+  
+  if (up == down && up == 18)
+    return 0;
+  else
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/condexp.C b/gcc/testsuite/g++.old-deja/g++.jason/condexp.C
new file mode 100644
index 00000000000..edfd12ef1a9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/condexp.C
@@ -0,0 +1,14 @@
+// PRMS id: 5629
+// Build don't link:
+
+struct String { const char *x; };
+class Pathname: public String { };
+
+String
+f(int i)
+{
+    Pathname p;
+    String s;
+
+    return i ? p: s;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/const.C b/gcc/testsuite/g++.old-deja/g++.jason/const.C
new file mode 100644
index 00000000000..2faf8e5811e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/const.C
@@ -0,0 +1,16 @@
+// Bug: a ends up in the text segment, so trying to initialize it causes
+// a seg fault.
+
+struct A {
+  int i;
+  A(): i(0) {}
+  A(int j): i(j) {}
+};
+
+const A a;
+const A b(1);
+
+int main ()
+{
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/const2.C b/gcc/testsuite/g++.old-deja/g++.jason/const2.C
new file mode 100644
index 00000000000..3aeae3c7e71
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/const2.C
@@ -0,0 +1,14 @@
+// Example of static member constants
+
+extern "C" int printf (const char *, ...);
+
+struct T {
+  static const char letter = 'a'; // this is the new stuff!
+  char x[letter];
+  void f();
+};
+
+void T::f() { printf ("%p", &letter); }
+const char T::letter;               // still need def after class
+
+main() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/const3.C b/gcc/testsuite/g++.old-deja/g++.jason/const3.C
new file mode 100644
index 00000000000..49360a4fabe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/const3.C
@@ -0,0 +1,10 @@
+// Bug: bar isn't emitted, which causes havoc.
+
+extern int i;
+const int bar = i;
+int i = 5;
+
+main()
+{
+  return bar != 5;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/const4.C b/gcc/testsuite/g++.old-deja/g++.jason/const4.C
new file mode 100644
index 00000000000..b8b8efa0ae6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/const4.C
@@ -0,0 +1,24 @@
+// PRMS Id: 8927
+// Bug: complex inheritance interferes with const checking
+
+class GrandParent {
+public:
+  virtual void DoIt();
+protected:
+  int A;
+};
+
+class Parent : virtual public GrandParent {
+public:
+  virtual void DoX() const;
+};
+
+class Child : public Parent {
+public:
+  void DoX() const;
+};
+
+void Child::DoX() const
+{
+  A = 10;		// ERROR - assignment to const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/context.C b/gcc/testsuite/g++.old-deja/g++.jason/context.C
new file mode 100644
index 00000000000..a9a83631992
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/context.C
@@ -0,0 +1,20 @@
+// PRMS Id: 3988
+// Bug: DECL_CONTEXT of A::B gets clobbered in pushdecl when defining A::foo().
+// Build don't link:
+
+#pragma implementation "context.h"
+#line 1 "context.h"
+#pragma interface
+
+template <class T>
+struct A {
+  inline void foo () { }
+  class B { };
+};
+
+struct C : public A<int> {
+  void bar (C::B&);
+};
+#line 2 "context.C"
+
+void C::bar (C::B& b) { }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion.C
new file mode 100644
index 00000000000..80436f355a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion.C
@@ -0,0 +1,16 @@
+// Bug: g++ doesn't find the conversion path from DPtr& to B*.
+// Build don't link:
+
+class B {};
+class D : public B {};
+class DPtr
+{
+public:
+  operator D*() const;
+};
+
+void foo (B* bp);
+void bar (DPtr& dp)
+{
+  foo (dp);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion10.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion10.C
new file mode 100644
index 00000000000..97bb70744cb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion10.C
@@ -0,0 +1,19 @@
+// PRMS Id: 9019
+// Bug: g++ doesn't find conversion to const char *.
+// Build don't link:
+
+struct String {
+  String ();
+  explicit String (const char *);
+  operator const char * ();
+};
+
+int main(int argc, char **argv) 
+{
+	String deflt("no args");
+	String useme;
+
+	const char *p = (argv[1]) ? argv[1] : deflt;
+
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion11.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion11.C
new file mode 100644
index 00000000000..c0c6ca4159c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion11.C
@@ -0,0 +1,26 @@
+// PRMS Id: 8805
+// Bug: The two-level conversion is not found when calling a global fn.
+
+class Int {
+public:
+  Int(int A);
+};
+
+class Ding {
+public:
+  Ding(Int A);
+};
+
+class Something {
+public:
+  void DoSomething(Ding A);	// ERROR - referred to
+};
+
+void DoSomething(Ding A);
+
+void foo(Something* pX)
+{
+  DoSomething(1);		// ERROR - 
+  pX->DoSomething(1);		// ERROR - 
+  (*pX).DoSomething(1);		// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion2.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion2.C
new file mode 100644
index 00000000000..db773d698e4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion2.C
@@ -0,0 +1,6 @@
+// PRMS Id: 3069
+
+void f(int&);			// ERROR - referenced by error below
+void g(const int& i) {
+  f(i);				// ERROR - discarding const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion3.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion3.C
new file mode 100644
index 00000000000..0d66c1ecee1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion3.C
@@ -0,0 +1,7 @@
+void qsort (void *, int, int, int (*)(const void *, const void *));
+int f (char *, char *);
+void g ()
+{
+  typedef int (*pf)(void *, void *);
+  qsort(0, 0, 0, pf(f));	// ERROR - adding const to function parms
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion4.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion4.C
new file mode 100644
index 00000000000..7caca196d0a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion4.C
@@ -0,0 +1,14 @@
+// Build don't link:
+struct A {
+  A (int);
+};
+struct B {
+  operator int () { return 1; }
+};
+void f (const A&);
+void g()
+{
+  B b;
+  f ((A) b);
+  f (A (b)); // gets bogus error - functional cast treated differently from C style
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion5.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion5.C
new file mode 100644
index 00000000000..303860b4725
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion5.C
@@ -0,0 +1,12 @@
+// Build don't link:
+struct A { };
+struct B: public A {
+  A a;
+  operator A () { return a; }	// WARNING - never used implicitly
+};
+void f (const A&);
+void g()
+{
+  B b;
+  (A) b; // gets bogus error - trying both constructor and type conversion operator
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion6.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion6.C
new file mode 100644
index 00000000000..42b9ac226d8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion6.C
@@ -0,0 +1,40 @@
+// PRMS Id: g++/6034
+
+extern "C" int printf (const char *, ...);
+
+class Base
+{
+	char x;
+};
+
+template <class T>
+// remove the public Base inheritance and the problem goes away...
+class Container : public Base
+{
+public:
+
+    Container(const T& aValue): myValue(aValue) { }
+    
+    operator const T&(void) const
+    {
+	printf("Container::const T& called\n");
+	return myValue;
+    }
+    
+protected:
+
+    T myValue;
+};
+
+typedef unsigned short Type;
+
+typedef Container<Type> TypeContainer;
+
+main(void)
+{
+    TypeContainer myTypeContainer(2);
+    Type t = myTypeContainer;
+
+    printf ("myType = %d\n", t);
+    return t != 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion7.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion7.C
new file mode 100644
index 00000000000..01812f5b8ee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion7.C
@@ -0,0 +1,16 @@
+// Bug: g++ tries to look inside (B*)0 for a virtual base pointer.
+
+struct A
+{
+};
+
+struct B : virtual A
+{
+};
+
+A* a;
+
+int main()
+{
+    a = (B*)0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion8.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion8.C
new file mode 100644
index 00000000000..fc4de8111b8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion8.C
@@ -0,0 +1,10 @@
+// PRMS id: 8279
+
+main ()
+{
+  char *const *p = 0;
+  char **q = 0;
+
+  (void)(p - q);
+  (void)(q - p);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/conversion9.C b/gcc/testsuite/g++.old-deja/g++.jason/conversion9.C
new file mode 100644
index 00000000000..e0d3715dae2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/conversion9.C
@@ -0,0 +1,13 @@
+// PRMS Id: 8475
+
+class SomeClass {
+public:
+  operator int & () {
+    static int x;
+    return x;
+  }
+} a;
+
+int main (int, char**) {
+  return a + 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash1.C b/gcc/testsuite/g++.old-deja/g++.jason/crash1.C
new file mode 100644
index 00000000000..298273490fc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash1.C
@@ -0,0 +1,29 @@
+// Bug: g++ dies on this input.
+// Build don't link:
+
+class Sample
+  {
+ public:
+  int operator <<(const char *c);
+  };
+
+extern Sample sample;
+
+struct Simple
+  {
+  int a;
+  };
+
+extern "C" void get_it();
+
+class Test
+  {
+ private:
+  void test();
+  friend void get_it();
+  };
+
+void Test::test()
+  {
+  sample << "hello";
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash10.C b/gcc/testsuite/g++.old-deja/g++.jason/crash10.C
new file mode 100644
index 00000000000..b9669449589
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash10.C
@@ -0,0 +1,7 @@
+// PRMS Id: 5155
+
+struct A {
+  enum foo { bar };
+};
+
+typedef A::foo A::foo;		// ERROR - causes compiler segfault
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash11.C b/gcc/testsuite/g++.old-deja/g++.jason/crash11.C
new file mode 100644
index 00000000000..51d1629630e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash11.C
@@ -0,0 +1,9 @@
+// Bug: g++ crashes on this input.
+// Build don't link:
+
+struct A {
+  const char *p;
+};
+const char foo[] = "bar";
+const A a = { foo };
+extern const A* ap = &a;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash12.C b/gcc/testsuite/g++.old-deja/g++.jason/crash12.C
new file mode 100644
index 00000000000..46d63225bab
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash12.C
@@ -0,0 +1,10 @@
+// Bug: g++ dies instead of flagging this invalid.
+// Build don't link:
+
+inline float  max(float  x, float  y) { return (x>y)?x:y; }
+
+float  b(float  x, float  y, float  z)
+{
+  float f = (y<x)?x:(max<y)?z:y;	// ERROR - 
+  return f;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash2.C b/gcc/testsuite/g++.old-deja/g++.jason/crash2.C
new file mode 100644
index 00000000000..9e96af1e3c3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash2.C
@@ -0,0 +1,10 @@
+// Bug: g++ crashes on this (admittedly invalid) input.
+// Special g++ Options:
+// Build don't link:
+
+class PhysicalPageId {
+  const maximum_block_numbers = 2;
+  long block_number[maximum_block_numbers];
+};
+
+const PhysicalPageId shadows_physical_page_id_null = { 2, { 0, 0 } }; // ERROR - constructor initializes non-field m_b_n
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash3.C b/gcc/testsuite/g++.old-deja/g++.jason/crash3.C
new file mode 100644
index 00000000000..c3709c55536
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash3.C
@@ -0,0 +1,13 @@
+// Bug: g++ tries to generate initialization semantics for a Node from an int,
+// and fails.
+// Build don't link:
+
+struct Node
+{
+  Node* child[2];
+};				// ERROR - 
+
+void bug(int i)
+{
+  Node* q = new Node(i);	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash4.C b/gcc/testsuite/g++.old-deja/g++.jason/crash4.C
new file mode 100644
index 00000000000..bf6a15c370a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash4.C
@@ -0,0 +1,38 @@
+// PRMS Id: 4346
+// Bug: g++ dies on redefinition of cc_Array::repInvariant.
+// Build don't link:
+
+class ccObjectInfo
+{
+public:
+    virtual const ccObjectInfo& repInvariant (int =0) const;
+};
+
+template <class T>
+class cc_Array : public ccObjectInfo
+{
+public:
+  virtual const ccObjectInfo& repInvariant (int =0) const ;
+};
+
+template <class T>
+const ccObjectInfo& cc_Array<T>::repInvariant(int) const
+{  return *this /* *this is required here */; } // ERROR - redefined
+
+template <class T>
+class ccArray :public ccObjectInfo
+{
+  ccArray (cc_Array<T>*);
+};
+
+template <class T>
+class ccObjArray : public ccArray<T>
+{
+  ccObjArray();
+}; 
+
+template <class T>
+const ccObjectInfo& cc_Array<T>::repInvariant(int) const
+{  return 0; }			// ERROR - causes compiler segfault
+
+typedef ccObjArray< double>	ccROIRuns;	 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash5.C b/gcc/testsuite/g++.old-deja/g++.jason/crash5.C
new file mode 100644
index 00000000000..b67376fe261
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash5.C
@@ -0,0 +1,4 @@
+// Bug: g++ doesn't deal well with abstract declarators used inappropriately.
+// Build don't link:
+
+void (*)();			// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash6.C b/gcc/testsuite/g++.old-deja/g++.jason/crash6.C
new file mode 100644
index 00000000000..8e0a9c861f2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash6.C
@@ -0,0 +1,9 @@
+// Bug: g++ dies on the below.
+// Build don't link:
+
+class A { };
+void f ()
+{
+  A a;
+  a.~a();			// ERROR - causes segfault
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash7.C b/gcc/testsuite/g++.old-deja/g++.jason/crash7.C
new file mode 100644
index 00000000000..e7dd8f75aad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash7.C
@@ -0,0 +1,5 @@
+// Bug: g++ can't deal.
+
+typedef unsigned size_t;	// ERROR - previous declaration
+typedef unsigned long size_t;	// ERROR - redefining size_t
+void f (size_t);		// causes compiler segfault - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash8.C b/gcc/testsuite/g++.old-deja/g++.jason/crash8.C
new file mode 100644
index 00000000000..4482a43f4bc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash8.C
@@ -0,0 +1,9 @@
+struct A {
+  A();
+  A(A);				// ERROR - copy ctor must take reference
+};
+main()
+{
+  A a;
+  A b(a);			// causes compiler segfault
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/crash9.C b/gcc/testsuite/g++.old-deja/g++.jason/crash9.C
new file mode 100644
index 00000000000..6cacb11a541
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/crash9.C
@@ -0,0 +1,29 @@
+// PRMS Id: 5085
+// Bug: TYPE_POINTER_TO wasn't set.
+// Build don't link:
+
+class A {
+   A(const A &);
+   void operator=(const A &); 
+public:
+   inline A();
+};
+
+class B {
+   A a;
+public:
+   B();
+   virtual void f() const;
+};
+
+class C : public B { };
+
+class D : C {
+public:
+  void f() const;
+};
+
+void D::f() const
+{
+  C::f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ctor1.C b/gcc/testsuite/g++.old-deja/g++.jason/ctor1.C
new file mode 100644
index 00000000000..69afd425519
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ctor1.C
@@ -0,0 +1,26 @@
+// PRMS Id: 5584
+
+extern "C"
+{
+  struct xx {
+    void (*xx)(void);
+    int x,y;
+  };
+}
+
+int r = 1;
+
+void f(void)
+{
+  r = 0;
+}
+
+main()
+{
+  struct xx p;
+
+  p.xx = f;
+  p.xx();
+
+  return r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ctor2.C b/gcc/testsuite/g++.old-deja/g++.jason/ctor2.C
new file mode 100644
index 00000000000..bf37c114be1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ctor2.C
@@ -0,0 +1,16 @@
+// Bug: the reference to c in the initializer list doesn't get fixed up.
+// Build don't link:
+
+struct AP {
+    AP(unsigned char);
+};
+
+struct AI : AP {
+    AI(unsigned char);
+};
+
+AI::AI(unsigned char c)
+: AP(c)
+{
+  &c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dcast1.C b/gcc/testsuite/g++.old-deja/g++.jason/dcast1.C
new file mode 100644
index 00000000000..f4d93c3c068
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dcast1.C
@@ -0,0 +1,20 @@
+// PRMS Id: 7162
+// Build don't link:
+
+struct B {
+   int i;
+   B() : i(1) {}
+};
+
+struct D : B {
+   int i;
+   D() : i(2) {}
+};
+
+void ch()
+{
+   D od2;
+   D &rd2 = od2;
+
+   B &rd1 = dynamic_cast<B&>(rd2);
+}   
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dcast2.C b/gcc/testsuite/g++.old-deja/g++.jason/dcast2.C
new file mode 100644
index 00000000000..2ba1357fd62
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dcast2.C
@@ -0,0 +1,18 @@
+struct A { virtual void f() { } };
+struct B { virtual void g() { } };
+struct C : public A, public B { };
+
+main ()
+{
+  C* cp = 0;
+  B* bp = 0;
+
+  if (dynamic_cast <B*> (cp) != 0)
+    return 1;
+
+  if (dynamic_cast <void *> (bp) != 0)
+    return 1;
+
+  if (dynamic_cast <C*> (bp) != 0)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dcast3.C b/gcc/testsuite/g++.old-deja/g++.jason/dcast3.C
new file mode 100644
index 00000000000..1dc00a138eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dcast3.C
@@ -0,0 +1,32 @@
+// Testcase for tricky dynamic cast situations.
+
+struct A {
+  virtual void f () { }
+};
+
+struct B : public A { };
+struct C : public B { };
+struct D : public B { };
+struct E : public C, public D { };
+
+struct B2 : public virtual A { };
+struct C2 : public B2 { };
+struct D2 : public B2 { };
+struct E2 : public C2, public D2 { };
+
+main ()
+{
+  E e;
+  E2 e2;
+
+  A* ap = (C*)&e;
+
+  // ap points to base subobject of unique B; succeeds
+  if (dynamic_cast <B*> (ap) == 0)
+    return 1;
+
+  ap = (C2*)&e2;
+  // ap points to base subobject shared by two Bs; fails
+  if (dynamic_cast <B2*> (ap) != 0)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/default1.C b/gcc/testsuite/g++.old-deja/g++.jason/default1.C
new file mode 100644
index 00000000000..e6ef57768e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/default1.C
@@ -0,0 +1,16 @@
+// PRMS Id: 5204
+// Bug: g++ bashes the type of add_sym with the type of add, so calling it
+// with one parameter generates an error.
+// Build don't link:
+
+int add(int const &symbol,
+	const unsigned char flags=(void*)0); // ERROR - invalid default arg
+
+int add_sym(int const &symbol,
+	    const unsigned char flags=0);
+
+main()
+{
+   int fname;
+   add_sym(fname);      // Guarantee a symbol exists
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/default2.C b/gcc/testsuite/g++.old-deja/g++.jason/default2.C
new file mode 100644
index 00000000000..f50ee2f151b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/default2.C
@@ -0,0 +1,31 @@
+// PRMS Id: 5921
+// Build don't link:
+// Bug: default arguments containing constructor calls persist incorrectly.
+
+class foo
+{
+ public:
+  foo();
+  foo(int x);
+ public:
+  int iamamember;
+};
+
+class bar
+{
+ public:
+  bar();
+  int memberfunction(int i, char *j, double k, foo foo1 = foo(0));
+};
+
+int
+pain(bar *bar1)
+{
+  return bar1->memberfunction(1, "x", 0.0);
+}
+
+int
+pain2(bar *bar1)
+{
+  return bar1->memberfunction(1, "x", 0.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/default3.C b/gcc/testsuite/g++.old-deja/g++.jason/default3.C
new file mode 100644
index 00000000000..05af3b68b27
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/default3.C
@@ -0,0 +1,6 @@
+// Bug: type_list_equal aborts when it sees lang-specific tree nodes.
+// Build don't link:
+
+struct A { };
+void f (A a = A());
+void g (A a = A());
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/defctor.C b/gcc/testsuite/g++.old-deja/g++.jason/defctor.C
new file mode 100644
index 00000000000..252d43ef6ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/defctor.C
@@ -0,0 +1,15 @@
+// Bug: g++ doesn't generate default constructor.
+
+class A {
+public:
+  int i;
+};
+
+extern "C" int printf(const char *, ...);
+
+main () {
+  A a;
+  a.i = 1;
+  A b (a);
+  printf("%d\n",b.i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/delete1.C b/gcc/testsuite/g++.old-deja/g++.jason/delete1.C
new file mode 100644
index 00000000000..a176652df71
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/delete1.C
@@ -0,0 +1,5 @@
+#include <stddef.h>
+struct A {
+  virtual void operator delete (void *); // ERROR - virtual delete
+  virtual void * operator new (size_t);	 // ERROR - virtual new
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/delete2.C b/gcc/testsuite/g++.old-deja/g++.jason/delete2.C
new file mode 100644
index 00000000000..7748e2b9cb5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/delete2.C
@@ -0,0 +1,16 @@
+// PRMS Id: 5003
+// Bug: g++ complains about calling the destructor for a const object.
+// Build don't link:
+
+struct A {
+public:
+  ~A();
+};
+
+const A foo ();
+
+void bar()
+{
+  A n;
+  n = foo();		// gets bogus error - deleting const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/delete3.C b/gcc/testsuite/g++.old-deja/g++.jason/delete3.C
new file mode 100644
index 00000000000..8bffb9aca86
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/delete3.C
@@ -0,0 +1,18 @@
+// PRMS Id: 6093
+
+class A {
+public:
+  A();
+  ~A();
+protected:
+  void operator delete(void *);	// ERROR - protected
+};
+
+A::~A()
+{
+}
+
+void foo(A *p)
+{
+  delete p;			// ERROR - in this context
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/destruct.C b/gcc/testsuite/g++.old-deja/g++.jason/destruct.C
new file mode 100644
index 00000000000..a9d7e86a467
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/destruct.C
@@ -0,0 +1,33 @@
+// Exhaustive test for destructors of simple types.
+// PRMS Id: 2744, 3308
+// Build don't link:
+
+template <class T> class A {
+  T q;
+public:
+  ~A() {
+    q.T::~T();
+    q.~T();
+    (&q)->T::~T();
+    (&q)->~T();
+  }
+};
+
+typedef char * cp;
+
+main ()
+{
+  A<int> a;
+  A<cp> b;
+  int i;
+  cp c;
+
+  i.~int();
+  i.int::~int();
+  (&i)->~int();
+  (&i)->int::~int();
+  c.~cp();
+  c.cp::~cp();
+  (&c)->~cp();
+  (&c)->cp::~cp();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/destruct2.C b/gcc/testsuite/g++.old-deja/g++.jason/destruct2.C
new file mode 100644
index 00000000000..09b6bdd7991
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/destruct2.C
@@ -0,0 +1,20 @@
+// PRMS Id: 4342
+// Bug: g++ does not massage things enough to allow calling ~X().
+// Build don't link:
+
+struct X 
+{
+    virtual ~X ();
+};
+
+struct Y : public X
+{};
+
+struct Z : public Y, public X
+{};				// WARNING - 
+
+void foo ()
+{
+    Z* f = new Z;
+    delete f;			// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/destruct3.C b/gcc/testsuite/g++.old-deja/g++.jason/destruct3.C
new file mode 100644
index 00000000000..94ca834d65f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/destruct3.C
@@ -0,0 +1,44 @@
+// PRMS Id: 4342 (second testcase)
+// Bug: g++ still can't deal with ambiguous inheritance in destructor calls.
+// Build don't link:
+
+struct ccUnwind 
+{
+    ccUnwind ();
+    virtual ~ccUnwind ();
+};
+
+struct ccPersistent
+{
+    virtual void bar();
+};
+
+struct ccImpExp : public ccPersistent, public ccUnwind
+{};
+
+struct ccTool : public ccImpExp
+{};
+
+struct ccScreenTool : public ccTool
+{};
+
+struct ccVTool : public ccScreenTool
+{};
+
+struct ccScreenObjRep : public ccUnwind
+{};
+
+struct ccScreenObj : public ccScreenObjRep
+{};
+
+struct ccVSTool : public ccImpExp, public ccUnwind 
+{};	// gets bogus error - XFAIL *-*-*
+
+struct ccSCCP : public ccVSTool
+{};	// gets bogus error - XFAIL *-*-*
+
+void foo ()
+{
+    ccSCCP* foo = new ccSCCP;
+    delete foo;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/destruct4.C b/gcc/testsuite/g++.old-deja/g++.jason/destruct4.C
new file mode 100644
index 00000000000..3ce7d765505
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/destruct4.C
@@ -0,0 +1,14 @@
+// PRMS Id: 4342
+// Bug: g++ fails to massage ambiguity in calling virtual destructor.
+// Build don't link:
+
+class A { public: virtual ~A();};
+class B: public A { };
+class C: public A { };
+class D: public B, public C { };
+ 
+void foo ()
+{
+    D* p = new D;
+    delete p;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dot.C b/gcc/testsuite/g++.old-deja/g++.jason/dot.C
new file mode 100644
index 00000000000..7f4bd7776d4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dot.C
@@ -0,0 +1,20 @@
+// PRMS Id: 4143
+// Bug: Pointer is silently dereferenced in method call.
+// Build don't link:
+
+extern "C" int printf (const char *, ...);
+
+class Test
+{
+    char ch;
+  public:
+    Test(char c) : ch(c) {}
+    void Print() { printf("%c", ch); }
+};
+
+main()
+{
+    Test *p = new Test('x');
+
+    p.Print();	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dtor.C b/gcc/testsuite/g++.old-deja/g++.jason/dtor.C
new file mode 100644
index 00000000000..c9e71628d09
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dtor.C
@@ -0,0 +1,13 @@
+struct A {
+  ~A();
+};
+
+struct B {
+  ~B();
+};
+
+main()
+{
+  A a;
+  a.~B();			// ERROR - wrong name
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dtor2.C b/gcc/testsuite/g++.old-deja/g++.jason/dtor2.C
new file mode 100644
index 00000000000..7f975136e8d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dtor2.C
@@ -0,0 +1,10 @@
+// PRMS Id: 5163
+// Bug: g++ doesn't accept the explicit destructor call syntax for templates.
+
+template <class T> struct A { };
+A<int> a;
+
+main()
+{
+  a.~A();			// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dtor3.C b/gcc/testsuite/g++.old-deja/g++.jason/dtor3.C
new file mode 100644
index 00000000000..0c5e68abb47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dtor3.C
@@ -0,0 +1,18 @@
+// PRMS Id: 5341
+// Bug: g++ complains about the explicit destructor notation.
+// Build don't link:
+
+#include <stddef.h>
+
+void *operator new(size_t Size, void* pThing) { return pThing; };
+
+template <class T> class Stack {
+public:
+  Stack() { new (Data) T(); }
+  ~Stack() { ((T*)Data)->~T(); }
+private:
+  char Data[sizeof(T)];
+};
+
+Stack<int> a;
+Stack<Stack<int> > c;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dtor4.C b/gcc/testsuite/g++.old-deja/g++.jason/dtor4.C
new file mode 100644
index 00000000000..dfdc3aafd6c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dtor4.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5420
+// Bug: g++ gets mixed up calling destructors for references.
+// Build don't link:
+
+template<class X>
+class Z {
+public:
+    char space[100];
+    void kill()
+	{ X& x = (X&) space[0];
+	  x.~X(); }
+};
+
+class C { int i; };
+
+void
+f()
+{
+    Z<int> r;
+    r.kill();
+    Z<C> s;
+    s.kill();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/dtor5.C b/gcc/testsuite/g++.old-deja/g++.jason/dtor5.C
new file mode 100644
index 00000000000..245e057deac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/dtor5.C
@@ -0,0 +1,24 @@
+// PRMS Id: 5286
+// Bug: g++ forgets side-effects of object in call to nonexistent destructor.
+
+void * operator new (__SIZE_TYPE__ s, void * p) { return p; }
+
+int r;
+
+template <class T> struct A {
+  T *p;
+  int i;
+  A() { i = 0; p = (T*) new char[sizeof (T)]; new (p + i++) T; }
+  ~A() { p[--i].~T(); r = i; }
+};
+
+main()
+{
+  { A<int> a; }
+
+  int* p = (int*) new char[sizeof (int)];
+  new (p + r++) int;
+  p[--r].~int();
+  
+  return r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum.C b/gcc/testsuite/g++.old-deja/g++.jason/enum.C
new file mode 100644
index 00000000000..6dd24e61811
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum.C
@@ -0,0 +1,19 @@
+// PRMS Id: 4337
+// Bug: Enums are not looked up to arbitrary depth.
+// Build don't link:
+
+struct W {
+  enum A { B };
+};
+
+struct X : public W
+{};
+
+struct Y : public X
+{};
+
+struct S
+{
+  X::A a1;
+  Y::A a2;			// gets bogus error - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum2.C b/gcc/testsuite/g++.old-deja/g++.jason/enum2.C
new file mode 100644
index 00000000000..8fb75386878
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum2.C
@@ -0,0 +1,8 @@
+// Build don't link:
+
+enum tristate { no = -1, maybe, yes };
+
+void foobar ()
+{
+  tristate var = no;		// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum3.C b/gcc/testsuite/g++.old-deja/g++.jason/enum3.C
new file mode 100644
index 00000000000..9e25570ab42
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum3.C
@@ -0,0 +1,19 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+enum tristate { no = -1, maybe, yes };
+
+tristate
+tristate_satisfies (register tristate const t1, register tristate const t2)
+{
+  switch (t1)
+    {
+    case no:
+      return (tristate) -t2;
+    case maybe:
+      return yes;
+    case yes:
+      return t2;
+    }
+  return maybe;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum4.C b/gcc/testsuite/g++.old-deja/g++.jason/enum4.C
new file mode 100644
index 00000000000..ab8b69f4aa7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum4.C
@@ -0,0 +1,10 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+enum tristate { no = -1, maybe, yes };
+
+tristate
+definite_tristate (int truth)
+{
+  return (truth) ? yes : no;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum5.C b/gcc/testsuite/g++.old-deja/g++.jason/enum5.C
new file mode 100644
index 00000000000..bbaa6747461
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum5.C
@@ -0,0 +1,8 @@
+enum { a = 1 };
+
+int main(void)
+{
+  int l = -1;
+
+  return ! (l < a);		// testcase fails if a is unsigned
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum6.C b/gcc/testsuite/g++.old-deja/g++.jason/enum6.C
new file mode 100644
index 00000000000..4097e2db1eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum6.C
@@ -0,0 +1,15 @@
+// Special g++ Options: -fshort-enums
+
+#include <limits.h>
+
+enum A { a1 = 0x7fffffff };
+enum B { b1 = 0x80000000 };
+enum C { c1 = -1, c2 = 0x80000000 };
+enum D { d1 = CHAR_MIN, d2 = CHAR_MAX };
+enum E { e1 = CHAR_MIN, e2 = CHAR_MIN };
+
+main()
+{
+  return (sizeof (A) != 4 || sizeof (B) != 4 || sizeof (C) != 8
+	  || sizeof (D) != 1 || sizeof (E) != 1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum7.C b/gcc/testsuite/g++.old-deja/g++.jason/enum7.C
new file mode 100644
index 00000000000..0f683047aec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum7.C
@@ -0,0 +1,15 @@
+// Yet Another testcase for signed/unsigned enums.
+// Build don't link:
+
+enum A { AA = 0, AB = 1};
+enum B { BA = -1, BB = 1};
+
+void set(int a);
+void set(long a);
+
+void
+foo()
+{
+	set(AA);	// gets bogus error - why is this ambiguous
+	set(BA);	// when this is not amibguous
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/enum8.C b/gcc/testsuite/g++.old-deja/g++.jason/enum8.C
new file mode 100644
index 00000000000..811b44cf29b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/enum8.C
@@ -0,0 +1,20 @@
+// Bug: the switch fails on the Alpha because folding ef - 1 fails.
+
+enum foo { one=1, thirty=30 };
+
+int f (enum foo ef)
+{
+  switch (ef)
+    {
+    case one:
+    case thirty:
+      return 0;
+    default:
+      return 1;
+    }
+}
+
+main ()
+{
+  return f (one);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/explicit.C b/gcc/testsuite/g++.old-deja/g++.jason/explicit.C
new file mode 100644
index 00000000000..9fcecfd81ae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/explicit.C
@@ -0,0 +1,15 @@
+// Testcase for explicit instantiation of templates.
+// Build don't link:
+
+template <class T>
+class A {
+  T t;
+public:
+  void f () { }
+};
+
+template class A<int>;
+
+template <class T> T min (T a, T b) { return (a < b ? a : b); }
+
+template int min (int, int);
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/expr1.C b/gcc/testsuite/g++.old-deja/g++.jason/expr1.C
new file mode 100644
index 00000000000..89d719fddd9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/expr1.C
@@ -0,0 +1,12 @@
+// Bug: g++ doesn't figure out what to do.
+// Build don't link:
+
+struct A {
+  operator char *();
+};
+ 
+char foo(A a)
+{
+  char c = a[0];			// gets bogus error
+  return c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/friend.C b/gcc/testsuite/g++.old-deja/g++.jason/friend.C
new file mode 100644
index 00000000000..ee6ee8d5eae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/friend.C
@@ -0,0 +1,18 @@
+// Bug: g++ doesn't keep track of the lexical context of friends properly.
+
+extern "C" void exit(int);
+
+struct B;
+struct A {
+  static void f () { exit (1); }
+};
+
+struct B {
+  static void f () { exit (0); }
+  friend void g () { f (); }
+};
+
+main ()
+{
+  g ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/friend2.C b/gcc/testsuite/g++.old-deja/g++.jason/friend2.C
new file mode 100644
index 00000000000..02ccb5c59dc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/friend2.C
@@ -0,0 +1,21 @@
+// PRMS Id: 5189
+// Bug: g++ fails to collapse the several declarations of freefoo, so it isn't
+// recognized as a friend.
+// Build don't link:
+
+extern "C"
+void freefoo(void);
+
+class foo {
+   friend void freefoo(void);
+   protected:
+      static void foomem();
+   public:
+      foo();
+      ~foo();
+};
+
+void freefoo(void)
+{
+   foo::foomem();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/groff1.C b/gcc/testsuite/g++.old-deja/g++.jason/groff1.C
new file mode 100644
index 00000000000..79a96438ad9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/groff1.C
@@ -0,0 +1,40 @@
+// PRMS Id: 3744
+// Bug: unswitching a COND_EXPR initializer fails to set SIDE_EFFECTS on the
+// result, so expand_expr ignores it.
+
+extern "C" {
+  int printf(const char *,...);
+  void exit(int);
+}
+
+struct A {
+  int x;
+  int y;
+
+  A() : x(0), y(0) { }
+};
+
+struct S {
+  S() : flags(0) { }
+  unsigned flags;
+  A from;
+  void foo(const A &pos);
+};
+
+void S::foo(const A &pos)
+{
+  A a = flags ? from : pos;
+  printf("%d %d\n", a.x, a.y);
+  if (a.x != 17 || a.y != 12)
+    exit (1);
+}
+
+main()
+{
+  A pos;
+  pos.x = 17;
+  pos.y = 12;
+  S s;
+  s.foo(pos);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/hmc1.C b/gcc/testsuite/g++.old-deja/g++.jason/hmc1.C
new file mode 100644
index 00000000000..751cf80f481
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/hmc1.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed templates default-arguments
+template <class I>
+class Class {
+public:
+  void func1(int n=1);
+  void func2(int d) {}
+};
+template <class I> 
+void Class<I>::func1(int n) {}
+
+//if this is replaced by:
+//void Class<I>::func1(int n=1) {}
+//the code compiles.
+
+main() {
+  Class<int> C;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/incomplete1.C b/gcc/testsuite/g++.old-deja/g++.jason/incomplete1.C
new file mode 100644
index 00000000000..8b738d9f606
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/incomplete1.C
@@ -0,0 +1,15 @@
+// The reference parameter to fred isn't dereferenced properly.
+// Build don't link:
+
+class Gump {};
+Gump  operator &  (const Gump x){return x;}
+
+class B;
+
+void *sam(int &x)
+{return &x;}
+
+const void *fred(const B& x)
+{return &x;}  // "&x" causes the compilation error.
+
+class B {};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/incomplete2.C b/gcc/testsuite/g++.old-deja/g++.jason/incomplete2.C
new file mode 100644
index 00000000000..66423215a92
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/incomplete2.C
@@ -0,0 +1,7 @@
+// Build don't link:
+
+struct A {
+  int foo(A a) { return a.bar(); }
+  int bar();
+  int n;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/init.C b/gcc/testsuite/g++.old-deja/g++.jason/init.C
new file mode 100644
index 00000000000..032d172e160
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/init.C
@@ -0,0 +1,7 @@
+// Bug: g++ uses an empty initializer list for its own devious purpose
+// internally, and gets confused if it shows up in the input.
+// Build don't link:
+
+struct A { int i; };
+
+A a = { };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/init2.C b/gcc/testsuite/g++.old-deja/g++.jason/init2.C
new file mode 100644
index 00000000000..dcee91835dc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/init2.C
@@ -0,0 +1,9 @@
+// PRMS Id: 5126
+
+extern int i, j;
+static const int foo [] = { i, j };
+int i = 5, j = 42;
+main()
+{
+  return foo[1] != 42;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/init3.C b/gcc/testsuite/g++.old-deja/g++.jason/init3.C
new file mode 100644
index 00000000000..bb3d0d8cf10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/init3.C
@@ -0,0 +1,42 @@
+// PRMS Id: 5652
+// Bug: strings does not get initialized.
+
+extern "C" void * memcpy (void *, const void *, __SIZE_TYPE__);
+extern "C" int strcmp (const char *, const char *);
+
+class My_string {
+   char *str;
+   int len;
+public:
+   My_string(const char* string);
+   My_string(const My_string &);
+   ~My_string() { delete str; }
+   char* char_p() { return str; }
+};
+
+const My_string strings[4] = {
+   "first string",
+   "second string",
+   "third string",
+   "fourth string"
+};
+
+My_string::My_string(const char* string)
+{
+   len = strlen(string) + 1;
+   str = new char[len];
+   memcpy(str, string, len);
+}
+
+My_string::My_string(const My_string &string)
+{
+   len = string.len;
+   str = new char[len];
+   memcpy(str, string.str, len);
+}
+
+main()
+{
+   My_string str1 = strings[0];
+   return strcmp ("first string", str1.char_p ()) != 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/init4.C b/gcc/testsuite/g++.old-deja/g++.jason/init4.C
new file mode 100644
index 00000000000..aa9417c642f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/init4.C
@@ -0,0 +1,3 @@
+struct A { int i; };
+
+A a = {{{1}}};			// ERROR - causes abort
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/inline.C b/gcc/testsuite/g++.old-deja/g++.jason/inline.C
new file mode 100644
index 00000000000..ac140ab6744
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/inline.C
@@ -0,0 +1,21 @@
+// PRMS Id: 4341
+// Bug: Instantiating a template in the middle of processing the functions
+// from another template screws up lineno/input_filename.
+
+#pragma implementation "C.h"
+#line 1 "A.h"
+#pragma interface
+template <class T> class A {};
+#line 1 "C.h"
+#pragma interface
+template <class T> class C
+{
+public:
+  C() { A<T> *ap; }
+  ~C() { }
+};
+#line 18 "inline.C"
+main()
+{
+  C<int> c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/inline2.C b/gcc/testsuite/g++.old-deja/g++.jason/inline2.C
new file mode 100644
index 00000000000..7dea476d373
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/inline2.C
@@ -0,0 +1,12 @@
+// Bug: the lang-specific bits of the decl for g aren't being copied when
+// inlining.
+// Special g++ Options: -O
+// Build don't link:
+
+inline void f () {
+  void g ();
+}
+
+void h() {
+  f();				// causes compiler segfault - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/jump.C b/gcc/testsuite/g++.old-deja/g++.jason/jump.C
new file mode 100644
index 00000000000..754e7006c36
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/jump.C
@@ -0,0 +1,14 @@
+// PRMS Id: 6036
+
+extern int a;
+
+main() {
+  switch (a) {
+  case 1:
+    int v2 = 3;			// ERROR - referenced below
+  case 2:			// ERROR - jumping past initializer
+    if (v2 == 7)
+      ;
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lex1.C b/gcc/testsuite/g++.old-deja/g++.jason/lex1.C
new file mode 100644
index 00000000000..69fb0b7bbea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lex1.C
@@ -0,0 +1,6 @@
+main()
+{
+  char c = '\351';
+  if (c != '\351')
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lineno.C b/gcc/testsuite/g++.old-deja/g++.jason/lineno.C
new file mode 100644
index 00000000000..6878f75b61a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lineno.C
@@ -0,0 +1,6 @@
+// Bug; g++ binds a function definition to the line number of a later decl.
+// Build don't link:
+
+void foo () { }			// ERROR - redeclared
+void foo ();			// gets bogus error - invalid binding
+void foo () { }			// ERROR - redeclared
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lineno2.C b/gcc/testsuite/g++.old-deja/g++.jason/lineno2.C
new file mode 100644
index 00000000000..6c278036b9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lineno2.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed error-reporting
+// Special g++ Options: 
+// Bug: # line directive gets ignored immediately after text.
+template <class T> class A
+{
+public:
+# 200 "lineno2.C"
+};
+
+main()
+{
+   undef1(); // ERROR - , LINE 204
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lineno3.C b/gcc/testsuite/g++.old-deja/g++.jason/lineno3.C
new file mode 100644
index 00000000000..f2688635437
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lineno3.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: 
+// GROUPS passed error-reporting
+// potential bug: # line directive does not get reproduced in template
+// expansion
+template <class T> class A
+{
+public:
+# 200 "lineno3.C"
+      int foo () { undef1(); } // ERROR - , LINE 200
+};
+
+template class A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lineno4.C b/gcc/testsuite/g++.old-deja/g++.jason/lineno4.C
new file mode 100644
index 00000000000..a570edf313c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lineno4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: 
+// GROUPS passed error-reporting
+// Bug: # line directive in template definition interferes with growing obstack
+template <class T> class A
+{
+public:
+
+# 200 "lineno4.C"
+      int foo () { undef1(); } // ERROR - , LINE 200
+};
+
+template class A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lineno5.C b/gcc/testsuite/g++.old-deja/g++.jason/lineno5.C
new file mode 100644
index 00000000000..f15aef05fce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lineno5.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed error-reporting
+// Bug: incomplete instantiation messes with lineno
+template <class T> class A;
+
+main()
+{
+  A<int> *p;
+  undef1();// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/local.C b/gcc/testsuite/g++.old-deja/g++.jason/local.C
new file mode 100644
index 00000000000..6159db0c613
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/local.C
@@ -0,0 +1,20 @@
+// General testcase for local classes.
+
+int x;
+void f ()
+{
+  static int s;
+  int x;			// ERROR - referenced below
+  extern int q();
+
+  struct local {
+    int g() { return x; }	// ERROR - automatic variable
+    int h() { return s; }	// gets bogus error - local class
+    int k() { return ::x; }	// OK
+    int l() { return q(); }	// OK
+    int m();			// OK - not defined
+    static int foo;		// ERROR - static data member of local class
+  };
+}
+
+local* p = 0;			// ERROR - no such type in scope
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lookup.C b/gcc/testsuite/g++.old-deja/g++.jason/lookup.C
new file mode 100644
index 00000000000..c6c44c373d9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lookup.C
@@ -0,0 +1,30 @@
+// PRMS Id: 4357
+// Bug: g++ forgets to clear out push/popclass cache stuff when instantiating
+// templates.
+// Build don't link:
+
+template <class T> class ccHandle { };
+
+class cc_GStack
+{
+  static cc_GStack* freeList;
+};
+
+// OK if ccGStack is not derived from ccHandle<something>
+class ccGStack : public ccHandle<int> { };
+
+struct S { };
+
+S* freeList;	  
+
+class X
+{
+public:
+    void foo();
+};
+
+void X::foo()
+{
+  S m;
+  freeList = &m;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lookup2.C b/gcc/testsuite/g++.old-deja/g++.jason/lookup2.C
new file mode 100644
index 00000000000..e44b1dcb057
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lookup2.C
@@ -0,0 +1,13 @@
+// Build don't link:
+
+struct A {
+  struct B {
+    B ();
+  };
+};
+void f (A::B);
+void g ()
+{
+  A::B b;
+  f (b);	  // gets bogus error - can't find nested constructor
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lookup3.C b/gcc/testsuite/g++.old-deja/g++.jason/lookup3.C
new file mode 100644
index 00000000000..7be731ef0f5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lookup3.C
@@ -0,0 +1,15 @@
+// [class.ambig]: A single function, object, type, or enumerator may be
+// reached through more than one path through the DAG of base classes.  This
+// is not an ambiguity.
+// Build don't link:
+
+struct A  {
+  typedef long T;
+};
+
+struct B : public A { };
+struct C : public A { };
+
+struct D : public C , public B {
+  void f (T&);			// gets bogus error - ambiguous lookup
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/loverload.C b/gcc/testsuite/g++.old-deja/g++.jason/loverload.C
new file mode 100644
index 00000000000..2d1a9b36ae6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/loverload.C
@@ -0,0 +1,11 @@
+// Bug: g++ can't deal with multi-language overloading.
+// Build don't link:
+
+extern void foo (int, int);
+extern "C" void foo (int);
+
+void bar ()
+{
+  foo (1);
+  foo (1, 2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/loverload3.C b/gcc/testsuite/g++.old-deja/g++.jason/loverload3.C
new file mode 100644
index 00000000000..c9cc3bfbe57
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/loverload3.C
@@ -0,0 +1,12 @@
+// PRMS Id: 2010
+// Bug: g++ doesn't deal with overloads involving C-language fns properly.
+// Build don't link:
+
+extern "C" double pow (double, double);
+inline double pow (double d, int e) { return pow (d, (double) e); }
+
+void foo () 
+{
+  pow (1.0, 1);
+  pow (1.0, 1.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/loverload4.C b/gcc/testsuite/g++.old-deja/g++.jason/loverload4.C
new file mode 100644
index 00000000000..c689bf5169d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/loverload4.C
@@ -0,0 +1,8 @@
+// Bug: g++ dies on this input.
+// Build don't link:
+
+inline char abs (char x) { return 0; }
+
+extern "C" {
+  inline int abs (int x) { return 1; }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lvalue.C b/gcc/testsuite/g++.old-deja/g++.jason/lvalue.C
new file mode 100644
index 00000000000..c85e6fe5f28
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lvalue.C
@@ -0,0 +1,22 @@
+// Bug: Scoped method calls don't propagate the constness of `this'.
+// PRMS Id: 4181 (second testcase)
+// Build don't link:
+
+class D;
+
+class Bptr
+{
+public:
+  Bptr& operator=(D*);                          
+  const Bptr& operator=(const D*) const;        
+};
+
+class Dptr : public Bptr
+{
+public:
+  const Dptr& operator=(const D* rep) const 
+  {
+    Bptr::operator=(rep);
+    return *this;
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lvalue2.C b/gcc/testsuite/g++.old-deja/g++.jason/lvalue2.C
new file mode 100644
index 00000000000..2fba73c9c87
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lvalue2.C
@@ -0,0 +1,20 @@
+// PRMS Id: 4892
+// Bug: COND_EXPRs, MODIFY_EXPRs and COMPOUND_EXPRs aren't properly recognized
+// as lvalues.
+// Build don't link:
+
+extern int foo;
+int& f (int& a, int& b)
+{
+  return (foo ? a : b);		// gets bogus error - 
+}
+
+int& g (int& a)
+{
+  return (a = 0);		// gets bogus error - 
+}
+
+int& h (int& a, int& b)
+{
+  return (a = 1, b);		// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lvalue3.C b/gcc/testsuite/g++.old-deja/g++.jason/lvalue3.C
new file mode 100644
index 00000000000..a3edaac6557
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lvalue3.C
@@ -0,0 +1,9 @@
+// Bug: C++ semantics for assignment don't match the backend semantics for
+// MODIFY_EXPR.
+// Build don't link:
+
+void
+foo (int j)
+{
+  (j = 1)++;			// causes compiler segfault
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/lvalue4.C b/gcc/testsuite/g++.old-deja/g++.jason/lvalue4.C
new file mode 100644
index 00000000000..f308213bcc4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/lvalue4.C
@@ -0,0 +1,6 @@
+main() {
+  int i = 2;
+  int *pi = &(++i);
+
+  return i != 3;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/mangle1.C b/gcc/testsuite/g++.old-deja/g++.jason/mangle1.C
new file mode 100644
index 00000000000..59b83b9c361
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/mangle1.C
@@ -0,0 +1,23 @@
+// Bug: numeric_outputed_need_bar is not cleared properly, adding random '_'s
+// to mangled names.
+
+// Build don't link:
+
+template <int seed_length>
+class rand1
+{
+public:
+    rand1 ();
+};
+
+class codes
+{
+public:
+    rand1<32> * randgen;
+    codes (int ptr);
+
+};
+
+codes::codes (int ptr)
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/mangle2.C b/gcc/testsuite/g++.old-deja/g++.jason/mangle2.C
new file mode 100644
index 00000000000..b1876b71249
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/mangle2.C
@@ -0,0 +1,23 @@
+// I guess this was broken once.
+// Build don't link:
+
+template <class C, int D> class X { };
+typedef X<int, 0> T;
+
+class Y
+{
+  public:
+    ~Y();
+};
+
+class Z
+{
+  public:
+    void f(T**);
+};
+
+void Z::f(T** t)
+{ }
+
+Y::~Y()
+{ }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/mangle3.C b/gcc/testsuite/g++.old-deja/g++.jason/mangle3.C
new file mode 100644
index 00000000000..5a82107bfef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/mangle3.C
@@ -0,0 +1,19 @@
+// PRMS Id: 7563
+// Bug: declaration at function scope causes mismangling.
+
+int main()
+{
+  char ArrA[10][10][20][30],
+       ArrB[10][10][20][30];
+
+  void HitMe(char [10][10][20][30], char [10][10][20][30]);
+
+  HitMe(ArrA, ArrB);
+
+  return 0;
+}
+
+void HitMe(char A[10][10][20][30], char B[10][10][20][30])
+{
+  return;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/member.C b/gcc/testsuite/g++.old-deja/g++.jason/member.C
new file mode 100644
index 00000000000..3518811967c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/member.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed member-pointers error-reporting
+struct Y
+{
+  struct X
+    {
+      int A;
+      int Y::X::* foo () { undef1(1); return &Y::X::A; }// ERROR - foo().*
+      int bar () { return A; }
+    };
+};
+
+int Y::X::* foo ()
+{
+  undef2(1);// ERROR - foo().*
+  return &Y::X::A;
+}
+
+int Y::X::* (* foo2 ())()
+{
+  undef3(1);// ERROR - foo().*
+  return foo;
+}
+
+int (Y::X::* bar2 ()) ()
+{
+  undef4(1);// ERROR - foo\(\).*
+  return Y::X::bar;// ERROR - foo\(\).*
+}
+
+int Y::X::* (Y::X::* foo3 ())()
+{
+  undef5(1);// ERROR - foo().*
+  return Y::X::foo;// ERROR - foo().*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/member1.C b/gcc/testsuite/g++.old-deja/g++.jason/member1.C
new file mode 100644
index 00000000000..c25a1904a4a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/member1.C
@@ -0,0 +1,4 @@
+// Build don't link:
+
+struct S { int S; } object;
+struct S function () { return object; }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/method.C b/gcc/testsuite/g++.old-deja/g++.jason/method.C
new file mode 100644
index 00000000000..e9496b82861
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/method.C
@@ -0,0 +1,12 @@
+// Bug: pointer to pointer is treated as plain pointer.
+// PRMS Id: 1767
+// Build don't link:
+
+class Foo {
+public:
+	void method();
+};
+
+void func(Foo ** ppFoo) {
+	ppFoo->method();	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/mi.C b/gcc/testsuite/g++.old-deja/g++.jason/mi.C
new file mode 100644
index 00000000000..eaf59b20233
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/mi.C
@@ -0,0 +1,16 @@
+int status;
+
+struct A { virtual void foo () { status = 1; } };
+struct B { };
+struct C : public A, public B { };
+struct D { virtual void baz () { } };
+struct E : public D, public C { void foo () { status = 0; } };
+
+main ()
+{
+  E* ep = new E;
+
+  ep->foo();
+
+  return status;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/mutable1.C b/gcc/testsuite/g++.old-deja/g++.jason/mutable1.C
new file mode 100644
index 00000000000..9298d2ef882
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/mutable1.C
@@ -0,0 +1,11 @@
+struct X
+{
+  X () { }
+  mutable int x;
+};
+
+main ()
+{
+  const X x;
+  x.x = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested1.C b/gcc/testsuite/g++.old-deja/g++.jason/nested1.C
new file mode 100644
index 00000000000..4405f3d0649
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested1.C
@@ -0,0 +1,12 @@
+// Bug: g++ can't deal with function-local classes that talk about themselves.
+// Build don't link:
+
+void foo() {
+  class Wrapper {
+  public:
+    void F (void * Wrapperptr)
+    {
+      Wrapper * wrapptr = (  Wrapper  *) Wrapperptr; // gets bogus error 
+    }
+  };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested2.C b/gcc/testsuite/g++.old-deja/g++.jason/nested2.C
new file mode 100644
index 00000000000..24020a2dd24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested2.C
@@ -0,0 +1,26 @@
+// PRMS Id: 3764 (c/h)
+// Bug: g++ gets into an infinite loop trying to find the top-level context
+// Build don't link:
+
+class Menu;
+class MenuItem;
+
+class MenuAction {
+public:
+  virtual void execute (Menu& menu, MenuItem& menuItem) = 0;
+protected:
+  MenuAction () {}
+}; 
+
+class Test {
+  class MenuCBA : public MenuAction {
+  public:
+    typedef void (Test::* MenuCBA_Member) (Menu& menu, MenuItem& menuItem);
+    MenuCBA (Test& instance, MenuCBA_Member member)
+      : _instance(&instance), _member(member) {	}
+    void execute (Menu& menu, MenuItem& menuItem);
+  private:
+    MenuCBA_Member _member;
+    Test* _instance;
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested4.C b/gcc/testsuite/g++.old-deja/g++.jason/nested4.C
new file mode 100644
index 00000000000..cd5a8393eb0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested4.C
@@ -0,0 +1,17 @@
+// From: quipu@ulrik.uio.no
+// Subject: extern "C" nested class
+// Date: Fri, 13 Aug 1993 15:33:53 +0200
+// Build don't link:
+
+extern "C" {
+  struct A {
+    struct B { int j; } *x;
+  };
+}
+
+void
+foo () {
+  A a;
+  struct A::B *b;
+  b = a.x;	// gets bogus error - type `B' is not a base type for type `B'
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested5.C b/gcc/testsuite/g++.old-deja/g++.jason/nested5.C
new file mode 100644
index 00000000000..1b0e35c9b91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested5.C
@@ -0,0 +1,11 @@
+// Build don't link:
+
+struct A {
+  struct B { };
+};
+
+struct C : public A {
+  struct D
+    : public B			// gets bogus error - can't find B
+    { };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested6.C b/gcc/testsuite/g++.old-deja/g++.jason/nested6.C
new file mode 100644
index 00000000000..b98c643d3fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested6.C
@@ -0,0 +1,5 @@
+// Build don't link:
+union A {
+ struct B { };
+ A::B b;			// gets bogus error
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested7.C b/gcc/testsuite/g++.old-deja/g++.jason/nested7.C
new file mode 100644
index 00000000000..43cce238546
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested7.C
@@ -0,0 +1,16 @@
+// Testcase for defining nested types separately.
+// Build don't link:
+
+class remote
+{
+  class remote_file;
+};
+
+class remote::remote_file
+{
+public:
+  ~remote_file();
+};
+
+remote::remote_file::~remote_file()
+{}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/nested8.C b/gcc/testsuite/g++.old-deja/g++.jason/nested8.C
new file mode 100644
index 00000000000..ff2d659a3fc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/nested8.C
@@ -0,0 +1,8 @@
+// Build don't link:
+
+struct A { };
+struct B: public A {
+  struct C {
+friend struct B;		// gets bogus error - base clause w/o members
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/net.C b/gcc/testsuite/g++.old-deja/g++.jason/net.C
new file mode 100644
index 00000000000..be8b962ad80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/net.C
@@ -0,0 +1,10 @@
+// Bug: g++ doesn't instantiate function templates in instantiate_type.
+// Build don't link:
+
+template <class T> void fn (T t) { }
+template <class T> struct A {
+  void (*p)(T);
+  A() { p = fn; }
+};
+
+A<int> a;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/net2.C b/gcc/testsuite/g++.old-deja/g++.jason/net2.C
new file mode 100644
index 00000000000..8738eade438
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/net2.C
@@ -0,0 +1,37 @@
+// Test of various ?: problems.
+
+class D
+{
+public:
+  void a();
+  void b();
+  D(int i):x(i) {}
+private:
+  int x;
+};
+
+void D::a() {++x;}
+void D::b() {--x;}
+
+  
+int aa=1, bb=0;
+
+int fa() {return 0;}
+int fb() {return 2;}
+
+int main(int argc, char* argv[])
+{
+  typedef int* pi;
+  int* p = (argc == 1)? &aa: &bb;
+  *p = 0;
+
+  typedef int (*ifptr)();
+  ifptr fp = (argc == 1)? fa: fb;
+  aa = fp();
+  
+  D d(0);
+  typedef void (D::*dmem)();
+  dmem mfp = (argc == 1)? &D::a: &D::b;
+  (d.*mfp)();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/new.C b/gcc/testsuite/g++.old-deja/g++.jason/new.C
new file mode 100644
index 00000000000..1a71ea5f3c5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/new.C
@@ -0,0 +1,25 @@
+// Bug: new doesn't make sure that the count is an integral value.
+
+typedef __SIZE_TYPE__ size_t;
+extern "C" int printf (const char *, ...);
+extern "C" void *malloc (size_t);
+size_t s;
+
+void * operator new (size_t siz) {
+  if (s == 0)
+    s = siz;
+  else
+    s = (s != siz);
+  return malloc (siz);
+}
+
+main()
+{
+  s = 0;
+
+  float f = 3;
+  int* b1 = new int[(int)f];
+  int* b2 = new int[f];
+
+  return s;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/new2.C b/gcc/testsuite/g++.old-deja/g++.jason/new2.C
new file mode 100644
index 00000000000..96ac5a3ce0c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/new2.C
@@ -0,0 +1,12 @@
+// PRMS Id: 6267
+// Special g++ Options: -fthis-is-variable
+
+struct A {
+  int i;
+  A() { i = 2; }
+};
+ 
+main()
+{
+  A *p = new A ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/new3.C b/gcc/testsuite/g++.old-deja/g++.jason/new3.C
new file mode 100644
index 00000000000..ede3a00e9dd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/new3.C
@@ -0,0 +1,23 @@
+// PRMS Id: 6037
+// Special g++ Options: -fcheck-new
+
+extern "C" void * malloc (__SIZE_TYPE__);
+
+struct A {
+  int i;
+  A () { i = 2; }
+};
+
+int ena = 0;
+void * operator new (__SIZE_TYPE__ s)
+{
+  if (ena)
+    return 0;
+  return malloc (s);
+}
+
+main ()
+{
+  ena = 1;
+  A* ap = new A;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/new4.C b/gcc/testsuite/g++.old-deja/g++.jason/new4.C
new file mode 100644
index 00000000000..ba8af272cb5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/new4.C
@@ -0,0 +1,22 @@
+// Special g++ Options: -fcheck-new
+
+struct A {
+  A(): i(42) { }
+  A(int j): i(j) { }
+  int i;
+};
+
+A* ap = new A (1);
+A* ap2 = new A[3];
+
+main ()
+{
+  if (ap->i != 1 || ap2[0].i != 42 || ap2[1].i != 42 || ap2[2].i != 42)
+    return 1;
+
+  A* ap = new A (1);
+  A* ap2 = new A[3];
+
+  if (ap->i != 1 || ap2[0].i != 42 || ap2[1].i != 42 || ap2[2].i != 42)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/new5.C b/gcc/testsuite/g++.old-deja/g++.jason/new5.C
new file mode 100644
index 00000000000..70f5ec5d475
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/new5.C
@@ -0,0 +1,5 @@
+main ()
+{
+  const int *p = new const int (0);
+  delete p;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/offset1.C b/gcc/testsuite/g++.old-deja/g++.jason/offset1.C
new file mode 100644
index 00000000000..d4fd38b70dc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/offset1.C
@@ -0,0 +1,17 @@
+// PRMS Id: 5070 (testcase 1)
+// Build don't link:
+
+struct foo {
+  foo(int x = 0) {};
+  int IsAlive(void) { return 1; }
+};
+
+struct xx {
+  int IsOk(int X);
+  foo a;
+};
+
+int xx::IsOk(int X)
+{
+  return ((xx::a).IsAlive());	// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/offset2.C b/gcc/testsuite/g++.old-deja/g++.jason/offset2.C
new file mode 100644
index 00000000000..787e3f12081
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/offset2.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5070 (testcase 2)
+
+int status = 1;
+
+struct foo {
+  foo& operator= (const foo&) { status = 0; }
+};
+
+struct xx {
+  foo a;
+};
+
+struct yy : public xx {
+  yy(foo& a) { xx::a = a; }
+};
+
+main()
+{
+  foo f;
+  yy y (f);
+
+  return status;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/offset3.C b/gcc/testsuite/g++.old-deja/g++.jason/offset3.C
new file mode 100644
index 00000000000..d980ba1fcd0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/offset3.C
@@ -0,0 +1,22 @@
+// PRMS Id: 5070 (bug 2)
+// Build don't link:
+
+struct A {
+  void f ();
+};
+
+struct Ptr {
+  A* operator->();
+};
+
+struct B {
+  Ptr p;
+};
+
+struct C: public B {
+  void g ();
+};
+
+void C::g() {
+  B::p->f();			// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/offset4.C b/gcc/testsuite/g++.old-deja/g++.jason/offset4.C
new file mode 100644
index 00000000000..2a5049105a4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/offset4.C
@@ -0,0 +1,15 @@
+// Bug: g++ complains about the use of A::p below.
+// Build don't link:
+
+struct A {
+  void *p;
+};
+
+struct B: public A {
+  int f ()
+    {
+      if (A::p)
+	return 1;
+      return 0;
+    }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq.C
new file mode 100644
index 00000000000..ac099a4a667
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq.C
@@ -0,0 +1,39 @@
+// PRMS Id: 4297 (related to 3525)
+// Bug: Generating default op= didn't set TYPE_HAS_ASSIGNMENT, so it wasn't
+// found.
+
+extern "C" int printf (char *, ...);
+
+class Y 
+{
+public:
+    Y(char*) {}
+    Y& operator = (const Y&) {}
+};
+    
+
+class X
+{
+public:
+    X(int v, char* m) : _v(v), _m (m) {}
+    X () : _v(0), _m("Unknown") {}
+    // Defining our own op= here makes things work correctly.
+
+private:
+    int _v;
+    int _m4;
+    // Adding more members here increases the count on u.
+    Y _m;
+};
+
+const X sPassed (1, "Passed"), sFailed (-1, "Failed");
+
+int main (int, char**)
+{
+    X result;
+    int u = 0;
+    result = (u++ ? sPassed : sFailed);
+    if (u == 1)
+      return 0;
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq2.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq2.C
new file mode 100644
index 00000000000..9e91ab3ae0f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq2.C
@@ -0,0 +1,26 @@
+// Bug: default operator= is not being generated properly.
+// PRMS Id: 3525
+// Build don't link:
+
+struct ccUnwind 
+{
+    ccUnwind& operator = (const ccUnwind&);
+};
+
+struct ccEllipseUnit
+{ 
+    ccEllipseUnit () {}
+};
+
+struct ccEllipse : ccUnwind  
+{   
+    ccEllipse ();
+    ccEllipse (const ccEllipseUnit&);
+
+};
+
+void foo ()
+{
+    ccEllipse e;
+    e = ccEllipseUnit();	// gets bogus error - assignment not defined
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq3.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq3.C
new file mode 100644
index 00000000000..e290f7a21ba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq3.C
@@ -0,0 +1,15 @@
+// Bug: g++ generates code for assignment in invalid situations.
+// Build don't link:
+
+class X {
+  int& a;
+public:
+  X(int& i): a(i) { };
+};
+
+void foo ()
+{
+  int one=1, two=2;
+  X a(one), b(two);
+  a = b;			// ERROR - no assignment semantics defined
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq4.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq4.C
new file mode 100644
index 00000000000..d993d83ab9d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq4.C
@@ -0,0 +1,8 @@
+// PRMS Id: 4329
+// Bug: default op= gives an warning about casting away volatile.
+// Build don't link:
+
+struct foo
+{
+    volatile int bar[2];
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq5.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq5.C
new file mode 100644
index 00000000000..c591830515b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq5.C
@@ -0,0 +1,26 @@
+// Testcase for tricky synthesized op= in complex inheritance situation.
+// See discussion in g++int.texi.
+
+// execution test fails - 
+
+int count = 0;
+extern "C" int printf (const char *, ...);
+
+class A {
+ public:
+  A& operator = (const A&) { count++; return *this; }
+};
+
+class B: virtual private A { };
+class C: virtual public A { };
+class D: public B, public C { };
+
+int main()
+{
+  D a, b;
+  a = b;
+  printf ("%d\n",count);
+  if (count != 1)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opeq6.C b/gcc/testsuite/g++.old-deja/g++.jason/opeq6.C
new file mode 100644
index 00000000000..62be499c56d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opeq6.C
@@ -0,0 +1,24 @@
+// Testcase for wrongful generation of operator =.
+// Build don't link:
+
+class ivResource {
+public:
+  ivResource ();
+private:
+  ivResource & operator =(const ivResource &);
+};
+
+class ivButtonState : virtual public ivResource {
+public:
+  void operator=(ivButtonState &);
+};
+
+class ivPrintBS : public ivButtonState {
+};
+
+void f ()
+{
+  ivPrintBS a, b;
+  a = b;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/operator.C b/gcc/testsuite/g++.old-deja/g++.jason/operator.C
new file mode 100644
index 00000000000..a81a42385f8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/operator.C
@@ -0,0 +1,31 @@
+// General test for operator overloading permissiveness.
+// Build don't link:
+// Special g++ Options:
+
+typedef unsigned long size_t;
+
+struct A {
+  int operator?:(int a, int b);	   // WARNING - 
+  static int operator()(int a);	   // ERROR - must be nonstatic
+  static int operator+(A,A);	   // ERROR - must be nonstatic
+  int operator+(int a, int b = 1); // ERROR - two errors on this line
+  int operator++(char);		   // ERROR - must take 'int'
+  void operator delete (void *);   // ERROR - overloaded
+  void operator delete (void *, unsigned long);	// ERROR - overloaded
+};
+
+struct B {
+  void * operator new (size_t, void *);
+  int operator++(int = 0);
+  int operator+ (int);
+  void operator()();
+  char * operator[](int);
+  B * operator->();
+};
+
+int operator-(int a, int b);	// ERROR - no class argument
+
+void * operator new (A a);	// ERROR - invalid first argument
+void operator delete (A a);	// ERROR - ditto
+
+char * operator char * (int);	// ERROR - return value, nonmember
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/operator2.C b/gcc/testsuite/g++.old-deja/g++.jason/operator2.C
new file mode 100644
index 00000000000..477616086a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/operator2.C
@@ -0,0 +1,14 @@
+// PRMS Id: 6018
+// Build don't link:
+
+class string {
+    char *p;
+public:
+    string(const char* s) ;// { p == s; }
+    operator const char*() ;// { return s; }
+};
+ 
+void f4(string& s)
+{
+        *s;     // implies "s.operator const char*()"
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/opover.C b/gcc/testsuite/g++.old-deja/g++.jason/opover.C
new file mode 100644
index 00000000000..1fa90b68f25
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/opover.C
@@ -0,0 +1,15 @@
+// Bug: g++ prefers a non-matching operator== over user-defined conversions
+// and a default operator==.
+// Build don't link:
+
+struct A {
+  operator int ();
+};
+
+struct B {
+  friend operator== (B, int);
+};
+
+int foo (A& a) {
+  return a == 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/optimize.C b/gcc/testsuite/g++.old-deja/g++.jason/optimize.C
new file mode 100644
index 00000000000..1f554e21935
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/optimize.C
@@ -0,0 +1,42 @@
+// Bug: g++ claims that control can fall off the end of these functions.
+// PRMS Id: 4943
+// Special g++ Options: -O -pedantic-errors
+// Build don't link:
+
+struct A {
+  A();
+  A(const A&);
+  A& operator= (const A&);
+  ~A();
+};
+
+int f ()
+{
+  A a[2];
+  return 1;
+}				// gets bogus error - jump_optimize
+
+int g ()
+{
+  A a;
+  return 1;
+}				// gets bogus error - jump_optimize
+
+struct B {
+  B();
+  B(const B&);
+  B& operator= (const B&);
+  ~B();
+};
+
+inline B::~B()
+{
+  int i = 2;
+  while (i--) ;
+}
+
+int h ()
+{
+  B b;
+  return 1;
+}				// gets bogus error - jump_optimize
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/optimize2.C b/gcc/testsuite/g++.old-deja/g++.jason/optimize2.C
new file mode 100644
index 00000000000..0d4e17752c7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/optimize2.C
@@ -0,0 +1,19 @@
+// Used to crash on the alpha with optimization.
+// Special g++ Options: -w
+
+struct Fix {
+  unsigned short l;
+};
+
+static inline void f (int len)
+{
+  if (len > 65535)
+    abort ();
+}
+
+struct Fix a = { 33 };
+
+main()
+{
+  f (a.l);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload.C b/gcc/testsuite/g++.old-deja/g++.jason/overload.C
new file mode 100644
index 00000000000..7d7aeee05b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed overloading
+enum bar {};
+
+void operator+ (int, int);// ERROR - .*
+void operator+ (bar&, int);
+
+template <class T> void operator+ (int b, T& t) { return b; }
+void operator+ (int, bar&);
+
+template <class T> class foo
+{
+public:
+  friend void operator+ (int, T&);
+};
+
+class baz;
+
+class foo<int>;
+class foo<baz>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload1.C b/gcc/testsuite/g++.old-deja/g++.jason/overload1.C
new file mode 100644
index 00000000000..e29a7c16b91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload1.C
@@ -0,0 +1,12 @@
+// Bug: g++ thinks there is a conversion from void * to B *.
+// Build don't link:
+
+struct A {
+  operator void* ();
+};
+
+struct B: public A { };
+
+void bar (A& a) {
+  B* bp = (B*)a;		// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload10.C b/gcc/testsuite/g++.old-deja/g++.jason/overload10.C
new file mode 100644
index 00000000000..a2402fcd63e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload10.C
@@ -0,0 +1,21 @@
+// PRMS Id: 4257 (second bug)
+// Bug: g++ fails to recognize multiple previous instantiations of a function
+// template.
+// Build don't link:
+
+template <class T>
+class A {
+  int i;
+
+  friend int foo (A<T>&);
+};
+
+template <class T> int foo (A<T>& a) { return a.i; }
+
+A<int> a;
+A<char> dummy;
+
+void bar ()
+{
+  foo (a);			// gets bogus error - two foo(A<int>&)'s
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload11.C b/gcc/testsuite/g++.old-deja/g++.jason/overload11.C
new file mode 100644
index 00000000000..e8c043f0545
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload11.C
@@ -0,0 +1,17 @@
+// PRMS Id: 4697
+// Bug: g++ calls the non-const method for a const object.
+
+class A {
+public:
+  void foo(int &i) const { i = 0; }
+  void foo(int &i) { i = 1; }
+};
+
+main()
+{
+  A a;
+  const A& b = a;
+  int i = 2;
+  b.foo (i);
+  return i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload12.C b/gcc/testsuite/g++.old-deja/g++.jason/overload12.C
new file mode 100644
index 00000000000..dc336c5caed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload12.C
@@ -0,0 +1,15 @@
+// PRMS Id: 4066
+// Bug: g++ doesn't notice the const on reference returns.
+
+struct B {
+  int foo() { return 1; }
+  int foo() const { return 0; }
+};
+
+B b_;
+const B &b () { return b_; }
+
+main()
+{
+  return b().foo();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload13.C b/gcc/testsuite/g++.old-deja/g++.jason/overload13.C
new file mode 100644
index 00000000000..602dc2b4e1d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload13.C
@@ -0,0 +1,27 @@
+// Bug: g++ screws up derived->base conversions when calling a global function
+// in the presence of matching members in the base.  Whew.
+
+struct xios {
+  virtual ~xios() { }
+};
+
+struct xistream: virtual public xios {
+  int j;
+  void operator>>(char&);
+};
+
+struct xfstreambase: virtual public xios { };
+
+struct xifstream: public xfstreambase, public xistream { };
+
+void operator>>(xistream& i, int j)
+{
+  i.j = 0;
+}
+
+main() {
+  int i;
+  xifstream ifs;
+  
+  ifs >> i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload14.C b/gcc/testsuite/g++.old-deja/g++.jason/overload14.C
new file mode 100644
index 00000000000..6a5d3dc2d5a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload14.C
@@ -0,0 +1,10 @@
+// Bug: g++ fails to recognize that the template matches the target type.
+// Build don't link:
+
+template <class T> void foo (T *, int);
+
+struct A;
+void bar ()
+{
+  void (*p)(A *, int) = &foo;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload15.C b/gcc/testsuite/g++.old-deja/g++.jason/overload15.C
new file mode 100644
index 00000000000..779de722c41
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload15.C
@@ -0,0 +1,10 @@
+// Bug: g++ thinks that int->long is a promotion.
+// Build don't link:
+
+long f (long, long);
+double f (double, double);
+
+void g (double d)
+{
+  f (d, 0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload16.C b/gcc/testsuite/g++.old-deja/g++.jason/overload16.C
new file mode 100644
index 00000000000..e1b7f3f8a1f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload16.C
@@ -0,0 +1,6 @@
+void f (int);			// ERROR - 
+void f (long);			// ERROR - 
+main()
+{
+  f (1 & 0xffffff00UL);		// ERROR - ambiguous
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload17.C b/gcc/testsuite/g++.old-deja/g++.jason/overload17.C
new file mode 100644
index 00000000000..65738482844
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload17.C
@@ -0,0 +1,20 @@
+// Bug: g++ fails to prefer UDC's alone to UDC's plus standard conversions.
+// Build don't link:
+
+struct B { };
+struct D: public B { };
+struct DP {
+  operator D * () const;
+  operator double () const;
+};
+
+void f (B *);
+void f (D *);
+void g (double);
+void g (float);
+
+void h (DP p)
+{
+  f (p);
+  g (p);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload18.C b/gcc/testsuite/g++.old-deja/g++.jason/overload18.C
new file mode 100644
index 00000000000..d4d9ec14b7e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload18.C
@@ -0,0 +1,6 @@
+// pushdecl gets confused by this.
+// Build don't link:
+
+void f ();
+void f (int, int);
+template <class T> T f (T) { }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload19.C b/gcc/testsuite/g++.old-deja/g++.jason/overload19.C
new file mode 100644
index 00000000000..ad5817565fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload19.C
@@ -0,0 +1,11 @@
+// PRMS Id: 4689
+// Bug: g++ doesn't notice operators overloaded on enumeral types.
+
+enum E { A=5, B=32, C=100 };
+
+E operator|(E a, E b) { return C; };
+
+int main()
+{
+  return (A|B) != C;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload2.C b/gcc/testsuite/g++.old-deja/g++.jason/overload2.C
new file mode 100644
index 00000000000..56419425383
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload2.C
@@ -0,0 +1,12 @@
+// Bug: foo and bar are considered to be overloaded (i.e. their
+//   IDENTIFIER_GLOBAL_VALUES are TREE_LISTs) even though they aren't,
+//   so ?: thinks it can't resolve the names.
+// Build don't link:
+
+void foo ();
+void bar ();
+
+void baz ()
+{
+  void (*p)() = 1 ? foo : bar;	// gets bogus error - wrongful overloading
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload20.C b/gcc/testsuite/g++.old-deja/g++.jason/overload20.C
new file mode 100644
index 00000000000..dde686c5c30
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload20.C
@@ -0,0 +1,11 @@
+// Bug: this code causes an internal compiler error 4.
+
+void f (char *);
+void f (int);
+struct A {
+  void f ();
+  void f (int);
+  void g () {
+    void (*p)(char *) = f;	// ERROR - no matching function in scope
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload21.C b/gcc/testsuite/g++.old-deja/g++.jason/overload21.C
new file mode 100644
index 00000000000..dc2f69ee908
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload21.C
@@ -0,0 +1,12 @@
+struct X {
+  void f (int = 4, char = 'r');	// ERROR - 
+  void g (int = 4, char = 'r');	// ERROR - 
+};
+
+void
+X::f (int i = 4, char x = 'r')
+{ }				// ERROR - duplicate default args
+
+void
+X::g (int i = 9, char x = 's')
+{ }				// ERROR - duplicate default args
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload22.C b/gcc/testsuite/g++.old-deja/g++.jason/overload22.C
new file mode 100644
index 00000000000..fd7276a473b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload22.C
@@ -0,0 +1,17 @@
+// PRMS Id: 4574
+// Bug: g++ prefers int to double for float& argument
+// Build don't link:
+
+inline double abs (double x) { return x;}
+inline int    abs (int i)    { return i; }
+
+float& fn(float& f)
+{
+  return f;
+}
+
+void foo()
+{
+  float f = 23.45;
+  abs(fn(f));			// gets bogus warning
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload23.C b/gcc/testsuite/g++.old-deja/g++.jason/overload23.C
new file mode 100644
index 00000000000..1cc1d0bc3fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload23.C
@@ -0,0 +1,27 @@
+// From: panisset@cae.ca (Jean-Francois Panisset)
+// Date: Mon, 6 Jun 94 13:39:25 EDT
+// Subject: Problem with operator overloading
+
+// Build don't link:
+
+class ostream {
+public:
+  ostream& operator<<(double n);
+  ostream& operator<<(float n);
+};
+
+class X
+{
+public:
+  operator long() const;
+  operator double() const;
+};
+ostream& operator<< (ostream& os, const X& x);
+
+
+main()
+{
+  X x;
+  ostream os;
+  os << x; // gets bogus error - converting to float
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload24.C b/gcc/testsuite/g++.old-deja/g++.jason/overload24.C
new file mode 100644
index 00000000000..0a12b001f78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload24.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5124
+// Bug: g++ promotes bar to int* too soon and the call to f fails.
+// Build don't link:
+
+typedef int arr[1];
+
+struct A {
+   void f(void);
+   void f(arr &);
+
+   void g(void);
+   void g(int *);
+
+   void h(void);
+};
+
+
+void A::h(void)
+{
+   arr bar;
+   f(bar);
+   g(bar);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload26.C b/gcc/testsuite/g++.old-deja/g++.jason/overload26.C
new file mode 100644
index 00000000000..872b0b206e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload26.C
@@ -0,0 +1,22 @@
+// Bug: g++ tries to build up a mangled name for its ideal match, which
+// fails for one call below.
+// Build don't link:
+
+extern const char foo[];
+extern const char baz[10];
+extern const char *fred;
+
+struct A {
+  void f(const char *);
+} *a;
+
+void bing(const char *);
+main ()
+{
+	a->f(foo);		// gets bogus error because foo's size unknown.
+	a->f(baz);
+	a->f(fred);
+	bing(fred);
+	bing(foo);
+	bing(baz);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload27.C b/gcc/testsuite/g++.old-deja/g++.jason/overload27.C
new file mode 100644
index 00000000000..3ae1a1dab5e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload27.C
@@ -0,0 +1,7 @@
+void f(const int &) { }
+void f(const float &);
+
+main()
+{
+    f(false);			// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload28.C b/gcc/testsuite/g++.old-deja/g++.jason/overload28.C
new file mode 100644
index 00000000000..e94e97872ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload28.C
@@ -0,0 +1,11 @@
+// PRMS Id: 6056
+
+struct Foo {
+  Foo()           { }		// ERROR - candidate
+  Foo(int i = 25) { }		// ERROR - candidate
+};
+
+main()
+{
+  Foo* f1 = new Foo();		// ERROR - ambiguous
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload29.C b/gcc/testsuite/g++.old-deja/g++.jason/overload29.C
new file mode 100644
index 00000000000..ecd43592b08
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload29.C
@@ -0,0 +1,16 @@
+// Bug: we get an error trying to build up our ideal candidate.
+// Build don't link:
+
+class C {
+ public:
+	C( const char * );
+};
+
+	extern	const	char	c1[];
+
+void f2( const char * );
+
+void f1() {
+	C *fntp = new C(c1);			// Line 10
+	f2( c1 );
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload3.C b/gcc/testsuite/g++.old-deja/g++.jason/overload3.C
new file mode 100644
index 00000000000..63b175e70df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload3.C
@@ -0,0 +1,12 @@
+// Bug: bar is considered to be overloaded (i.e. its
+//   IDENTIFIER_GLOBAL_VALUES are TREE_LISTs) even though it isn't,
+//   so default_conversion thinks it can't resolve the name.
+// Build don't link:
+
+void foo ();
+void bar ();
+
+void baz ()
+{
+  void (*p)() = 1 ? (void (*)()) &foo : bar;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload30.C b/gcc/testsuite/g++.old-deja/g++.jason/overload30.C
new file mode 100644
index 00000000000..24485c5851d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload30.C
@@ -0,0 +1,17 @@
+// PRMS Id: 6412
+// Build don't link:
+
+class Foo;
+
+template <class F>
+class Temp
+{
+  F  func_;
+public:
+  Temp (F f) : func_(f) {}
+};
+
+template <class T>
+T* func1 (T* t) { return t; }
+
+Temp<Foo*(*)(Foo*)> temp2(func1);
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload31.C b/gcc/testsuite/g++.old-deja/g++.jason/overload31.C
new file mode 100644
index 00000000000..e45d802033f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload31.C
@@ -0,0 +1,24 @@
+// PRMS Id: 6568
+// Bug: g++ complains about the ambiguous conversion to bool even though
+// we wouldn't end up using it anyway.
+// Build don't link:
+
+class AString
+{
+public:
+    AString (unsigned len);
+    operator char *() const;
+    operator char const *() const;
+};
+
+void
+foo(unsigned t, AString const & handle)
+{
+}
+
+void
+foo(AString const & handle, bool includeSpecials)
+{
+    unsigned t;
+    foo(t, handle);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload32.C b/gcc/testsuite/g++.old-deja/g++.jason/overload32.C
new file mode 100644
index 00000000000..95f251d6664
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload32.C
@@ -0,0 +1,19 @@
+// PRMS Id: 7128
+// Build don't link:
+
+class B {};
+
+class D : public B {};
+
+class X {
+ public:
+   operator const B & () const;
+   operator const D & () const;
+};
+	
+void f( const D & );
+
+void g( const X & x )
+{
+   f( x );
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload33.C b/gcc/testsuite/g++.old-deja/g++.jason/overload33.C
new file mode 100644
index 00000000000..8b5bb4a34ae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload33.C
@@ -0,0 +1,78 @@
+// PRMS ID: 7507
+// Build don't link:
+
+/* ------------------------------------------------------------ */
+
+class Base0
+{
+public:
+				Base0() {}
+      virtual			~Base0() {}
+};
+
+class Base1
+{
+public:
+				Base1() {}
+    virtual			~Base1() {}
+};
+
+class Derived : public Base0, public Base1
+{
+public:
+				Derived() {}
+  virtual			~Derived() {}
+};
+
+/* ------------------------------------------------------------ */
+
+class Dummy
+{
+  public:
+				Dummy(Base0 * theBase) {}
+				~Dummy() {}
+};
+
+/* ------------------------------------------------------------ */
+
+template<class T>
+class ConstSmartPtr
+{
+  T*			myItem;		// private
+
+  public:	
+			ConstSmartPtr(T const* theItem);
+
+			operator T const*() const
+				{ return myItem; }
+  protected:
+    T*			_item() const
+				{ return myItem; }
+};
+
+template<class T>
+class SmartPtr : public ConstSmartPtr<T>
+{
+  public:
+			SmartPtr(T* theItem)
+			  : ConstSmartPtr<T>(theItem) {}
+
+    T*			item() const
+				{ return _item(); }
+
+			operator T*() const
+				{ return _item(); }
+};
+
+/* ------------------------------------------------------------ */
+
+void
+function()
+{
+  SmartPtr<Derived>  myObj = new Derived();
+
+  Dummy th1(myObj);		    // Doesn't work under Cygnus
+  Dummy th2((Base0 *) myObj);	    // Doesn't work either
+}
+
+/* ------------------------------------------------------------ */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload34.C b/gcc/testsuite/g++.old-deja/g++.jason/overload34.C
new file mode 100644
index 00000000000..871c35aea93
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload34.C
@@ -0,0 +1,8 @@
+// PRMS ID: 8010
+// Build don't link:
+
+class X {
+  int & flag;
+public:
+  void f(){ flag++ ; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload35.C b/gcc/testsuite/g++.old-deja/g++.jason/overload35.C
new file mode 100644
index 00000000000..bb6e436f2dc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload35.C
@@ -0,0 +1,25 @@
+// PRMS Id: 9647
+// Build don't link:
+
+class castBug
+{
+public:
+   operator int *();
+   operator const int *() const;
+};
+
+class castBug2
+{
+public:
+   operator const int *() const;
+};
+
+void voidfn(void *);
+
+void test()
+{
+   castBug b;
+   castBug2 b2;
+   voidfn(b);			// gets bogus error
+   voidfn(b2);			// ERROR - discarding const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload4.C b/gcc/testsuite/g++.old-deja/g++.jason/overload4.C
new file mode 100644
index 00000000000..1da0ff0a454
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload4.C
@@ -0,0 +1,11 @@
+// Testcase for simple overloading resolution.
+// Build don't link:
+
+void foo (int);
+void foo (int, int);
+
+void bar ()
+{
+  foo (1);
+  foo (1, 2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload5.C b/gcc/testsuite/g++.old-deja/g++.jason/overload5.C
new file mode 100644
index 00000000000..8702bbb26ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload5.C
@@ -0,0 +1,4 @@
+// Testcase for simple overloading resolution.
+
+int foo ();			// ERROR - 
+void foo ();			// ERROR - disallowed overload
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload6.C b/gcc/testsuite/g++.old-deja/g++.jason/overload6.C
new file mode 100644
index 00000000000..3ae96428389
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload6.C
@@ -0,0 +1,15 @@
+// Bug: g++ thinks there is a default conversion from void* to B*.
+//      There isn't.
+// Build don't link:
+
+struct A {
+  operator void* ();
+};
+
+struct B { };
+
+void foo (B* bp);
+
+void bar (A& a) {
+  foo (a);			// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload7.C b/gcc/testsuite/g++.old-deja/g++.jason/overload7.C
new file mode 100644
index 00000000000..361150569c9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload7.C
@@ -0,0 +1,15 @@
+// Bug: g++ thinks there is a default conversion from A& to B*.
+//      There isn't.
+// Build don't link:
+
+struct A {
+  operator A* ();
+};
+
+struct B: public A { };
+
+void foo (B* bp);
+
+void bar (A& a) {
+  foo (a);			// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload8.C b/gcc/testsuite/g++.old-deja/g++.jason/overload8.C
new file mode 100644
index 00000000000..9b605f8bce7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload8.C
@@ -0,0 +1,7 @@
+// Bug: g++ fails to catch the ambiguity below.
+// Build don't link:
+
+struct A {
+  operator int () { return 1; };
+  operator int &() { return 1; }; // ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/overload9.C b/gcc/testsuite/g++.old-deja/g++.jason/overload9.C
new file mode 100644
index 00000000000..5b832fbc5f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/overload9.C
@@ -0,0 +1,39 @@
+// PRMS Id: 4257
+// Bug: g++ ignores non-member possibilities (ideal_candidate_ansi bug)
+// Build don't link:
+
+class ostream 
+{
+public:
+#ifdef EITHER_ONE_A
+    ostream& operator<<(unsigned long n);
+    ostream& operator<<(long n);
+#else
+    ostream& operator<<(short n);
+    ostream& operator<<(unsigned short n);
+#endif
+};
+
+class ccObjectInfo {};
+
+ostream& operator << (ostream& out, const ccObjectInfo& obj);
+
+class ccString : public ccObjectInfo
+{
+#ifdef EITHER_ONE_B
+    operator int		() const;
+#else
+    operator long   		() const;
+#endif
+};
+
+// Should pick this one!!
+ostream& operator << (ostream& o, const ccString & s);
+
+extern ostream cout;
+
+void f ()
+{
+    ccString foo;
+    cout << foo;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse1.C b/gcc/testsuite/g++.old-deja/g++.jason/parse1.C
new file mode 100644
index 00000000000..a5ba83c78eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse1.C
@@ -0,0 +1,8 @@
+// Bug: g++ parses the declaration of r as a function declaration.
+// Build don't link:
+
+void foo (int i)
+{
+  int &r (i);
+  r = 1;			// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse10.C b/gcc/testsuite/g++.old-deja/g++.jason/parse10.C
new file mode 100644
index 00000000000..477f7f53a63
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse10.C
@@ -0,0 +1,15 @@
+// Testcase for precedence of ?: wrt =
+
+extern "C" int printf (const char *, ...);
+
+main()
+{
+  int j = 0, k = 0;
+  1 ? j : k = 5;		// should be parsed 1 ? j : (k = 5)
+  (void) (1 ? k = 5 : 0);
+  k = 5 ? 1 : 0;		// should be parsed k = (5 ? 1 : 0)
+
+  printf ("%d %d\n", j, k);
+
+  return j == 5 || k == 5;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse11.C b/gcc/testsuite/g++.old-deja/g++.jason/parse11.C
new file mode 100644
index 00000000000..e9f285cee8d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse11.C
@@ -0,0 +1,9 @@
+// PRMS Id: 6825
+// Build don't link:
+
+class aClass 
+{ 
+  ;
+private: 
+  ;   // This line causes problems 
+}; 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse12.C b/gcc/testsuite/g++.old-deja/g++.jason/parse12.C
new file mode 100644
index 00000000000..7829a8b1b0d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse12.C
@@ -0,0 +1,17 @@
+// PRMS Id: 6821
+
+struct A {
+  int operator()(int i) { return i; }
+};
+
+struct B {
+  A* p;
+  int f () { return (*p)(42); }	// gets bogus error
+};
+
+main ()
+{
+  B b = { new A };
+
+  return b.f () != 42;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse13.C b/gcc/testsuite/g++.old-deja/g++.jason/parse13.C
new file mode 100644
index 00000000000..0ffef983e70
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse13.C
@@ -0,0 +1,8 @@
+// Build don't link:
+
+struct A { 
+  struct B {}; 
+  struct C;
+};
+
+struct A :: C : A :: B {}; // gets bogus error - parse error before `:'
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse14.C b/gcc/testsuite/g++.old-deja/g++.jason/parse14.C
new file mode 100644
index 00000000000..20fcc47dbf8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse14.C
@@ -0,0 +1,12 @@
+// Bug: g++ decides that A::foo is introducing a constructor declarator.
+// Build don't link:
+
+struct A {
+  typedef bool foo;
+};
+
+A::foo (*bar) ();
+
+struct B {
+  A::foo (*bar) ();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse2.C b/gcc/testsuite/g++.old-deja/g++.jason/parse2.C
new file mode 100644
index 00000000000..71be1f4aa22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse2.C
@@ -0,0 +1,6 @@
+// Bug: g++ doesn't understand constructor syntax for pointers.
+// Build don't link:
+
+void f () {
+  char * p (0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse3.C b/gcc/testsuite/g++.old-deja/g++.jason/parse3.C
new file mode 100644
index 00000000000..16f99aaa2de
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse3.C
@@ -0,0 +1,6 @@
+// PRMS Id: 4484 (bug 2)
+// Bug: g++ does not grok abstract declarator syntax for method pointers.
+// Build don't link:
+
+template <class T> class A { };
+void (A<int>::*p)() = (void (A<int>::*)())0; // gets bogus error - abstract declarator failure
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse4.C b/gcc/testsuite/g++.old-deja/g++.jason/parse4.C
new file mode 100644
index 00000000000..95e0f441c73
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse4.C
@@ -0,0 +1,7 @@
+// Bug: g++ doesn't handle superfluous parentheses when redeclaring a TYPENAME.
+// Build don't link:
+
+typedef int foo;
+class A {
+    typedef int ((foo));	// gets bogus error - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse5.C b/gcc/testsuite/g++.old-deja/g++.jason/parse5.C
new file mode 100644
index 00000000000..519deb2867a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse5.C
@@ -0,0 +1,12 @@
+// Bug: foo (bar) should be a declaration of a static data member, not a
+// function; it's getting caught by the rules for constructors.
+// Build don't link:
+
+typedef int foo;
+typedef int bar;
+struct A {
+  static foo (bar);		// gets bogus error
+};
+
+int i = A::bar;			// gets bogus error
+int (*fp)(bar) = A::foo;	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse6.C b/gcc/testsuite/g++.old-deja/g++.jason/parse6.C
new file mode 100644
index 00000000000..677dbe2cb3f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse6.C
@@ -0,0 +1,9 @@
+// PRMS id: 4653
+// Bug: g++ tries to resolve declarator/expression ambiguities too soon.
+// Build don't link:
+
+template<class T> struct A { };
+
+void f () {
+  void (A<int>::*pmf) ();	// gets bogus error - late binding
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse7.C b/gcc/testsuite/g++.old-deja/g++.jason/parse7.C
new file mode 100644
index 00000000000..bd9744c8315
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse7.C
@@ -0,0 +1,7 @@
+// Bug: g++ tries to parse this as a constructor.
+// Build don't link:
+
+typedef int foo;
+struct A {
+  foo (*bar)();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse8.C b/gcc/testsuite/g++.old-deja/g++.jason/parse8.C
new file mode 100644
index 00000000000..1ed9de76040
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse8.C
@@ -0,0 +1,2 @@
+// Build don't link:
+void foo(const int* const); // gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/parse9.C b/gcc/testsuite/g++.old-deja/g++.jason/parse9.C
new file mode 100644
index 00000000000..62836e46438
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/parse9.C
@@ -0,0 +1,18 @@
+// PRMS Id: 5720
+// Bug: the extra set of parens confuses the expr/declarator disambiguation.
+
+class Fu
+{
+  int val;
+public:
+  Fu(int i) : val(i) { };
+  void print() { }
+};
+
+main(int argc, char * argv[])
+{
+  int * i = &argc;
+
+  Fu((*i)).print();		// gets bogus error
+  Fu((*j));
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmem.C b/gcc/testsuite/g++.old-deja/g++.jason/pmem.C
new file mode 100644
index 00000000000..76e873255ed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmem.C
@@ -0,0 +1,11 @@
+// Bug: g++ parses the declaration of 'char A::* foo' below as a
+// declaration of 'char A'.
+// Build don't link:
+
+class A { };
+typedef int foo;
+void f ()
+{
+  char A::* foo;
+  foo = 0;			// gets bogus error - parsing blunder
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmem2.C b/gcc/testsuite/g++.old-deja/g++.jason/pmem2.C
new file mode 100644
index 00000000000..f8d9797a2ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmem2.C
@@ -0,0 +1,43 @@
+template <class Called>
+class aCallback
+{
+public:
+  aCallback(Called& obj, int (Called::*met)());
+
+  int callback();
+  
+protected:
+
+private:
+  Called&       object;
+  
+  int (Called::*method)();
+  
+};
+
+template <class Called>
+aCallback<Called>::aCallback(Called& obj,
+                             int (Called::*met)()) :
+object(obj),
+method(met)
+{};
+
+template <class Called>
+int aCallback<Called>::callback()
+{
+  return (object.*method)();
+}
+
+struct myStruct
+{
+  int action() {return 0;};
+};
+
+main()
+{
+  myStruct toto;
+
+  aCallback<myStruct>   cb(toto, &myStruct::action);
+
+  return cb.callback();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmem3.C b/gcc/testsuite/g++.old-deja/g++.jason/pmem3.C
new file mode 100644
index 00000000000..343953b9604
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmem3.C
@@ -0,0 +1,11 @@
+// Test that comparison of pointers to members does not complain about
+// contravariance violation.
+
+struct A { int i; };
+struct B : public A { int j; int f (); };
+main ()
+{
+  int A::*apm = &A::i;
+  int B::*bpm = apm;
+  return apm != bpm;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmem4.C b/gcc/testsuite/g++.old-deja/g++.jason/pmem4.C
new file mode 100644
index 00000000000..3ce2bb9fc0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmem4.C
@@ -0,0 +1,10 @@
+struct X {};
+X& X::*PTM_1;		// ERROR - pointer to reference member
+void X::*PTM_2;		// ERROR - pointer to void member
+
+struct A {
+  static int& ir;
+};
+
+int i;
+int& A::ir = i;			// not an error
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf.C
new file mode 100644
index 00000000000..677363995b7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf.C
@@ -0,0 +1,7 @@
+// PRMS Id: 4333
+// Bug: g++ can't deal with casts to pointer to member function.
+// Build don't link:
+
+class A { };
+typedef void (A::* pmf)();
+void foo () { (pmf) 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf2.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf2.C
new file mode 100644
index 00000000000..c3decc2e639
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf2.C
@@ -0,0 +1,13 @@
+// PRMS Id: 4484 (bug 3)
+// Bug: g++ does implicitly take the address of methods passed to fns.
+// Build don't link:
+
+struct A {
+  void f ();
+};
+
+void g (void (A::*)());
+
+void h () {
+  g (A::f);			// ERROR - failed conversion to method pointer XFAIL *-*-*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf3.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf3.C
new file mode 100644
index 00000000000..4d4d6ef237f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf3.C
@@ -0,0 +1,19 @@
+// From: enewton@uunet.uu.NET
+// Subject: g++ 2.5.8: cannot cast member function pointers
+// Date: 27 Jan 1994 01:22:56 -0500
+// Build don't link:
+
+struct A {
+	void f(char);
+	void g(int);
+};
+
+typedef void (A::*Ptr)(char);
+
+void q() {
+   Ptr p;
+
+   p  = (Ptr) &A::f;
+   p  = (Ptr) &A::g;
+   p  = &A::f;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf4.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf4.C
new file mode 100644
index 00000000000..a0af9f41289
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf4.C
@@ -0,0 +1,9 @@
+// PRMS Id: 4484 (bug 5)
+// Bug: g++ can't convert between pmf types.
+// Build don't link:
+
+class A;
+typedef void (A::*pmf)();
+typedef void (A::*pmfc)() const;
+
+pmfc p = (pmfc)(pmf)0;		// gets bogus error - pmf conversion
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf5.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf5.C
new file mode 100644
index 00000000000..c27bec10f9e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf5.C
@@ -0,0 +1,18 @@
+// PRMS Id: 4985
+// Build don't link:
+// Special g++ Options:
+
+struct Thing {
+        int OverloadFn() const;
+        void FunctionA(char* restOfLine);
+        void OverloadFn(char* restOfLine);
+};
+
+struct ThingEntry {
+        void (Thing::*_handler)(char* restOfLine);
+};
+
+static ThingEntry KeyWordTable[] = {
+        &Thing::FunctionA,
+        Thing::OverloadFn,
+};				// WARNING - implicit &
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf6.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf6.C
new file mode 100644
index 00000000000..08e425b7931
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf6.C
@@ -0,0 +1,11 @@
+// PRMS Id: 5656
+// Bug: g++ tries (which is a bug) and fails (which is a bug) to initialize
+// var at runtime.
+// Build don't link:
+
+struct A
+{
+    int func(int);
+    int func() const;
+};
+int (A::* var) () const = & A::func;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf7.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf7.C
new file mode 100644
index 00000000000..303dfb9b241
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf7.C
@@ -0,0 +1,27 @@
+// PRMS Id: 6486
+// Make sure that no confused handling of COND_EXPRs and SAVE_EXPRs messes
+// with the number of calls to foo.
+
+int c;
+
+struct A {
+  void f () {}
+  virtual void g () {}
+};
+
+A& foo ()
+{
+  static A a;
+  ++c;
+  return a;
+}
+
+main ()
+{
+  void (A::*p)() = &A::f;
+  (foo ().*p)();
+  p = &A::g;
+  (foo ().*p)();
+
+  return 2 - c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmf8.C b/gcc/testsuite/g++.old-deja/g++.jason/pmf8.C
new file mode 100644
index 00000000000..97f551eb9bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmf8.C
@@ -0,0 +1,29 @@
+// PRMS Id: 6905
+
+class Parent {
+public:
+  void DoSomething() { return; };
+  int i;
+};
+
+class Child : public Parent {
+public:
+};
+
+class User {
+public:
+  void DoAnyThing(void (Parent::*)(void)) { return; }
+  void DoAThing(void (Child::*)(void)) { return; }
+  void DoAThing(int Child::*) { return; }
+};
+
+
+main()
+{
+  User a;
+
+  a.DoAnyThing(&Child::DoSomething);
+  a.DoAThing(&Child::DoSomething);
+  a.DoAThing(&Parent::DoSomething);
+  a.DoAThing(&Parent::i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/pmftemp.C b/gcc/testsuite/g++.old-deja/g++.jason/pmftemp.C
new file mode 100644
index 00000000000..87d2ed11464
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/pmftemp.C
@@ -0,0 +1,16 @@
+// PRMS Id: 4484 (bug 1)
+// Bug: g++ does not support templates involving method pointers.
+// Build don't link:
+
+struct A {
+  void f ();
+};
+
+template <class T> void
+f (void (T::*p)())		// gets bogus error - use of template parm as aggregate
+{ }
+
+void g ()
+{
+  f (&A::f);			// gets bogus error - templates and method pointers
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/precedence.C b/gcc/testsuite/g++.old-deja/g++.jason/precedence.C
new file mode 100644
index 00000000000..af2dcde85a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/precedence.C
@@ -0,0 +1,14 @@
+// Bug: g++ groups ->* before casts.
+// PRMS Id: 4484 (bug 4)
+// Build don't link:
+
+struct A { };
+struct B : public A { void f (); };
+
+void g ()
+{
+  A* ap = new B;
+  void (B::*p)() = &B::f;
+
+  ((B*)ap->*p)();		// gets bogus error - incorrect precedence
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/redecl1.C b/gcc/testsuite/g++.old-deja/g++.jason/redecl1.C
new file mode 100644
index 00000000000..fecace37af4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/redecl1.C
@@ -0,0 +1,12 @@
+class A
+{
+public:
+    A (const A& ccref);
+    friend A const re (const A& v1); // ERROR - 
+};
+
+A // const
+re (const A& ref)
+{				// ERROR - mismatched decls
+    return A (ref);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref1.C b/gcc/testsuite/g++.old-deja/g++.jason/ref1.C
new file mode 100644
index 00000000000..590ddf507c9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref1.C
@@ -0,0 +1,8 @@
+// Bug: g++ tries to call a constructor for a reference.  Doh!
+// Build don't link:
+
+class B;
+struct A {
+  B & b;
+  A (B & x) : b (x) { }		// gets bogus error - 
+};				// gets bogus error - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref10.C b/gcc/testsuite/g++.old-deja/g++.jason/ref10.C
new file mode 100644
index 00000000000..faadb2e79da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref10.C
@@ -0,0 +1,31 @@
+// Test that conversion from D* to B*& works properly.
+
+extern "C" int printf (const char *, ...);
+
+struct V {
+  int a;
+};
+
+struct B: virtual V {
+  int b;
+};
+
+struct D: B {
+  int c;
+};
+
+V* gp = 0;
+
+void foo(V * const &r) {
+  gp = r;
+}
+
+int bar(V *r) {
+  return (r != gp);
+}
+
+main() {
+  D *p = new D;
+  foo(p);
+  return bar(p);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref11.C b/gcc/testsuite/g++.old-deja/g++.jason/ref11.C
new file mode 100644
index 00000000000..b8c6f317a10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref11.C
@@ -0,0 +1,17 @@
+int main(int argc, char ** argv) {
+
+  int (&var_field_ref)[] =  * (int (*)[]) new int [42]; 
+  int (&fix_field_ref)[1] =  * (int (*)[1]) new int [42]; 
+
+  int static_field[42];
+
+  int *const &var_field_ptr_ref  = var_field_ref; // gets bogus error
+  int *const &fix_field_ptr_ref  = fix_field_ref;
+  int *const &static_field_ptr_ref  = static_field;
+
+  int * var_field_ptr  = var_field_ref; // gets bogus error
+  int * fix_field_ptr  = fix_field_ref; 
+  int * static_field_ptr  = static_field; 
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref12.C b/gcc/testsuite/g++.old-deja/g++.jason/ref12.C
new file mode 100644
index 00000000000..7a33647ffb6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref12.C
@@ -0,0 +1,5 @@
+void f (char *const &) { }
+main ()
+{
+  f ("hi");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref2.C b/gcc/testsuite/g++.old-deja/g++.jason/ref2.C
new file mode 100644
index 00000000000..fe97990cd92
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref2.C
@@ -0,0 +1,6 @@
+// Bug: g++ can't deal with references to arrays.
+// Build don't link:
+
+typedef float Matrix[4][4];
+Matrix m;
+Matrix& f () { return m; }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref3.C b/gcc/testsuite/g++.old-deja/g++.jason/ref3.C
new file mode 100644
index 00000000000..2bdd023383f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref3.C
@@ -0,0 +1,7 @@
+// PRMS Id: ????
+// Build don't link:
+
+void f (const int& i)
+{
+  &(int&)i;			// gets bogus error - references ARE lvalues
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref4.C b/gcc/testsuite/g++.old-deja/g++.jason/ref4.C
new file mode 100644
index 00000000000..422c58cab70
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref4.C
@@ -0,0 +1,4 @@
+// Build don't link:
+
+void f ();
+void (&fr)() = f;		// gets bogus error - references to functions XFAIL *-*-*
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref5.C b/gcc/testsuite/g++.old-deja/g++.jason/ref5.C
new file mode 100644
index 00000000000..ca0135323b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref5.C
@@ -0,0 +1,10 @@
+// Build don't link:
+// Special g++ Options: -w
+int i;
+int &const j = i;
+int &const f();
+void g ()
+{
+  j = 1;
+  f() = 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref6.C b/gcc/testsuite/g++.old-deja/g++.jason/ref6.C
new file mode 100644
index 00000000000..afebb6bab98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref6.C
@@ -0,0 +1,2 @@
+const int &f();
+int &a = f();			// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref7.C b/gcc/testsuite/g++.old-deja/g++.jason/ref7.C
new file mode 100644
index 00000000000..ba7bd1d2cb1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref7.C
@@ -0,0 +1,21 @@
+// Testcase for the lifetime of a temporary object which is used to
+// initialize a reference.
+
+int destroyed = 0;
+
+struct A {
+  A() { }
+  A(int) { }
+  ~A() { destroyed++; }
+};
+
+A a;
+A foo () { return a; }
+
+main()
+{
+  const A& ar = foo();
+  const A& ar2 = A();
+  const A& ar3 = (A)1;
+  return destroyed;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref8.C b/gcc/testsuite/g++.old-deja/g++.jason/ref8.C
new file mode 100644
index 00000000000..53f9c1ceef9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref8.C
@@ -0,0 +1,17 @@
+// PRMS Id: 5184
+// Bug: cast to C& below does not adjust address
+
+struct A {};
+struct B {
+  virtual void foo () {};
+};
+struct C : public B, public A {};
+
+main() {
+    C c;
+
+    A& ar = c;
+    C& cr = (C&)ar;
+
+    cr.foo();	// this line causes core dump
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/ref9.C b/gcc/testsuite/g++.old-deja/g++.jason/ref9.C
new file mode 100644
index 00000000000..099d3421cf8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/ref9.C
@@ -0,0 +1,25 @@
+// Bug: g++ re-evaluates the initializer for r before calling f(); since i has
+// changed to an invalid index, this breaks.
+
+class C
+{
+public:
+  void f () { }
+};
+
+void foo (C * objs[])
+{
+  int i = 0;
+  C & r = * objs[i];	/* make reference to element */
+
+  i = 666;
+  r.f ();		/* core dumps here */
+}
+
+int
+main ()
+{
+  C * objs[1] = { new C };
+
+  foo (objs);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/report.C b/gcc/testsuite/g++.old-deja/g++.jason/report.C
new file mode 100644
index 00000000000..d3d3392e451
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/report.C
@@ -0,0 +1,68 @@
+// Build don't link: 
+// GROUPS passed error-reporting
+template <char C>
+class badoo
+{
+};
+
+template <int (*F) (int)>
+class doowop
+{
+};
+
+struct A
+{
+  int a;
+  ~A () { a = 0; }
+  operator int () { return a; }
+};
+
+extern "C" int atoi (char *);
+
+int (*fee)(char *) = atoi;
+int (**bar)(char *) = &fee;
+
+char *s = "4";
+char **sp = &s;
+char ***spp = &sp;
+
+int foo (int a = (**bar) (s))
+{
+   return doowop<foo>::bar; // ERROR - not a member
+} // ERROR - non-void
+
+int foo2 (int (*a)(int) = &foo)
+{
+   undef4 (1); // ERROR - implicit declaration
+  return 1;
+}
+
+class X{
+  class Y{};
+};
+
+typedef int const * bart ();
+typedef bart const * const * bar2;
+
+bar2 baz (X::Y y)
+{
+  X::Y f;
+  bar2 wa [5];
+  wa[0] = baz(f);
+  undef2 (1); // ERROR - implicit declaration
+} // ERROR - non-void
+
+int ninny ()
+{
+  struct A
+    {
+	  static int ninny2 () { return badoo<'\001'>::foo; } // ERROR - not a member
+    };
+
+  return A::ninny2();
+}
+
+int darg (char X::*p)
+{
+   undef3 (1); // ERROR - implicit declaration
+} // ERROR - non-void
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/return.C b/gcc/testsuite/g++.old-deja/g++.jason/return.C
new file mode 100644
index 00000000000..c737a3ea8bd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/return.C
@@ -0,0 +1,21 @@
+// PRMS Id: 5331
+// Bug: the return value of foo is constructed in a temporary and then
+// copied into the return slot.  This is not necessary.
+
+int c = 0;
+
+struct X {
+   X(int i) { }
+   X(X const &XX) { c = 1; }
+   ~X() { }
+};
+
+const X foo() { 
+  return X(3); 
+};
+
+int main()
+{
+  foo();
+  return c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/return2.C b/gcc/testsuite/g++.old-deja/g++.jason/return2.C
new file mode 100644
index 00000000000..272390903e8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/return2.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5368
+// Bug: the X temporary in foo() is not destroyed.
+
+int c = 0;
+
+struct X {
+  X (int) { c++; }
+  ~X() { c--; }
+};
+
+struct Y {
+   Y(const X &) { }
+};
+
+Y foo() { 
+  return X(3); 
+};
+
+int main()
+{
+  foo();
+  return c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/return3.C b/gcc/testsuite/g++.old-deja/g++.jason/return3.C
new file mode 100644
index 00000000000..61e3dda02ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/return3.C
@@ -0,0 +1,19 @@
+// PRMS id: 10912
+
+struct A {
+  A() { i=10; };
+  int i;
+};
+struct B : public A {};
+B b;
+
+A f()
+{
+  return b;
+}
+
+main ()
+{
+  A a = f ();
+  return a.i != 10;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg1.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg1.C
new file mode 100644
index 00000000000..a9b581f2751
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg1.C
@@ -0,0 +1,13 @@
+// Bug: g++ parses the declaration of i as a functional cast.
+// Build don't link:
+
+void take_int (int arg) { }
+ 
+void
+test ()
+{
+    int (i);
+
+    i = 0;
+    take_int (i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg10.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg10.C
new file mode 100644
index 00000000000..8e7d2d1349d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg10.C
@@ -0,0 +1,9 @@
+// Bug: g++ doesn't notice the overflow in the enum values.
+
+#include <limits.h>
+ 
+enum COLOR
+{
+    red,
+    green = ULONG_MAX, blue
+};				// ERROR - enum overflow
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg11.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg11.C
new file mode 100644
index 00000000000..2b3e4cc02d0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg11.C
@@ -0,0 +1 @@
+typedef int int;	/* ERROR - trying to redefine int */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg12.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg12.C
new file mode 100644
index 00000000000..e33404dfc1b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg12.C
@@ -0,0 +1 @@
+int array[3] = { 1, 2, 3, 4 };	/* ERROR - excess initializer elements */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg13.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg13.C
new file mode 100644
index 00000000000..77560b33865
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg13.C
@@ -0,0 +1,11 @@
+// Bug: g++ does overloading on a function-by-function basis.
+
+void
+f ()
+{
+  void (*fp)(void);
+  {
+    extern void g ();
+  }
+  fp = g;	/* ERROR - no 'g' in scope */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg14.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg14.C
new file mode 100644
index 00000000000..8475ecd6c81
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg14.C
@@ -0,0 +1,15 @@
+void *vp;
+int (*ap)[];
+struct S *sp;
+union U *up;
+int (*fp)();
+ 
+void
+test ()
+{
+    vp++;               /* ERROR - incrementing void * */
+    ap++;               /* ERROR - incrementing ptr to incomplete type */
+    sp++;               /* ERROR - incrementing ptr to incomplete type */
+    up++;               /* ERROR - incrementing ptr to incomplete type */
+    fp++;               /* ERROR - incrementing ptr to function */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg15.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg15.C
new file mode 100644
index 00000000000..1f0ff3b64e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg15.C
@@ -0,0 +1,6 @@
+const void *cvp;
+ 
+const void func1 ()
+{
+        return *cvp;    /* ERROR - returning a value from a void function */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg16.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg16.C
new file mode 100644
index 00000000000..75d87a5f0f2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg16.C
@@ -0,0 +1,5 @@
+// Bug: g++ doesn't push parameter decls as they are parsed.
+// Build don't link:
+
+void (*ptr) (int foo, int array[sizeof(foo)]); // gets bogus error XFAIL *-*-*
+void test2 (int bar, int array[sizeof(bar)]) { } // gets bogus error XFAIL *-*-*
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg17.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg17.C
new file mode 100644
index 00000000000..8291650b7d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg17.C
@@ -0,0 +1,15 @@
+// The default assignment operator for B uses array assignment, so we can't
+// just disallow it...
+
+struct A { A& operator=(const A&); };
+struct B { A f[20]; };
+
+int a1[20], a2[20];
+B b1, b2;
+
+void
+test ()
+{
+  b1 = b2;	      /* OK */
+  a1 = a2;	      /* ERROR - array assignment */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg18.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg18.C
new file mode 100644
index 00000000000..53c3dd1628f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg18.C
@@ -0,0 +1,11 @@
+// Any expression may be explicitly converted to type void.
+// Build don't link:
+
+struct S { int m[10]; } object;
+struct S f () { return object; }
+ 
+void
+test ()
+{
+  (void) f().m;         /* OK - cast to void; see constraints in 3.8.1 */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg2.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg2.C
new file mode 100644
index 00000000000..9c30c3640a8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg2.C
@@ -0,0 +1,6 @@
+// Bug: g++ complains about a class definition containing a const member
+// but no constructor; it shouldn't complain at that point, since this is
+// valid use.
+// Build don't link:
+
+struct S { const int member; } object = { 0 };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg20.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg20.C
new file mode 100644
index 00000000000..33b4858b758
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg20.C
@@ -0,0 +1,10 @@
+// Build don't link:
+
+typedef void func_type ();
+func_type *fp;
+void *vp;
+
+void example ()
+{
+    vp != fp;			// gets bogus error - nuttin' wrong wit dat
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg21.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg21.C
new file mode 100644
index 00000000000..d6389bebfa7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg21.C
@@ -0,0 +1 @@
+char array0[4] = "abcde";          /* ERROR - initializer too long */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg22.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg22.C
new file mode 100644
index 00000000000..7be8ba03fc0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg22.C
@@ -0,0 +1,6 @@
+static void f ();		// ERROR - used but not defined
+
+void g ()
+{
+  f ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg23.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg23.C
new file mode 100644
index 00000000000..73bcfc0f0e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg23.C
@@ -0,0 +1,2 @@
+  signed char *ptr2 = "hello";  /* ERROR - changing sign */
+unsigned char *ptr3 = "hello";  /* ERROR - changing sign */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg24.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg24.C
new file mode 100644
index 00000000000..e5987a149c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg24.C
@@ -0,0 +1,8 @@
+typedef int Int;
+ 
+Int Int_object_1;
+ 
+void test ()
+{
+        ((Int) Int_object_1) = Int_object_1; /* ERROR - not an lvalue*/
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg25.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg25.C
new file mode 100644
index 00000000000..deb319d7057
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg25.C
@@ -0,0 +1 @@
+struct { int :0; };  /* ERROR - anon struct not used to declare objects */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg26.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg26.C
new file mode 100644
index 00000000000..1ad204e8ad4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg26.C
@@ -0,0 +1,9 @@
+typedef void (FTYPE) ();
+ 
+FTYPE f;                /* ok */
+ 
+void
+test_0 ()
+{
+    (FTYPE) f;          /* ERROR - casting to function type */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg27.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg27.C
new file mode 100644
index 00000000000..8fb85e80f52
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg27.C
@@ -0,0 +1,4 @@
+short volatile short var_0_2;              /* ERROR - duplicate short */
+long volatile long var_0_3;                /* ERROR - duplicate long */
+signed volatile signed var_0_7;            /* ERROR - duplicate signed */
+unsigned volatile unsigned var_0_8;        /* ERROR - duplicate unsigned */
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg28.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg28.C
new file mode 100644
index 00000000000..246c7e69b31
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg28.C
@@ -0,0 +1,9 @@
+/* From 01/25/94 working paper (7.1.3):
+ 
+        If, in a decl-specifier-seq containing the decl-specifier typedef,
+        there is no type-specifier, or the only type-specifiers are cv-
+        qualifiers, the typedef declaration is ill-formed.
+*/
+ 
+typedef foo;			// ERROR - invalid typedef
+typedef const bar;		// ERROR - invalid typedef
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg3.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg3.C
new file mode 100644
index 00000000000..fc254511cfe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg3.C
@@ -0,0 +1,15 @@
+// Bug: g++ remembers the members of OUTER and complains about the second
+// definition.
+// Build don't link:
+
+void
+test ()
+{
+    {
+	struct OUTER { struct INNER { int mbr; } member; };
+    }
+
+    {
+	struct OUTER { struct INNER { int mbr; } member; };
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg4.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg4.C
new file mode 100644
index 00000000000..978b3634aab
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg4.C
@@ -0,0 +1,12 @@
+// Bug: f1 and f2 are treated as overloaded when they aren't.
+// Build don't link:
+
+int i;
+void f1(double) { }
+void f2(double) { }
+
+void
+test ()
+{
+    i ? f1 : f2;		// gets bogus error - improper overloading
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg5.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg5.C
new file mode 100644
index 00000000000..700fae36294
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg5.C
@@ -0,0 +1,10 @@
+// Bug: func is treated as an overloaded function when it isn't.
+// Build don't link:
+
+int *func () { return 0; }
+
+void
+test ()
+{
+  *func;			// gets bogus error - improper overloading
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg6.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg6.C
new file mode 100644
index 00000000000..0f3c9c3823c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg6.C
@@ -0,0 +1,4 @@
+// Build don't link:
+
+wchar_t *single  =   L"xyz"  ;
+wchar_t *(array[]) = { L"xyz" };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg7.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg7.C
new file mode 100644
index 00000000000..8f3835fffcc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg7.C
@@ -0,0 +1,6 @@
+// Bug: fixincludes and/or cpp mangle the definition of wchar_t so that this
+// doesn't work.
+// Build don't link:
+
+#include <stdlib.h>
+wchar_t array[] = L"xxx";	// gets bogus error - wchar_t
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg8.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg8.C
new file mode 100644
index 00000000000..401d05de590
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg8.C
@@ -0,0 +1,4 @@
+// Bug: g++ is wrongfully pedantic about union initializers.
+// Build don't link:
+
+union U { int mbr; } array[1] = { 0 };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rfg9.C b/gcc/testsuite/g++.old-deja/g++.jason/rfg9.C
new file mode 100644
index 00000000000..abf6335fa97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rfg9.C
@@ -0,0 +1,9 @@
+int cond;
+int i;
+int *ip;
+
+void
+test ()
+{
+  cond ? i : ip;	/* ERROR - pointer/integer mismatch */
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rvalue1.C b/gcc/testsuite/g++.old-deja/g++.jason/rvalue1.C
new file mode 100644
index 00000000000..01cd497b1c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rvalue1.C
@@ -0,0 +1,51 @@
+// PRMS Id: 6000
+// Bug: g++ gets confused trying to build up a reference to a cast.
+
+class String {
+protected:
+  char *cp;
+public:
+  String(char *incp);
+  String(const String &constStringRef);
+  virtual void virtualFn1(void) const {;}
+};
+
+String::String(char *incp)
+{
+  cp = incp;
+}
+
+String::String(const String &constStringRef)
+{
+// Right here, do an 'info args', and look at the virtual function table
+// pointer: typically junk! Calling the function through that table could
+// do anything, since we're really leaping off into the void. This example
+// goes down with 'SIGBUS', but I've seen 'SIGSEGV' too, and 'SIGILL' is
+// possible.
+
+  cp = constStringRef.cp;
+  constStringRef.virtualFn1();
+}
+
+void foofun(String string)
+{
+  ;
+}
+
+class Class1 {
+public:
+  Class1(const String & constStringRef);
+};
+
+Class1 :: Class1 (const String & constStringRef)
+{
+// If instead of calling the function 'foofun()' here, we just assign
+// 'constStringRef' to a local variable, then the vptr is typically == 0!
+
+  foofun(String(constStringRef));
+}
+
+int main(void)
+{
+  Class1 *class1 = new Class1("Hi!");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rvalue2.C b/gcc/testsuite/g++.old-deja/g++.jason/rvalue2.C
new file mode 100644
index 00000000000..522c35fb003
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rvalue2.C
@@ -0,0 +1,17 @@
+// Test for undesired aliasing.
+
+struct A {
+  const A * get_this () const { return this; }
+};
+
+main ()
+{
+  A a;
+  int r = 0;
+  const A& ar1 = (A)a;
+  if (&ar1 == &a)
+    r |= 1;
+  if (A(a).get_this () == &a)
+    r |= 2;
+  return r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/rvalue3.C b/gcc/testsuite/g++.old-deja/g++.jason/rvalue3.C
new file mode 100644
index 00000000000..12fe76d3163
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/rvalue3.C
@@ -0,0 +1,5 @@
+main ()
+{
+   int i;
+   int &ir = (int&)(int)i;	// ERROR - casting rvalue to reference type
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping.C
new file mode 100644
index 00000000000..49715be0a9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping.C
@@ -0,0 +1,12 @@
+// PRMS Id: 3977
+// Bug: A member function is not hidden properly by a later use of its name.
+// Build don't link:
+
+struct A {
+  void index ();
+};
+
+struct B: A {
+  int index;
+  B(): index(4) {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping10.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping10.C
new file mode 100644
index 00000000000..9119951978c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping10.C
@@ -0,0 +1,14 @@
+// Test for scope-based hiding of functions.
+
+void f (char *);
+struct A {
+  void f ();			// ERROR - referred to 
+};
+struct B : public A {
+  void g (char *);
+  void h () {
+    extern void g ();		// ERROR - 
+    f("foo");			// ERROR - hidden
+    g("foo");			// ERROR - hidden
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping11.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping11.C
new file mode 100644
index 00000000000..870b9d5b566
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping11.C
@@ -0,0 +1,11 @@
+// Build don't link:
+
+void f ();
+void g ()
+{
+  int f;
+  {
+    void f ();
+    f ();			// gets bogus error - trying to call integer
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping12.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping12.C
new file mode 100644
index 00000000000..ef2f178a186
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping12.C
@@ -0,0 +1,9 @@
+void f ()
+{
+  struct A {
+    friend void g ();
+  };
+}
+void h () {
+  g ();				// ERROR - no g in scope
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping13.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping13.C
new file mode 100644
index 00000000000..2fd1707627b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping13.C
@@ -0,0 +1,10 @@
+// Build don't link:
+
+struct A { typedef int foo; };
+struct B: public A {
+  typedef int bar;
+  struct C {
+    void g (B::bar);		// gets bogus error - nested type failure
+    void f (B::foo);
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping14.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping14.C
new file mode 100644
index 00000000000..d8c19388151
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping14.C
@@ -0,0 +1,8 @@
+// [class.scope0]: The scope of a name declared in a class consists
+// ... also of all ... default arguments ... in that class ....
+// Build don't link:
+
+struct A {
+  void f (int A::* = &A::i);	
+  int i;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping15.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping15.C
new file mode 100644
index 00000000000..bfebf240984
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping15.C
@@ -0,0 +1,20 @@
+// Bug: g++ ignores the :: qualification and dies trying to treat an integer
+// variable as a list of functions.
+// Build don't link:
+
+class DComplex {
+public:
+  friend  double   imag(const DComplex& a);
+};
+
+class FComplex {
+public:
+  friend  float    imag(const FComplex& a);
+};
+
+void
+scnrm2(FComplex cx[])
+{
+  int imag;
+  ::imag( cx[0] );
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping16.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping16.C
new file mode 100644
index 00000000000..d88501e67a4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping16.C
@@ -0,0 +1,4 @@
+struct A {
+  int a();			// ERROR - 
+  int a;			// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping17.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping17.C
new file mode 100644
index 00000000000..a05acef3d91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping17.C
@@ -0,0 +1,8 @@
+// Test that the integer hides the struct in block scope.
+
+main ()
+{
+  int A;
+  struct A { };
+  A = 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping2.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping2.C
new file mode 100644
index 00000000000..68c8c754a80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping2.C
@@ -0,0 +1,15 @@
+// Bug: A function is not hidden properly by a use of its name in an
+// inner scope.
+// Build don't link:
+
+struct A
+{
+    struct B
+    {
+	int f;
+	B() : f(0) {};
+	void g() { f = 0; };
+    };
+    void f();
+    void f(int);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping3.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping3.C
new file mode 100644
index 00000000000..578de7a7e8e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping3.C
@@ -0,0 +1,8 @@
+// Bug: g++ does not grok nested types very well.
+// Build don't link:
+
+class A {
+  class B;
+  friend class B;
+  class B { };			// gets bogus error - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping4.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping4.C
new file mode 100644
index 00000000000..33f11a672ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping4.C
@@ -0,0 +1,30 @@
+// PRMS Id: 4375
+// Bug: g++ fails to keep track of nested typedefs properly.
+// Build don't link:
+
+class A {
+public:
+  typedef char * Ptr;
+  Ptr s;
+  Ptr get_string();
+  A(Ptr string); // { s = string; };
+};
+
+class B {
+public:
+  typedef A * Ptr;
+  Ptr a;
+  Ptr get_A();
+  B(Ptr a_ptr);
+};
+
+A::A(Ptr string) {		// gets bogus error - 
+  s = string;			// gets bogus error - 
+}
+
+main() {
+  A a("testing");
+  A *a_ptr;
+  B b(&a);
+  a_ptr = b.get_A();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping5.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping5.C
new file mode 100644
index 00000000000..4572da7652a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping5.C
@@ -0,0 +1,6 @@
+// Bug: g++ thinks that A defines operator delete, and tries to call it.
+// Build don't link:
+
+struct A {
+  ~A () { ::operator delete (0); }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping6.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping6.C
new file mode 100644
index 00000000000..161cc4762f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping6.C
@@ -0,0 +1,27 @@
+// Testcase for all uses of explicit global scope.
+// Build don't link:
+
+int a, B;
+
+struct A { };
+int operator+(A&, int);
+
+struct B {
+  struct C {
+    static int a;
+    static int f () { A a; return ::operator+ (a, ::a); } // gets bogus error
+  };
+};
+
+int B::C::a = 0;
+
+struct D : public ::B::C { };	// gets bogus error
+
+void f ()
+{
+  int B;
+  ::B::C b;
+
+  B = ::B::C::a;		// gets bogus error
+  B = ::B::C::f();		// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping7.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping7.C
new file mode 100644
index 00000000000..6ffa907f62a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping7.C
@@ -0,0 +1,6 @@
+// Bug: g++ doesn't flag name collisions between types and non-types as
+// errors.  It shouldn't for class names, but it should for typedefs.
+// Build don't link:
+
+int bar;			// ERROR - 
+typedef int bar;		// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping8.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping8.C
new file mode 100644
index 00000000000..de023d1c3e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping8.C
@@ -0,0 +1,7 @@
+// Bug: g++ allows two different meanings of a name in the same scope.
+
+typedef int foo;		// ERROR - 
+struct A {
+  A (foo);
+  int foo ();			// ERROR - foo already used in scope
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/scoping9.C b/gcc/testsuite/g++.old-deja/g++.jason/scoping9.C
new file mode 100644
index 00000000000..3d8a1555ff2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/scoping9.C
@@ -0,0 +1,12 @@
+// Bug: g++ silently mangles the second 'B' to 'A::B', so the definition is
+// lost.
+// Build don't link:
+
+struct A {
+  enum B { };
+};
+
+struct C: public A {
+  enum B { };
+  void foo (C::B);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/shadow1.C b/gcc/testsuite/g++.old-deja/g++.jason/shadow1.C
new file mode 100644
index 00000000000..59ffcbd15c3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/shadow1.C
@@ -0,0 +1,16 @@
+// Special g++ Options: -Wshadow
+// Build don't link:
+
+class x {
+public:
+        void fun();
+private:
+        int foo;
+};
+
+void x::fun() { };
+
+main ()
+{
+        float foo;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/soverload.C b/gcc/testsuite/g++.old-deja/g++.jason/soverload.C
new file mode 100644
index 00000000000..793e37f33c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/soverload.C
@@ -0,0 +1,10 @@
+// Bug: dfs_pushdecls doesn't create an overload list for member functions,
+//   like it claims to.
+// Build don't link:
+
+struct A
+{
+  static int foo (int);
+  static int foo (int, int);
+  void bar () { foo (1, 2); }	// gets bogus error - broken overloading
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/special.C b/gcc/testsuite/g++.old-deja/g++.jason/special.C
new file mode 100644
index 00000000000..9f6202ecf44
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/special.C
@@ -0,0 +1,6 @@
+// Make sure that forward declarations of specializations work...
+
+template <class T> class A { };
+class A<int>;
+A<int> a;			// ERROR - incomplete type
+class A<int> { };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/static1.C b/gcc/testsuite/g++.old-deja/g++.jason/static1.C
new file mode 100644
index 00000000000..fd0a937b6eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/static1.C
@@ -0,0 +1,31 @@
+// PRMS id: 6863
+
+extern "C" printf(const char *, ...);
+extern "C" void abort();
+
+enum ENUM {E1=0, E2 };
+int d;
+
+class AAA{
+public:
+ AAA() {a = new char[10];printf("constructor AAA() called\n");}
+ AAA(int) {printf("constructor AAA(int) called\n");}
+ ~AAA(){ printf("destructor ~AAA() called\n"); d = 1; }
+ operator int () { return 1;}
+ char *a;
+ int i;
+};
+
+struct sentinel {
+  ~sentinel () { if (d == 0) abort (); }
+} s;
+
+/* forward decl here causes gcc not to execute ct and dt for arr1 */
+extern AAA arr1[];
+
+AAA arr1[] = {(int)E1 };
+
+main()
+{
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth.C b/gcc/testsuite/g++.old-deja/g++.jason/synth.C
new file mode 100644
index 00000000000..733243cf363
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth.C
@@ -0,0 +1,13 @@
+// Bug: the synthesized copy constructor for A is not found.
+// Build don't link:
+
+struct A {
+  // A (const A& a): i(a.i) {}
+  int i;
+};
+
+struct B {
+  A a;
+  B (const B& b): a(b.a), j(b.j) { } // gets bogus error - 
+  int j;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth10.C b/gcc/testsuite/g++.old-deja/g++.jason/synth10.C
new file mode 100644
index 00000000000..d94e6bdebe9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth10.C
@@ -0,0 +1,52 @@
+// Special g++ Options: -O
+// Build don't link:
+// Bug: Synthesizing methods for the nested class screwed up current_class_decl
+// for the outer class.
+
+class A;
+class AH
+{
+  public:
+    inline  AH (   A * p = 0 );
+    AH ( const  AH & from )
+    : pointer( from.pointer )   { inc(); }
+    ~ AH ()  { dec(); }
+  private:
+    A * pointer;
+    inline void inc() const;
+    inline void dec() const;
+};
+
+class A 
+{
+  protected:
+    struct AttrTable
+    {
+	struct Row
+	{
+	};
+    };
+    
+  public:
+
+    class Attributes
+    {
+      public:
+	class iterator
+	{
+	  public:
+	    iterator() : mo(0), attr(0) {}
+	    iterator& operator++() { ++attr; return *this; }
+	    iterator operator++(int)
+	    { iterator tmp = *this; ++*this; return tmp; }
+
+	  private:
+	    AH mo;
+	    const AttrTable::Row* attr;
+	};
+
+	Attributes(AH mo)
+	: mo(mo) {}
+	AH mo;
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth2.C b/gcc/testsuite/g++.old-deja/g++.jason/synth2.C
new file mode 100644
index 00000000000..3094b8e55cb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth2.C
@@ -0,0 +1,8 @@
+// PRMS Id: 4623
+// Bug: g++ tries and fails to synthesize a copy constructor for D.
+// Build don't link:
+
+class A { };
+class B: public virtual A { };
+class C: public A { };
+class D: public B, public C { }; // gets bogus error - bad synthesis
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth3.C b/gcc/testsuite/g++.old-deja/g++.jason/synth3.C
new file mode 100644
index 00000000000..26af8aed3b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth3.C
@@ -0,0 +1,6 @@
+// Testcase for wrongful generation of copy constructor.
+// Build don't link:
+
+class A { };
+class B: virtual private A { };
+class D: public B { };		// gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth4.C b/gcc/testsuite/g++.old-deja/g++.jason/synth4.C
new file mode 100644
index 00000000000..89ecf2dc074
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth4.C
@@ -0,0 +1,15 @@
+// Build don't link:
+
+struct X {
+  X();
+};
+typedef	void (X::*mfp)();
+struct Y {
+  Y();
+  mfp memfp;
+};
+void f()
+{
+  Y *y1, *y2 ;
+  *y1 = *y2;		 // gets bogus error - failed to synthesize op=
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth5.C b/gcc/testsuite/g++.old-deja/g++.jason/synth5.C
new file mode 100644
index 00000000000..cfc68c53448
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth5.C
@@ -0,0 +1,14 @@
+// Bug: generated B::operator= tries to call A::operator=
+
+#pragma implementation
+#line 1 "synth5.h"
+#pragma interface
+
+struct A {
+  virtual A& operator= (const A&) = 0;
+};
+
+struct B: public A {
+};
+#line 5 "synth5.C"
+main() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth6.C b/gcc/testsuite/g++.old-deja/g++.jason/synth6.C
new file mode 100644
index 00000000000..f3a95db44f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth6.C
@@ -0,0 +1,15 @@
+// Bug: g++ tries to generate an op= for DbmItem and fails.
+// Build don't link:
+
+class RefCount{
+public:
+  RefCount();
+
+private:
+  RefCount& operator=(const RefCount);
+};
+
+class DbmItem: public RefCount{
+public:
+  DbmItem(): RefCount() {};
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth7.C b/gcc/testsuite/g++.old-deja/g++.jason/synth7.C
new file mode 100644
index 00000000000..1d4264b2983
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth7.C
@@ -0,0 +1,11 @@
+// Testcase to make sure that synthesized methods are found when needed.
+
+struct B { ~B() { } };
+struct A { B b; };
+
+main()
+{
+  A a, b (a), c = A();
+  A& (A::*afp)(const A&) = &A::operator=;
+  (a.*afp) (b);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth8.C b/gcc/testsuite/g++.old-deja/g++.jason/synth8.C
new file mode 100644
index 00000000000..f7e82a9e8a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth8.C
@@ -0,0 +1,20 @@
+// Bug: the synthesized constructor for A tries to use the mem-initializer
+// list for the B constructor.
+// Build don't link:
+
+struct A
+{
+  virtual ~A();
+};
+
+struct B
+{
+  B();
+  char* x;
+  A* a;
+};
+
+B::B()
+: x(0), a(new A())
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/synth9.C b/gcc/testsuite/g++.old-deja/g++.jason/synth9.C
new file mode 100644
index 00000000000..6886feb6e21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/synth9.C
@@ -0,0 +1,20 @@
+// PRMS Id: 6837
+// Bug: anonymous union confuses g++.
+// Build don't link:
+
+struct my_key {
+   my_key(const my_key&);
+   my_key(const char* n);
+};
+
+struct my_node {
+   my_node(my_key&);
+   union {
+      long cnt;
+      my_node* next;
+   };
+   my_key a;
+};
+
+extern my_node n;
+my_node a(n);
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempargs.C b/gcc/testsuite/g++.old-deja/g++.jason/tempargs.C
new file mode 100644
index 00000000000..749e02cbd19
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempargs.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed templates overloading
+template<class T> class Vector { };
+template<class T> struct Sort { static void sort (Vector<typename T::foo> &); };
+template<class T> void Sort<T>::sort (Vector<typename T::foo> &) { }
+struct whee { typedef int foo; };
+
+void f (Vector<int> &vi) { Sort<whee>::sort (vi); }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempcons.C b/gcc/testsuite/g++.old-deja/g++.jason/tempcons.C
new file mode 100644
index 00000000000..bbc6afeb77e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempcons.C
@@ -0,0 +1,8 @@
+// Bug: member initializers are allowed where they shouldn't be.
+// Build don't link:
+
+template <class T>
+class A {
+  int i;
+  Blarg () : i(0) { }		// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempdest.C b/gcc/testsuite/g++.old-deja/g++.jason/tempdest.C
new file mode 100644
index 00000000000..78fb75df22c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempdest.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed templates destructors
+// Example of PR 3308 workaround
+
+template <class T>
+class A
+{
+  T q;
+public:
+  ~A() { (&q)->T::~T(); }
+};
+
+typedef unsigned int ui;
+
+main()
+{
+  A<ui> *ap = new A<ui>;
+
+  delete ap;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempinst1.C b/gcc/testsuite/g++.old-deja/g++.jason/tempinst1.C
new file mode 100644
index 00000000000..2efcf241bf4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempinst1.C
@@ -0,0 +1,21 @@
+// Bug: g++ fails to instantiate operator<<.
+// Build don't run:
+// Special g++ Options: -g
+
+struct ostream {
+  ostream& operator<< (const char *) { return *this; };
+};
+
+template <class T> class foo {
+  friend ostream& operator<<(ostream&, foo<T>&);
+};
+
+template <class T> ostream& operator<< (ostream& ios, foo<T>&obj) { };
+
+int main()
+{
+  ostream cout;
+  foo<int> foo_obj;
+  cout << foo_obj; // causes linker error
+  return 0;
+} 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template1.C b/gcc/testsuite/g++.old-deja/g++.jason/template1.C
new file mode 100644
index 00000000000..f3aa571483e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template1.C
@@ -0,0 +1,20 @@
+// PRMS Id: 4688
+// Bug: g++ can't deal with templates instantiated within extern "C".
+// Build don't link:
+
+class Gnaf {
+public:
+   virtual int invariant ();
+};
+
+template <class T> class Array : public Gnaf {
+public:
+   virtual int invariant();
+};
+
+extern "C"
+int foo()
+{
+   Array<int> toConv;
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template10.C b/gcc/testsuite/g++.old-deja/g++.jason/template10.C
new file mode 100644
index 00000000000..35841f64712
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template10.C
@@ -0,0 +1,26 @@
+// Bug: member operator shadows global template in tsubst.
+// Build don't link:
+
+class ostream;
+
+template <class TP> class smanip {
+public:
+  friend ostream& operator<<(ostream &o, const smanip<TP>&m);
+};
+
+template<class TP>
+ostream& operator<<(ostream& o, const smanip<TP>& m)
+{ return o;}
+
+class X
+{
+public:
+  X operator<<(int);  // commenting out this line makes it work!
+  void print(ostream& os);
+};
+
+void X::print(ostream& os)
+{
+  smanip<double> smd;
+  os << smd;			// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template11.C b/gcc/testsuite/g++.old-deja/g++.jason/template11.C
new file mode 100644
index 00000000000..25449e2e742
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template11.C
@@ -0,0 +1,14 @@
+// Bug: initializers for static data members of templates don't get run.
+
+template <class T> struct A {
+  static T t;
+};
+
+int foo () { return 1; }
+
+int A<int>::t = foo ();
+
+main ()
+{
+  return (A<int>::t != 1);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template12.C b/gcc/testsuite/g++.old-deja/g++.jason/template12.C
new file mode 100644
index 00000000000..93c19b63571
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template12.C
@@ -0,0 +1,14 @@
+// Testcase for 'this is a type' syntax.
+// Build don't link:
+
+struct B {
+  typedef int A;
+};
+
+template <class T> struct Y {
+  void f() {
+    typename T::A *d;
+  }
+};
+
+template class Y<B>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template13.C b/gcc/testsuite/g++.old-deja/g++.jason/template13.C
new file mode 100644
index 00000000000..11d21801846
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template13.C
@@ -0,0 +1,10 @@
+// Bug: g++ fails to actually instantiate templates to the specifications of
+// guiding decls.
+// Special g++ Options: -g -ansi -pedantic-errors
+
+template <class T> inline T min (T a, T b) { return a<b?a:b; }
+double min (double, double);
+
+main () {
+  return (int) min (0, 1.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template14.C b/gcc/testsuite/g++.old-deja/g++.jason/template14.C
new file mode 100644
index 00000000000..464638d5b55
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template14.C
@@ -0,0 +1,16 @@
+// PRMS Id: 4745
+// Bug: g++ gets the constructor and destructor confused because the default
+// parm prevents the two constructor types from satisfying ==.
+
+template <class T> struct A {
+  A(int = 1);
+  ~A();
+};
+
+template <class T> A<T>::A(int) { } // causes compiler abort
+template <class T> A<T>::~A() { }
+
+main()
+{
+  A<int> a;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template15.C b/gcc/testsuite/g++.old-deja/g++.jason/template15.C
new file mode 100644
index 00000000000..99e129bea89
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template15.C
@@ -0,0 +1,27 @@
+// PRMS Id: 2139
+// Bug: g++ tries to instantiate the template with types on the function
+// obstack and fails.
+
+template<class T>
+class X {
+public:
+    X(int) { }
+
+    T x;
+};
+
+class A { };
+
+main()
+{
+    int i;
+    X<int> xi(i);
+    X<double> xd(i);
+    
+    X<int (*)(int, void *)> fp0(i);
+    X<int (*)(int, char, double)> fp1(i);
+    X<int (*)(int, double**, void *)> fp2(i);
+
+    X<int (A::*)()> mp0 (i);
+    X<int A::*> mp1 (i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template16.C b/gcc/testsuite/g++.old-deja/g++.jason/template16.C
new file mode 100644
index 00000000000..3241f981f35
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template16.C
@@ -0,0 +1,33 @@
+// PRMS Id: 1502
+// Bug: g++ fails to resolve 'gnc' in the call to 'grid'.
+
+template<class T> class foo { 
+public:
+  foo() { } 
+};
+
+template<class T> class bar : public foo<T> {
+public:
+  bar() : foo<T>() {}
+};
+
+template<class T> class ben : public foo<T> {
+public:
+  ben() : foo<T>() {}
+  void grid(T (*f)(bar<T>&),bar<T>& x,bar<T>& y,bar<T>& param);
+};
+
+template<class T> void ben<T>::grid(T (*f)(bar<T>&),bar<T>& x,bar<T>& y,bar<T>& param) { }
+
+template<class T> T gnc(bar<T>& a)
+{
+  return 0;
+}
+
+int main()
+{
+  ben<double> a;
+  bar<double> x,y,p;
+  a.grid(gnc,x,y,p);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template17.C b/gcc/testsuite/g++.old-deja/g++.jason/template17.C
new file mode 100644
index 00000000000..27e4d047ccd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template17.C
@@ -0,0 +1,11 @@
+// Caught by Booch Components.
+// Bug: g++ tries to instantiate nested enums.
+// Build don't link:
+
+template <class T> struct A
+{
+  struct B { };
+  enum C { c };
+};
+
+template struct A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template18.C b/gcc/testsuite/g++.old-deja/g++.jason/template18.C
new file mode 100644
index 00000000000..bcee653c64e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template18.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// Special g++ Options: -g -fexternal-templates
+// GROUPS passed templates
+// Bug: g++ emits template instances when it shouldn't.
+// Special g++ Options: -g -fexternal-templates
+
+#pragma implementation "irrelevant_file"
+#line 1 "wa.h"
+#pragma interface		// ERROR - , XFAIL *-*-*
+template <class T> inline T min (T a, T b) { return a<b?a:b; }
+#line 3 "wa.C" 
+
+main()
+{
+  min (1, 1); 
+}// UNKNOWN "min"
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template19.C b/gcc/testsuite/g++.old-deja/g++.jason/template19.C
new file mode 100644
index 00000000000..ab344432530
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template19.C
@@ -0,0 +1,9 @@
+// Make sure type deduction isn't confused by top-level cv-quals.
+template <class T> T max (const T a, const T b)  { return a>b?a:b; }
+
+main()
+{
+  int a = 0, b = 1;
+  int c = max (a, b);
+  int d = max ((const int)a, (const int)b);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template2.C b/gcc/testsuite/g++.old-deja/g++.jason/template2.C
new file mode 100644
index 00000000000..d3950e9b2b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template2.C
@@ -0,0 +1,12 @@
+// Bug: instantiation of member templates breaks.
+// Build don't link:
+
+template <class T> struct A {
+  static void f ();
+  void g ();
+};
+
+template <class T> void A<T>::f () { }
+template <class T> void A<T>::g () { }
+
+A<int> a;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template20.C b/gcc/testsuite/g++.old-deja/g++.jason/template20.C
new file mode 100644
index 00000000000..fe776c9ff21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template20.C
@@ -0,0 +1,9 @@
+// Make sure type deduction works for both types of array parameters.
+template <class T> void f (T (&a)[2]) { }
+template <class T> void g (T a[2]) { }
+main()
+{
+  int a[2] = { 0, 0 };
+  f (a);
+  g (a);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template21.C b/gcc/testsuite/g++.old-deja/g++.jason/template21.C
new file mode 100644
index 00000000000..817d1da8828
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template21.C
@@ -0,0 +1,16 @@
+// Gosh, this works!
+// Build don't link:
+
+template<class T>
+struct A
+{
+    struct B
+    {
+	void bar();
+    };
+    struct C { };
+};
+
+template<class T> void A<T>::B::bar() { }
+
+template class A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template22.C b/gcc/testsuite/g++.old-deja/g++.jason/template22.C
new file mode 100644
index 00000000000..db2c6202767
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template22.C
@@ -0,0 +1,31 @@
+// Testcase for proper unification of code involving references.
+// Build don't link:
+
+template<class T>
+struct A
+{
+    void foo();
+};
+
+template<class T> void A<T>::foo() { }
+
+template class A<int&>;
+
+const int& f1 ();
+int& f2 ();
+int f3 ();
+
+template <class T> void g1 (const T&);
+template <class T> void g2 (T&);
+template <class T> void g3 (T);
+
+main()
+{
+  g1 (f1 ());
+  g1 (f2 ());
+  g1 (f3 ());
+  g2 (f2 ());
+  g3 (f1 ());
+  g3 (f2 ());
+  g3 (f3 ());
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template23.C b/gcc/testsuite/g++.old-deja/g++.jason/template23.C
new file mode 100644
index 00000000000..1d257a2e7df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template23.C
@@ -0,0 +1,12 @@
+// Testcase for instantiation with cv-qualified type
+// Build don't link:
+
+template<class T>
+struct A
+{
+    void foo();
+};
+
+template<class T> void A<T>::foo() { }
+
+template class A<const int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template24.C b/gcc/testsuite/g++.old-deja/g++.jason/template24.C
new file mode 100644
index 00000000000..c56d92a8564
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template24.C
@@ -0,0 +1,21 @@
+// Bug: g++ doesn't find the conversion from ostream_withassign to ostream.
+
+#include <iostream.h>
+
+template <class T>
+struct A {
+  T t;
+};
+
+template <class T>
+ostream & operator<< (ostream & os, A<T> & a)
+{
+  os << a.t;
+  return os;
+}
+
+main ()
+{
+  A<int> a = { 1 };
+  cout << a << endl;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template25.C b/gcc/testsuite/g++.old-deja/g++.jason/template25.C
new file mode 100644
index 00000000000..4fc2a993863
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template25.C
@@ -0,0 +1,48 @@
+// PRMS Id: 6393
+// Bug: g++ is too lax in considering UPTs to be the same.
+
+template <class R, class T>
+class Bar
+{
+public:
+  R do_bar (T arg);
+};
+
+
+template <class T>
+class Foo
+{
+  T i;
+
+public:
+  void do_foo () {}
+  void do_foo (T const & t) {}
+  void do_foo (Bar<char, T> const & bar);  // {} Put the body here and it works
+  void do_foo (Bar<T, T> const & bar);     // {} Put the body here and it works
+};
+
+// These definitions don't work
+
+template <class T>
+inline void Foo<T>::
+do_foo (Bar<char, T> const & bar)
+{}
+
+template <class T>
+inline void Foo<T>::
+do_foo (Bar<T, T> const & bar)
+{}
+
+
+main ()
+{ int i;
+  Bar<char, int> bar1;
+  Bar<int, int>  bar2;
+  Foo<int> foo;
+  foo.do_foo();
+  foo.do_foo(i);
+  foo.do_foo(bar1);
+  foo.do_foo(bar2);
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template26.C b/gcc/testsuite/g++.old-deja/g++.jason/template26.C
new file mode 100644
index 00000000000..fcd598dda84
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template26.C
@@ -0,0 +1,114 @@
+// PRMS Id: 6275
+// Bug: unification fails for call to find_parameter_in_stack.
+
+#include <stdio.h>
+#include <stdlib.h>
+
+const int max_stack_size = 20;
+
+template <class T>
+class Stack {
+  private:
+    T objects[max_stack_size];
+    int nobjects;
+  public:
+    Stack(): nobjects(0) {}
+    void push(const T&a) {
+        if (nobjects >= max_stack_size) {
+            fprintf(stderr,"Stack: overflow\n");
+            abort();
+          }
+        objects[nobjects++] = a;
+      }
+    T pop() {
+        if (!nobjects) {
+            fprintf(stderr,"Stack: underflow\n");
+            abort();
+          }
+        nobjects -= 1;
+        T result = objects[nobjects];
+        return result;
+      }
+    T top() const {
+        if (!nobjects) {
+            fprintf(stderr,"Stack: underflow\n");
+            abort();
+          }
+        return objects[nobjects - 1];
+      }
+    int n() const { return nobjects; }
+    T operator[](int i) { return objects[i]; }
+};
+
+template <class T>
+class Parameter {
+    T parameter_;
+    int is_set_;
+    int overrides_;
+  public:
+    Parameter(): is_set_(0), overrides_(0) {}
+    void set(const T& a) { parameter_ = a; is_set_ = 1; }
+    void override(int overrides = 1) { overrides_ = overrides; }
+    const T& value() const { return parameter_; }
+    int overrides() const { return overrides_; }
+    int is_set() const { return is_set_; }
+};
+
+template <class T1, class T2>
+T2
+find_parameter_in_stack(Stack<T1>& stack, Parameter<T2>& (T1::*access)())
+{
+  T2 result;
+  int have_result = 0;
+  for (int i=stack.n()-1; i>=0; i--) {
+      if ((stack[i].*access)().is_set()) {
+          if (!have_result || (stack[i].*access)().overrides()) {
+              result = (stack[i].*access)().value();
+              have_result = 1;
+            }
+        }
+    }
+  return result;
+}
+
+class A {
+  private:
+    Parameter<int> a_;
+  public:
+    A() { }
+    Parameter<int>& a() { return a_; }
+};
+
+int
+main(int, char**)
+{
+  Stack<A> A_stack;
+  A a1;
+  A a2;
+  a1.a().set(1);
+  a2.a().set(2);
+  A_stack.push(a1);
+  A_stack.push(a2);
+
+  int val = find_parameter_in_stack(A_stack, &A::a);
+
+  printf("val = %d\n", val);
+  if (val != 2)
+    return 1;
+
+  A_stack.pop();
+  A_stack.pop();
+
+  a1.a().override();
+
+  A_stack.push(a1);
+  A_stack.push(a2);
+
+  val = find_parameter_in_stack(A_stack, &A::a);
+
+  printf("val = %d\n", val);
+  if (val != 1)
+    return 1;
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template27.C b/gcc/testsuite/g++.old-deja/g++.jason/template27.C
new file mode 100644
index 00000000000..3806da0ac7f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template27.C
@@ -0,0 +1,48 @@
+// PRMS Id: 6826
+// Check that unnecessary templates are not instantiated.
+
+template <class T> 
+class Test 
+{ 
+ public: 
+  void doThiss(); 
+  void doThat(); 
+};
+
+template <class T> 
+void Test<T>::doThiss() 
+{ 
+  T x; 
+
+  x.thiss(); 
+} 
+
+template <class T> 
+void Test<T>::doThat() 
+{ 
+  T x; 
+
+  x.that(); 
+} 
+
+class A 
+{ 
+ public: 
+  thiss() {}; 
+};
+
+class B
+{ 
+ public: 
+  that() {}; 
+};
+
+main() 
+{ 
+  Test<A> a; 
+  a.doThiss();			// a.doThat() is not well formed, but then
+				// it's not used so needn't be instantiated. 
+  
+  Test<B> b;
+  b.doThat();			// simillarly b.doThiss(); 
+} 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template28.C b/gcc/testsuite/g++.old-deja/g++.jason/template28.C
new file mode 100644
index 00000000000..c5501d91e61
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template28.C
@@ -0,0 +1,33 @@
+// PRMS Id: 7179
+
+template <class T>
+class Car{
+public:
+   Car();
+} ;
+
+class Wheels{
+public:
+   Wheels();
+} ;
+
+class Shop
+{
+public:
+   Shop();
+private:
+   Car<Wheels> car ;
+} ;
+
+Wheels::Wheels() {}
+
+Shop::Shop() {}
+
+int main()
+{
+   Shop shop ;
+   return 0 ;
+}
+
+template <class T>
+Car<T>::Car() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template29.C b/gcc/testsuite/g++.old-deja/g++.jason/template29.C
new file mode 100644
index 00000000000..d4212e2e5e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template29.C
@@ -0,0 +1,19 @@
+// PRMS Id: 9500
+// Build don't link:
+
+template <int S> 
+class base 
+   { 
+public: 
+   inline base(); 
+   }; 
+ 
+template <class T> 
+class derived : public base<sizeof(T)> 
+   { 
+public: 
+   inline derived(); 
+   }; 
+ 
+template <class T> 
+inline derived<T>::derived() : base<sizeof(T)>(){} 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template3.C b/gcc/testsuite/g++.old-deja/g++.jason/template3.C
new file mode 100644
index 00000000000..e03b8a9ab35
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template3.C
@@ -0,0 +1,14 @@
+// PRMS Id: 4679
+// Bug: g++ doesn't re-instantiate templates after definition is seen.
+
+template <class T> struct A;
+
+A<int> *a;
+
+template <class T> struct A { T t; };
+
+main()
+{
+  if (a)
+    a->t = 1;			// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template30.C b/gcc/testsuite/g++.old-deja/g++.jason/template30.C
new file mode 100644
index 00000000000..b9a6dbeaf3f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template30.C
@@ -0,0 +1,13 @@
+template <class T, class U>    
+int func(U, T);			// ERROR - ref below
+
+template <class T, class U>    
+int func(T, U)
+{				// ERROR - ref below
+        return 2;
+}
+
+main ()
+{
+  func (0, 1);			// ERROR - ambiguous
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template31.C b/gcc/testsuite/g++.old-deja/g++.jason/template31.C
new file mode 100644
index 00000000000..8870bf4ec4e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template31.C
@@ -0,0 +1,38 @@
+// PRMS Id: 8569
+
+#include <iostream.h>
+#include <vector>
+ 
+class Component {
+    int george;
+    char mabel[128];
+};
+class CopyMe {
+public:
+    CopyMe(){;}
+private:
+    vector<Component> strvec;
+};
+
+class IncludeIt   {
+public:
+    IncludeIt() {}
+    ~IncludeIt() {}
+    IncludeIt(const IncludeIt& i) {
+        myStrvec = i.myStrvec;
+    }
+    IncludeIt& operator=(const IncludeIt& i) {
+	myStrvec = i.myStrvec;
+    }
+private:
+    CopyMe myStrvec;
+};
+
+main(int argc, char**argv)   {
+    IncludeIt foo;
+    IncludeIt* bar;
+    exit(0);
+}
+
+template class __malloc_alloc_template<0>;
+template class __default_alloc_template<false, 0>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template32.C b/gcc/testsuite/g++.old-deja/g++.jason/template32.C
new file mode 100644
index 00000000000..d510e93c492
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template32.C
@@ -0,0 +1,10 @@
+// Bug: Instantiating A<int> screws with class bindings for B
+// Build don't link:
+
+template <class T> struct A { };
+struct B {
+  typedef int foo;
+  void f ();
+};
+
+void B::f () { A<int> a; foo i; }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template33.C b/gcc/testsuite/g++.old-deja/g++.jason/template33.C
new file mode 100644
index 00000000000..35a63aad3da
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template33.C
@@ -0,0 +1,17 @@
+// Test nested enums in templates.
+// Build don't link:
+
+template <class T>
+class A
+{
+public:
+  enum muni {X, Y};
+  
+  muni e() { return X; };
+  muni f();
+};
+
+template <class T>
+A<T>::muni A<T>::f() { return X; }
+
+template class A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template34.C b/gcc/testsuite/g++.old-deja/g++.jason/template34.C
new file mode 100644
index 00000000000..76943291db8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template34.C
@@ -0,0 +1,24 @@
+template<class T>
+class Set {
+  public:
+    typedef int (*Compare)(const T&, const T&);
+    static Compare cmp1;
+    static int (*cmp2)(const T&, const T&);
+};
+
+template<class T>
+int gen_cmp(const T& a, const T& b) {
+    if (a<b) return -1;
+    else if (a==b) return 0;
+    else return 1;
+}
+
+template<class T>
+Set<T>::Compare Set<T>::cmp1 = &gen_cmp;
+
+template<class T>
+int (*Set<T>::cmp2)(const T&, const T&) = &gen_cmp;
+
+main() {
+    Set<int> s;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template35.C b/gcc/testsuite/g++.old-deja/g++.jason/template35.C
new file mode 100644
index 00000000000..be3f808252c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template35.C
@@ -0,0 +1,15 @@
+// Bug: instantiation of D() corrupts declaration of basis[].
+// Build don't link:
+
+struct B { };
+template <int t>
+struct D : public B 
+{
+    D() : B () { }
+};
+
+B const * basis[] =
+{
+    new D<0>,
+    new D<1>,
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template36.C b/gcc/testsuite/g++.old-deja/g++.jason/template36.C
new file mode 100644
index 00000000000..807af75e0d2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template36.C
@@ -0,0 +1,51 @@
+// Testcase for implicit 'typename' and resolution of 'typename's in the
+// current scope.
+
+class base1 { 
+public:
+    int bar() const
+    { return 1; }
+};
+
+class base2 { 
+public:
+    int bar() const
+    { return 0; }
+};
+
+template<class X>
+struct base_trait {
+    typedef base1 base;
+};
+
+struct base_trait<float> {
+    typedef base2 base;
+};
+
+template<class T>
+class weird : public base_trait<T>::base {
+public:
+    typedef base_trait<T>::base base;
+
+    base f ();
+    int base::* g ();
+
+    int zowee() const
+    { return bar(); }  
+};
+
+template <class T>
+weird<T>::base weird<T>::f ()
+{
+    return base();
+}
+
+template <class T>
+int weird<T>::base::* weird<T>::g ()
+{ return 0; }
+
+int main()
+{
+    weird<float> z;
+    return z.zowee() || z.f().bar();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template37.C b/gcc/testsuite/g++.old-deja/g++.jason/template37.C
new file mode 100644
index 00000000000..fc237ca439e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template37.C
@@ -0,0 +1,36 @@
+// PRMS Id: 9930
+// Test of -fexternal-templates hackery in new template code
+// Special g++ options: -fexternal-templates
+
+  #pragma implementation "foo.hh"
+  #pragma interface "foo.hh"
+
+  template<class T>
+  class ONE
+  {
+    public:
+      static void func();
+  };
+
+  template<class T>
+  void ONE<T>::func()
+  {
+  }
+
+  class ONE<int>
+  {
+    public:
+      static void func();
+  };
+
+  void ONE<int>::func()
+  {
+  }
+
+  main()
+  {
+    ONE<char>::func();
+    ONE<int>::func();
+
+    return 0;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template38.C b/gcc/testsuite/g++.old-deja/g++.jason/template38.C
new file mode 100644
index 00000000000..567dc20e419
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template38.C
@@ -0,0 +1,18 @@
+// Special g++ Options: -fansi-overloading
+
+struct A {
+  friend int operator== (const A&, const A&);
+  A (int) { }
+};
+
+template <class T> int
+operator== (const T&, const T&)
+{
+  return 0;
+}
+
+main ()
+{
+  A a (1);
+  return a == 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template39.C b/gcc/testsuite/g++.old-deja/g++.jason/template39.C
new file mode 100644
index 00000000000..dc76889e4e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template39.C
@@ -0,0 +1,22 @@
+// PRMS Id: 10283
+// Build don't link:
+
+template <class T> struct B {
+  static void (*p)();
+  static void f ();
+};
+
+template <class T>
+void (*B<T>::p)() = &B<T>::f;
+
+B<int> b;
+
+template <int i> struct A {
+  static const int j = i;
+  int k[j];
+};
+
+A<1> a;
+
+template <int i>
+const int A<i>::j;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template4.C b/gcc/testsuite/g++.old-deja/g++.jason/template4.C
new file mode 100644
index 00000000000..7fcb45c3f9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template4.C
@@ -0,0 +1,21 @@
+// Bug: g++ tries to instantiate ccList twice, and fails.
+// Build don't link:
+
+template<class T> class ccHandle{ };
+template <class T> class ccList;
+template <class T> class cc_List {
+public:
+  ccList <T>  copy ();
+};
+
+template <class T> class ccList : public ccHandle < cc_List <T> > {
+public:
+  ccList (int);
+};
+
+template <class T>
+ccList <T> cc_List<T>::copy (){}
+
+int main (int, char **) {
+  ccList <int> size1();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template40.C b/gcc/testsuite/g++.old-deja/g++.jason/template40.C
new file mode 100644
index 00000000000..635dffcf143
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template40.C
@@ -0,0 +1,19 @@
+// PRMS id: 11315
+// Bug: g++ doesn't recognize the copy ctor for Array<long>.
+
+template <class Type>
+class Array {
+public:
+  Array(int sz=12)
+    : ia (new Type[sz]), size(sz) {}
+  ~Array() { delete[] ia;}
+  Array(const Array<long>& r) : size(0) {} // just for testing
+private:
+  Type *ia;
+  int size;
+};
+
+main(int argc, char *argv[])
+{
+  Array<long> ia;	// looping occurs on this line
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template41.C b/gcc/testsuite/g++.old-deja/g++.jason/template41.C
new file mode 100644
index 00000000000..62d03b67372
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template41.C
@@ -0,0 +1,33 @@
+// PRMS Id: 11420
+// Bug: Can't handle indirect virtual template base init.
+
+extern "C" int printf (const char *, ...);
+
+template<class T>
+class Vbase {
+ public:
+  Vbase(T i) { printf ("%d\n", i); }
+};
+
+template<class T>
+class D1 : virtual public Vbase<T> {
+ public:
+  D1(T i) : Vbase<T>(i) {}
+};
+
+template<class T>
+class D2 : virtual public Vbase<T> {
+ public:
+  D2(T i) : Vbase<T>(i) {}
+};
+
+template<class T>
+class Most : public D1<T>, public D2<T> {
+ public:
+  Most(T i) : D1<T>(i), D2<T>(i), Vbase<T>(i) {}
+};
+
+int main () {
+  Most<int> x(2);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template42.C b/gcc/testsuite/g++.old-deja/g++.jason/template42.C
new file mode 100644
index 00000000000..529aaccd348
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template42.C
@@ -0,0 +1,18 @@
+// Testcase for not evaluating template default args if they are
+// never used.
+
+struct X {
+  X(int) { }
+};
+
+template <class T>
+struct A {
+  void f (T t = T()) { }
+};
+
+main ()
+{
+  A<X> a;
+  X x (1);
+  a.f (x);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template43.C b/gcc/testsuite/g++.old-deja/g++.jason/template43.C
new file mode 100644
index 00000000000..62c7ee76182
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template43.C
@@ -0,0 +1,30 @@
+// Test matching of partial specializations.
+
+template <int* x, int* y>
+class EQUAL {
+public:
+	enum { value = 0 };
+};
+template <int* x>
+class EQUAL<x,x> {
+public:
+	enum { value = 1 };
+};
+
+int x;
+int y;
+
+int equals_x_x = EQUAL<&x,&x>::value; // expected value: 1
+int equals_x_y = EQUAL<&x,&y>::value; // expected value: 0
+int equals_y_x = EQUAL<&y,&x>::value; // expected value: 0
+int equals_y_y = EQUAL<&y,&y>::value; // expected value: 1
+
+main ()
+{
+  if (equals_x_x == 1
+      && equals_x_y == 0
+      && equals_y_x == 0
+      && equals_y_y == 1)
+    return 0;
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template5.C b/gcc/testsuite/g++.old-deja/g++.jason/template5.C
new file mode 100644
index 00000000000..3c1e4cd04c6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template5.C
@@ -0,0 +1,28 @@
+// Bug: g++ fails to compare integer constants properly.
+// Build don't link:
+
+template <int X, int Y>
+struct Matrix {
+   int base [X] [Y];
+};
+
+template <int M,int H,int N>
+Matrix<M,N>& Mul(Matrix<M,N>& Q,Matrix<M,H>& A,Matrix<H,N>& B) {
+  for(int i=0;i<M;i++) {
+    for(int j=0;j<N;j++) {
+      Q.base[i][j]=0;
+      for(int k=0;k<H;k++) {
+	Q.base[i][j]+=A.base[i][k]*B.base[k][j];
+      }
+    }
+  }
+  return Q;
+}
+
+void f ()
+{
+   Matrix<2, 3> q;
+   Matrix<2, 4> a;
+   Matrix<4, 3> b;
+   q = Mul (q, a, b);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template6.C b/gcc/testsuite/g++.old-deja/g++.jason/template6.C
new file mode 100644
index 00000000000..c42426a1908
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template6.C
@@ -0,0 +1,20 @@
+// PRMS Id: 4656
+// Testcase for use of member pointers in template resolution
+
+template <class T> class A {
+ public:
+  A() : a(1) {}
+  T a;
+};
+
+template <class T>
+int foo (T A<int>::*p)
+{
+  return 0;
+}
+int main()
+{
+  int A<int>::*pm = &A<int>::a;	// gets bogus error - failed temp resolution
+  foo (pm);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template7.C b/gcc/testsuite/g++.old-deja/g++.jason/template7.C
new file mode 100644
index 00000000000..87d79a8ab7b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template7.C
@@ -0,0 +1,9 @@
+// PRMS Id: 4826
+// Build don't link:
+
+class A;
+template <class T> void f(const T&, const T&);
+
+void g (const A& a, A& b) {
+  f (a, b); // gets bogus error - failed unification
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template8.C b/gcc/testsuite/g++.old-deja/g++.jason/template8.C
new file mode 100644
index 00000000000..586fb61a02e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template8.C
@@ -0,0 +1,10 @@
+// PRMS Id: 4827
+// Build don't link:
+
+class A;
+template <class T> int f (const T&, const A *);
+
+int g (const int& a)
+{
+  return f (a, (A *)0); // gets bogus error - failed unification
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/template9.C b/gcc/testsuite/g++.old-deja/g++.jason/template9.C
new file mode 100644
index 00000000000..80fd8c9775b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/template9.C
@@ -0,0 +1,12 @@
+// PRMS Id: 4864
+// Bug: g++ can't deal with a guiding declaration which comes before the
+// template.
+// Build don't link:
+
+void f (const int&, const int&);
+template <class T> void f (const T&, const T&) { }
+
+void g (int a)
+{
+  f (a,a); // gets bogus error - two identical candidates
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary.C
new file mode 100644
index 00000000000..168bfe9103e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary.C
@@ -0,0 +1,19 @@
+// From: bruno@isoft.com.ar (Bruno R. Depascale)
+// Subject: No destructor bug
+// Date: Mon, 14 Feb 1994 12:49:45 -0300 (Arg)
+
+// Bug: temporaries created with constructor notation aren't destroyed.
+
+int count = 0;
+
+class A {
+public:
+  A() { ++count; }
+  ~A() { --count; }
+};
+
+int main()
+{
+  A();
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary2.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary2.C
new file mode 100644
index 00000000000..ea80a3fa6b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary2.C
@@ -0,0 +1,16 @@
+class X // Indentation has been done so to see the similarities.
+{
+public:
+  X() {}		  // ERROR - referenced below
+         X(X& x) {x.i=7;} // ERROR - Both functions modify the
+  void bar(X& x) {x.i=7;} // ERROR - reference parameter x.
+  int i;
+};
+
+X foo() { X x; return x; }
+
+main() 
+{
+  X   x(foo()); // ERROR - Compiler doesn't warn about temporary reference.
+  x.bar(foo()); // ERROR - The same mistake is warned about in this case.
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary3.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary3.C
new file mode 100644
index 00000000000..ec5984c3aee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary3.C
@@ -0,0 +1,26 @@
+// Bug: the temporary returned from f is elided, causing a to be constructed
+// twice but only destroyed once.
+
+extern "C" int printf (const char *, ...);
+
+int c,d;
+
+struct A {
+  A (int) { c++; }
+  ~A () { d++; }
+  A (const A&) { c++; }
+  int i;
+};
+
+A f ()
+{ return 1; }
+
+main ()
+{
+  {
+    A a (1);
+    a = f ();
+  }
+  printf ("%d %d\n", c, d);
+  return c != d;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary4.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary4.C
new file mode 100644
index 00000000000..97ce95a81c0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary4.C
@@ -0,0 +1,31 @@
+// Bug: g++ initializes both B::i and B::j before destroying any temps.
+
+extern "C" int printf (const char *, ...);
+
+int c = 0;
+int d = 0;
+int r = 0;
+
+struct A {
+  A() { if (c != d) r = 1; ++c; }
+  A(const A&);  // declare so g++ returns A on the stack
+  ~A() { ++d; }
+  operator int () { return 0; }
+};
+
+A foo ()
+{
+  return A();
+}
+
+struct B {
+  int i;
+  int j;
+  B(): i(foo()), j(foo()) { }
+};
+
+main()
+{
+  B b;
+  return r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary5.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary5.C
new file mode 100644
index 00000000000..07033d0e934
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary5.C
@@ -0,0 +1,16 @@
+// PRMS Id: 6604
+// Bug: Scoped constructor call is not properly recognized as a functional cast
+
+int c;
+
+struct A {
+  A() { ++c; }
+  ~A() { --c; }
+  operator int () { return 1; }
+};
+
+main ()
+{
+  A::A();
+  return c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary6.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary6.C
new file mode 100644
index 00000000000..ce6a92e586a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary6.C
@@ -0,0 +1,8 @@
+// Bug: the temporary from the default parameter to f2 is reused.
+// Build don't link:
+
+struct A {};
+int f2 (int i, const A& ar = A());
+void f (int i, int j = f2(1));
+void g () { f (1); }
+void h () { f (1); }
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary7.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary7.C
new file mode 100644
index 00000000000..8b91fe1324d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary7.C
@@ -0,0 +1,35 @@
+// PRMS ID: 7304
+
+struct V {
+  int n;
+  V() : n(0) { }
+  V(int x) : n(x) { }
+};
+
+V baz(const V &x)
+{
+  return x;
+}
+
+int bar(V v1, V v2, V v3)
+{
+  return v1.n;
+}
+
+struct A {
+  A(): n(7) { }
+  int foo();
+  V n;
+};
+
+int A::foo()
+{
+  V v1, v2;
+  return bar(n, baz(v1), v2);
+}
+
+int main()
+{
+  A a;
+  return (a.foo() != 7);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/temporary8.C b/gcc/testsuite/g++.old-deja/g++.jason/temporary8.C
new file mode 100644
index 00000000000..bb0698e2e3c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/temporary8.C
@@ -0,0 +1,25 @@
+// Test for proper handling of temporaries in ?: exprs.
+
+extern "C" int printf (const char *, ...);
+int c = 0, d = 0;
+
+class A {
+public:
+  A() { ++c; }
+  A(const A&) { ++c; }
+  ~A() { ++d; }
+};
+
+A f (const A& a)
+{
+  return (c ? A() : A());
+}
+
+int main()
+{
+  {
+    f (c ? A() : A());
+  }
+  printf ("%d %d\n", c, d);
+  return c != d || c != 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempover.C b/gcc/testsuite/g++.old-deja/g++.jason/tempover.C
new file mode 100644
index 00000000000..0998f692a59
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempover.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed templates overloading
+#define TEMPL template <class T>
+ 
+class B {};
+ 
+TEMPL class A : virtual public B {
+  public:
+    A(int);
+};
+ 
+TEMPL A<T>::A(int){}
+ 
+A<double> a(1);
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempparse.C b/gcc/testsuite/g++.old-deja/g++.jason/tempparse.C
new file mode 100644
index 00000000000..68f67adc473
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempparse.C
@@ -0,0 +1,29 @@
+/*
+   PRMS Id: 3631
+   Bug is: g++ mangles template class names in a way that it won't accept,
+     and then tries to feed them to itself.
+*/
+// Build don't link:
+
+template<class T>
+struct A {
+  A();
+};
+
+template<class T>
+struct B : A<T> {
+  B();
+};				// gets bogus error - B<C<char>>
+
+template<class T>
+struct C {
+  C();
+};
+
+template<class T>
+struct D {
+  D();
+  B<C<T> > p_f;
+};
+
+typedef D<char> Dummy;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tempsub.C b/gcc/testsuite/g++.old-deja/g++.jason/tempsub.C
new file mode 100644
index 00000000000..4b69d888d36
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tempsub.C
@@ -0,0 +1,28 @@
+// Distillation of crash1.C problem (PR 3633)
+// Build don't link:
+
+template<class P>
+class A
+{
+  P p;
+};
+
+template<class Q>
+class B
+{
+  A<Q> a;			// bogus error - temp parm name propagating
+};
+
+template<class R>
+class C
+{
+  B<R> b;
+};
+
+template<class S>
+class D
+{
+  S s;
+};
+
+C< D<int> > c;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/this.C b/gcc/testsuite/g++.old-deja/g++.jason/this.C
new file mode 100644
index 00000000000..544db6c361a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/this.C
@@ -0,0 +1,16 @@
+// PRMS Id: 5190
+// Bug: g++ fails to build up a const reference to `this'.
+// Build don't link:
+
+class X
+{
+public:
+    void member ();
+};
+
+void print (const X* const &);
+
+void X::member ()
+{
+    print (this);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/thunk1.C b/gcc/testsuite/g++.old-deja/g++.jason/thunk1.C
new file mode 100644
index 00000000000..22c0516f1b3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/thunk1.C
@@ -0,0 +1,47 @@
+// Test that non-variadic function calls using thunks work right.
+// Special g++ Options: -fvtable-thunks
+
+struct A {
+  void* p;
+  A (void* q): p (q) { }
+  A (const A& a): p (a.p) { }
+};
+
+class CBase {
+public:
+   void BaseFunc();
+};
+
+class MMixin {
+public:
+   virtual A MixinFunc(int arg, A arg2) = 0;
+};
+
+class CExample : public CBase, public MMixin {
+public:
+   A MixinFunc(int arg, A arg2);
+};
+
+void CBase::BaseFunc()
+{
+}
+
+A CExample::MixinFunc(int arg, A arg2)
+{
+  if (arg != 1 || arg2.p != 0)
+    return 0;
+  return this;
+}
+
+void* test(MMixin& anExample)
+{
+  return anExample.MixinFunc(1,A(0)).p;
+}
+
+main ()
+{
+  CExample c;
+
+  if (test(c) != &c)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/thunk2.C b/gcc/testsuite/g++.old-deja/g++.jason/thunk2.C
new file mode 100644
index 00000000000..d4ba59bbf00
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/thunk2.C
@@ -0,0 +1,48 @@
+// Test that non-variadic function calls using thunks and PIC work right.
+// Skip if not native
+// Special g++ Options: -fvtable-thunks -fPIC
+
+struct A {
+  void* p;
+  A (void* q): p (q) { }
+  A (const A& a): p (a.p) { }
+};
+
+class CBase {
+public:
+   void BaseFunc();
+};
+
+class MMixin {
+public:
+   virtual A MixinFunc(int arg, A arg2) = 0;
+};
+
+class CExample : public CBase, public MMixin {
+public:
+   A MixinFunc(int arg, A arg2);
+};
+
+void CBase::BaseFunc()
+{
+}
+
+A CExample::MixinFunc(int arg, A arg2)
+{
+  if (arg != 1 || arg2.p != 0)
+    return 0;
+  return this;
+}
+
+void* test(MMixin& anExample)
+{
+  return anExample.MixinFunc(1,A(0)).p;
+}
+
+main ()
+{
+  CExample c;
+
+  if (test(c) != &c)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C b/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C
new file mode 100644
index 00000000000..50f008655ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/thunk3.C
@@ -0,0 +1,56 @@
+// Test that function calls using thunks work right.
+// Special g++ Options: -fvtable-thunks
+// excess errors test - XFAIL mips*-*-* alpha*-*-* rs6000-*-* powerpc-*-eabi m68k-*-coff
+
+#include <stdarg.h>
+
+struct A {
+  void* p;
+  A (void* q): p (q) { }
+  A (const A& a): p (a.p) { }
+};
+
+class CBase {
+public:
+   void BaseFunc();
+};
+
+class MMixin {
+public:
+   virtual A MixinFunc(int arg, ...) = 0;
+};
+
+class CExample : public CBase, public MMixin {
+public:
+   A MixinFunc(int arg, ...);
+};
+
+void CBase::BaseFunc()
+{
+}
+
+A CExample::MixinFunc(int arg, ...)
+{
+  va_list ap;
+  va_start (ap, arg);
+
+  if (arg != 1 || va_arg (ap, int) != 2 || va_arg (ap, int) != 3
+      || va_arg (ap, int) != 4 || va_arg (ap, int) != 5
+      || va_arg (ap, int) != 6 || va_arg (ap, int) != 7
+      || va_arg (ap, int) != 8 || va_arg (ap, int) != 9)
+    return 0;
+  return this;
+}
+
+void* test(MMixin& anExample)
+{
+  return anExample.MixinFunc(1,2,3,4,5,6,7,8,9).p;
+}
+
+main ()
+{
+  CExample c;
+
+  if (test(c) != &c)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tpt-1.cc b/gcc/testsuite/g++.old-deja/g++.jason/tpt-1.cc
new file mode 100644
index 00000000000..15095200d01
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tpt-1.cc
@@ -0,0 +1,30 @@
+// Testcase for use of template parms as types for other template parms.
+
+template <class T, T t>
+class A {
+    T	a;
+public:
+    A(): a(t) {}
+
+    operator T () { return a; }
+};
+
+template <class S, S s>
+class B {
+    A<S,s> a;
+public:
+    B(A<S,s>& b): a(b) {}
+
+    operator S () { return a*20; }
+};
+
+main()
+{
+    A<int, 5> a;
+    B<int, 5> b(a);
+
+    if (b * a == 500)
+      return 0;
+    else
+      return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tredecl.C b/gcc/testsuite/g++.old-deja/g++.jason/tredecl.C
new file mode 100644
index 00000000000..72cbae7a6ee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tredecl.C
@@ -0,0 +1,17 @@
+// Bug:  Foo<Bar> *p semi-instantiates Foo<Bar> in local scope, so
+// when Foo<Bar> f tries to instantiate it later, it only finds the partial
+// instantiation from before.
+//
+// No PR; distilled from James Clark's SGML project.
+//
+// Build don't link:
+
+class Bar { };
+
+template<class T> class Foo;
+
+Foo<Bar> *p;
+
+template<class T> class Foo { };
+
+Foo<Bar> f;			// gets bogus error - hosed binding levels
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tredecl2.C b/gcc/testsuite/g++.old-deja/g++.jason/tredecl2.C
new file mode 100644
index 00000000000..faaf8624f27
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tredecl2.C
@@ -0,0 +1,5 @@
+// No bug; making sure my fix for tredecl.C doesn't break other cases
+// Build don't link:
+
+template<class T> struct Foo { Foo<T> * me() { return this; } };
+Foo<int> i;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tredecl3.C b/gcc/testsuite/g++.old-deja/g++.jason/tredecl3.C
new file mode 100644
index 00000000000..bcc25ba484f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tredecl3.C
@@ -0,0 +1,11 @@
+// PRMS Id: 4679
+// Bug: redeclaration of templates erases the definition.
+// Build don't link:
+
+template <class T> class Foo { public: void h(); };
+template <class T> class Foo;
+
+void g()
+{
+  Foo<int> f;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/tredecl4.C b/gcc/testsuite/g++.old-deja/g++.jason/tredecl4.C
new file mode 100644
index 00000000000..64ba4b8ff8b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/tredecl4.C
@@ -0,0 +1,5 @@
+// It is illegal to use the name of a class template for anything else,
+// including another class template.
+
+template <class T> class A { };	// ERROR - 
+template <class U, class V> class A { }; // ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/trivial.C b/gcc/testsuite/g++.old-deja/g++.jason/trivial.C
new file mode 100644
index 00000000000..f5a535541cb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/trivial.C
@@ -0,0 +1,71 @@
+// PRMS Id: 3665
+// Build don't link:
+
+//-------------------------------------------------------------
+//  Referential declaration within class
+//
+//  Imbeded below is the invocation of the compiler and the error
+//  message
+//
+//  This compiles successfully with both the xlC and CFRONT compilers
+//  This was reviewed with Clem Dickey and we agree that it appears to
+//  be a Cygnus compiler problem.
+//-------------------------------------------------------------
+/*
+$ make bug.reference.o
+        /usr/p3/bin/i960-vxworks-g++ `getsrc bug.reference.C` -I. -Iinc1 -Iinc2
+ -I/vw5.0.3/h  -I/vw5.0.3/h/i960 -I/usr/p3/lib/gcc-lib/i960-vxworks/cygnus-2.3.3
+/include -I/usr/p3/lib/gcc-lib/i960-vxworks/cygnus-2.3.3-930417/include -I/usr/p
+3/lib/i960-vxworks/include -I/usr/p3/i960-vxworks/include  -c -DCPU_FAMILY=I960
+-DCPU=I960CA -mca -mold-align -g3 -O1 -DASSERT_ON -nostdinc -nostdinc++ -MD
+./bug.reference.C: In method `class1::class1 (long unsigned int, long unsigned i
+nt **&)':
+./bug.reference.C:43: cannot convert type `long unsigned int **'
+./bug.reference.C:43:        to type `long unsigned int *[]&'
+make: 1254-004 The error code from the last command is 1.
+*/
+
+// typedefs
+typedef unsigned long u32;
+typedef u32 *ul[16];
+
+// class defs
+class class1 {
+    u32   var1;
+    class1(const class1 &);                   // Copy constructor
+    class1& operator=(const class1 &);        // operator= member function
+public:
+    class1(u32, ul&);
+    ul  &ulref;
+    ~class1() {}
+};
+
+
+// member function defs
+class1::class1(u32 u, ul &l) : var1(u), ulref(l)
+{}
+
+/* ===========================================================================
+Note:  The following is a "work around" that allows the successful compilation.
+
+
+// typedefs
+typedef unsigned long u32;
+typedef u32 *ul[16];
+
+// class defs
+class class1 {
+    u32   var1;
+    class1(const class1 &);                   // Copy constructor
+    class1& operator=(const class1 &);        // operator= member function
+public:
+    class1(u32, ul*);
+    ul  &ulref;
+    ~class1() {}
+};
+
+
+// member function defs
+class1::class1(u32 u, ul *l) : var1(u), ulref(*l)
+{}
+============================================================================*/
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typeck.C b/gcc/testsuite/g++.old-deja/g++.jason/typeck.C
new file mode 100644
index 00000000000..cffbc87bbce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typeck.C
@@ -0,0 +1,19 @@
+// Bug: g++ fails to catch incompatibilities in the parameter lists when
+// assigning.
+// Build don't link:
+
+typedef struct S *type_p;
+typedef struct S const *ctype_p;
+
+typedef ctype_p (*PF) (int);
+
+type_p callee (type_p arg) { return 0; }
+
+void foobar ()
+{
+  static PF p = callee;		// ERROR - 
+
+  p = callee;			// ERROR - 
+}
+
+PF pp = callee;			// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typedef.C b/gcc/testsuite/g++.old-deja/g++.jason/typedef.C
new file mode 100644
index 00000000000..fac78cebeaf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typedef.C
@@ -0,0 +1,9 @@
+// PRMS Id: 4687
+// Bug: g++ misinterprets typedefs of function type in class scope.
+// Build don't link:
+
+struct A {
+   typedef int F();
+   F *fp;
+   void* g() { return fp; }	// gets bogus error - typing
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typedef2.C b/gcc/testsuite/g++.old-deja/g++.jason/typedef2.C
new file mode 100644
index 00000000000..44a32de3925
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typedef2.C
@@ -0,0 +1,12 @@
+// PRMS Id: 5367
+// Bug: the nested name of C::func gets hosed.
+
+struct C {
+  typedef int func(int *, int *);
+};
+
+int
+main()
+{
+   C::func *handler;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typedef3.C b/gcc/testsuite/g++.old-deja/g++.jason/typedef3.C
new file mode 100644
index 00000000000..5b96451ccc9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typedef3.C
@@ -0,0 +1,8 @@
+// Test that inheriting from a type typedefed to itself works.
+// Build don't link:
+
+typedef struct class1 {
+    class1& operator=(const class1&);
+} class1;
+
+class class2 : public class1 { };
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typeid1.C b/gcc/testsuite/g++.old-deja/g++.jason/typeid1.C
new file mode 100644
index 00000000000..90eeb4558fe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typeid1.C
@@ -0,0 +1,11 @@
+#include <typeinfo>
+#include <iostream.h>
+
+struct foo { double f(int); };
+
+main() {
+  double f (int);
+  const type_info &r = typeid (f);
+  cout << typeid(f).name() << endl;
+  cout << typeid(foo::f).name() << endl;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/typeid2.C b/gcc/testsuite/g++.old-deja/g++.jason/typeid2.C
new file mode 100644
index 00000000000..16d5e970142
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/typeid2.C
@@ -0,0 +1,30 @@
+// PRMS Id: 11596
+
+#include <typeinfo>
+extern "C" int printf (const char *, ...);
+
+class Chicken
+{
+public:
+  int eggs_per_day;
+};
+
+template <class Bird>
+class Flock
+{
+public:
+  Bird * flock_head;
+  int    head_count;
+  void print_self() {
+    printf ("A flock of %d %ss\n", head_count, typeid (Bird).name ());
+    printf ("A flock of %d %ss\n", head_count, typeid (*flock_head).name ());
+  }
+};
+
+main()
+{
+  Flock<Chicken> x;
+  printf ("%s\n", typeid(x).name());
+  x.head_count = 42;
+  x.print_self();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/union.C b/gcc/testsuite/g++.old-deja/g++.jason/union.C
new file mode 100644
index 00000000000..b145390efcc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/union.C
@@ -0,0 +1,11 @@
+// Bug: g++ doesn't insert anon union members into class scope.
+// Breaks groff.
+// Build don't link:
+
+struct A {
+  union {
+    int i;
+  };
+
+  void foo () { i = 1; }	// gets bogus error - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/vecdel.C b/gcc/testsuite/g++.old-deja/g++.jason/vecdel.C
new file mode 100644
index 00000000000..717e9678898
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/vecdel.C
@@ -0,0 +1,19 @@
+__SIZE_TYPE__ newsize = 0;
+__SIZE_TYPE__ delsize = 0;
+
+struct A {
+  int i;
+  void * operator new [] (__SIZE_TYPE__ i)
+    { newsize = i; return ::operator new [](i); }
+  void operator delete [] (void *p, __SIZE_TYPE__ i)
+    { delsize = i; ::operator delete [](p); }
+};
+
+int main()
+{
+  A* ap = new A [2];
+  delete [] ap;
+  if (!newsize || newsize != delsize)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/virtual.C b/gcc/testsuite/g++.old-deja/g++.jason/virtual.C
new file mode 100644
index 00000000000..65e8c94f242
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/virtual.C
@@ -0,0 +1,41 @@
+// From: chw@bellcore.com (Charlie Woloszynski,MRE 2J-278,8295228,,27143)
+// Newsgroups: gnu.g++.bug
+// Subject: gcc-2.5.5 bug in multiple inheritance and pure virtual functions
+// Date: 25 Jan 1994 23:41:36 -0500
+
+// Bug: g++ fails to notice definitions of abstract virtuals.
+// Build don't link:
+
+class A 
+{
+public:
+  virtual void a1() = 0;
+  virtual void a2() = 0;
+};
+
+class B
+{
+public:
+  virtual void b1() = 0;
+  virtual void b2() = 0;
+};
+
+
+class C: public A, public B
+{
+public:
+  virtual void a2() {};
+  virtual void b2() {};
+};
+
+class D : public C
+{
+public:
+  virtual void a1() {};
+  virtual void b1() {};
+};
+
+main()
+{
+  D d;				// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/virtual2.C b/gcc/testsuite/g++.old-deja/g++.jason/virtual2.C
new file mode 100644
index 00000000000..22b9fec5e74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/virtual2.C
@@ -0,0 +1,13 @@
+struct A {
+  virtual A* f () { return this; }
+};
+
+struct B: public A {
+  virtual B* f () { return 0; }
+};
+
+main ()
+{
+  A* ap = new B;
+  return (ap->f () != 0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning1.C b/gcc/testsuite/g++.old-deja/g++.jason/warning1.C
new file mode 100644
index 00000000000..86a2160e764
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning1.C
@@ -0,0 +1,7 @@
+// Bug: g++ protests that foo was never defined.
+// Build don't link:
+
+static void foo ();
+static void foo ();
+static void foo () { }
+void bar () { foo(); }		// gets bogus error - 
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning10.C b/gcc/testsuite/g++.old-deja/g++.jason/warning10.C
new file mode 100644
index 00000000000..8dbf5ed3217
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning10.C
@@ -0,0 +1,19 @@
+// Don't warn about these comparisons.
+// Build don't link:
+// Special g++ Options: -W -Wall
+
+struct A {
+  unsigned int b : 28;
+};
+
+int f (int i, unsigned char u, A a, unsigned long ul)
+{
+  if ((u & 0x10) == 0)
+    return 1;
+  if (i == 0U)
+    return 1;
+  if (a.b > ul)
+    return 1;
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning2.C b/gcc/testsuite/g++.old-deja/g++.jason/warning2.C
new file mode 100644
index 00000000000..778a6158a8c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning2.C
@@ -0,0 +1,14 @@
+// g++ ought to warn about casting a base pointer to a derived reference.
+// Build don't link:
+
+struct A {
+  virtual int f () = 0;
+};
+
+struct B: public A { int f () { } };
+
+main()
+{
+  B* bp;
+  A& ar = (A&)bp;		// WARNING - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning3.C b/gcc/testsuite/g++.old-deja/g++.jason/warning3.C
new file mode 100644
index 00000000000..b63b9cac148
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning3.C
@@ -0,0 +1,12 @@
+// Bug: overloading of 'A' for template causes bogus shadowing warnings.
+// Special g++ Options: -Wshadow
+// Build don't link:
+
+template<class T> 
+class A
+{
+ public:
+   virtual ~A() {}
+};
+
+template class A<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning4.C b/gcc/testsuite/g++.old-deja/g++.jason/warning4.C
new file mode 100644
index 00000000000..a4eb4ac7d41
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning4.C
@@ -0,0 +1,16 @@
+// Bug: a virtual function with the same name in an unrelated class will
+// cause a bogus overloading warning.
+// Special g++ Options: -Woverloaded-virtual
+// Build don't link:
+
+struct A {
+  virtual void foo ();
+};
+
+struct B {
+  virtual void bar ();
+};
+
+struct C: public A {
+  virtual void bar  ();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning5.C b/gcc/testsuite/g++.old-deja/g++.jason/warning5.C
new file mode 100644
index 00000000000..ffa8713ea64
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning5.C
@@ -0,0 +1,23 @@
+// PRMS Id: 5135
+// Bug: g++ complains that the result of the new expression is not used.
+// Special g++ Options: -Wall
+
+extern "C" int printf (const char *, ...);
+inline void * operator new (__SIZE_TYPE__, void *p) { return p; }
+
+class foo {
+public:
+  foo() : a(42) {};
+  int a;
+};
+
+main()
+{
+  char buffer[1024];
+
+  new (buffer) foo;
+
+  foo* pY = (foo *)buffer;
+
+  return pY->a != 42;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning6.C b/gcc/testsuite/g++.old-deja/g++.jason/warning6.C
new file mode 100644
index 00000000000..920a4694acd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning6.C
@@ -0,0 +1,7 @@
+// Special g++ Options: -Wunused
+// Build don't link:
+
+struct A {
+  int i:8;
+  virtual ~A() {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning7.C b/gcc/testsuite/g++.old-deja/g++.jason/warning7.C
new file mode 100644
index 00000000000..1fe03f89ce9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning7.C
@@ -0,0 +1,6 @@
+// PRMS Id: 5481
+// Special g++ Options: -Wunused
+// Build don't link:
+
+struct A { };
+static A a = A();
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning8.C b/gcc/testsuite/g++.old-deja/g++.jason/warning8.C
new file mode 100644
index 00000000000..d6ea821eb90
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning8.C
@@ -0,0 +1,17 @@
+// Build don't link:
+
+struct A {
+  A();
+  ~A();
+};
+
+struct B {
+  B (const A&);
+  ~B ();
+};
+
+const B& f ()
+{
+  A a;
+  return a;			// WARNING - returning reference to temporary
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.jason/warning9.C b/gcc/testsuite/g++.old-deja/g++.jason/warning9.C
new file mode 100644
index 00000000000..d46ba37650c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.jason/warning9.C
@@ -0,0 +1,13 @@
+// Special g++ Options: -Wsynth
+
+struct A {
+  operator int ();
+  A& operator= (int);		// WARNING - not used below
+};
+
+main()
+{
+  A a, b;
+
+  a = b;			// WARNING - uses synthesized op=
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/access1.C b/gcc/testsuite/g++.old-deja/g++.law/access1.C
new file mode 100644
index 00000000000..75b7ec39808
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/access1.C
@@ -0,0 +1,34 @@
+// Build don't link: 
+// GROUPS passed access
+// access file
+// Message-Id: <9211281852.AA24557@cove.cis.ufl.edu>
+// From: Robert Forsman <thoth@cove.cis.ufl.edu>
+// Subject: method access bug in gcc-2.3.1 on a sparc-sun-sunos4.1.2
+// Date: Sat, 28 Nov 92 13:52:14 EST
+
+extern "C" {
+    int atoi(const char*);
+}
+
+struct thingus;
+
+class foo {
+public:
+  static const foo alpha;
+  static const foo beta;
+
+private:
+  int i;
+  foo(thingus * s);
+public:
+  foo() {i=0;}
+};
+
+struct thingus {
+  int i;
+};
+
+static thingus blah, blah2;
+
+const foo foo::alpha(&blah);
+const foo foo::beta(&blah2);
diff --git a/gcc/testsuite/g++.old-deja/g++.law/access2.C b/gcc/testsuite/g++.old-deja/g++.law/access2.C
new file mode 100644
index 00000000000..02b27c3e8c6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/access2.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed access
+// access file
+// Message-Id: <9306301534.AA05072@sparc1.cnm.us.es>
+// From: juando@cnm.us.es (Juan D. Martin)
+// Subject: Compiler lets access to private constructor in template.
+// Date: Wed, 30 Jun 93 17:34:10 +0200
+
+template <class T> class Foo
+{
+private:
+    friend class Bar; // To avoid warning.
+      Foo(const T &v) {}; // ERROR - private
+};
+
+
+main()
+{
+    Foo<int>(1);// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/access3.C b/gcc/testsuite/g++.old-deja/g++.law/access3.C
new file mode 100644
index 00000000000..7836fe55edd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/access3.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed access
+// unsorted.2 file
+// Date: Sat, 6 Jun 1992 18:23:03 -0400
+// From: Brendan Kehoe <brendan@cs.widener.edu>
+// Message-Id: <199206062223.AA22653@betty.cs.widener.edu>
+// Subject: bug with access control to member functions
+
+       class X {
+	     void g (int); // ERROR - is private
+        public:
+          void g (double);
+        };
+
+        class Y : public X { void f() { g (1); } };// ERROR - 
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/access4.C b/gcc/testsuite/g++.old-deja/g++.law/access4.C
new file mode 100644
index 00000000000..994a6109bde
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/access4.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed access
+// (Message bugs/access:3)
+// From: jamshid@ses.com (Jamshid Afshar)
+// Date:     Wed, 2 Mar 94 18:24:22 CST
+// Subject:  g++ 2.5.5 doesn't warn about inaccessible virtual base ctor
+// Message-ID: <9403030024.AA04534@ses.com>
+
+class ForceLeafSterile {
+    friend class Sterile;
+      ForceLeafSterile() {} // ERROR - 
+};
+
+class Sterile : private virtual ForceLeafSterile {
+public:
+    Sterile() {}
+    Sterile(const char* /*blah*/) {}
+};
+
+class Illegitimate : public Sterile {
+public:
+    Illegitimate() {}           // ERROR -  can't access virtual base deflt ctor
+    Illegitimate(const char* /*blah*/)
+        : ForceLeafSterile() {} // ERROR - can't access default ctor
+    Illegitimate(const Illegitimate&)
+        {}                      // ERROR - can't access default ctor
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/access5.C b/gcc/testsuite/g++.old-deja/g++.law/access5.C
new file mode 100644
index 00000000000..8d25ed2c6a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/access5.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed access
+// access file
+// From: Jeffrey C. Gealow <jgealow@mtl.mit.edu>
+// Date:     Thu, 18 Feb 93 10:22:23 -0500
+// Subject:  nested class access control bug
+// Message-ID: <9302181522.AA29209@mtl.mit.edu>
+
+
+class enclose {
+public:
+  class nested_public { int x; };
+protected:
+  class nested_protected { int x; };
+private:
+  class nested_private { int x; };
+};
+
+class derived : public enclose {
+  nested_public obj1;     // ok
+  nested_protected obj2;  // ok
+  nested_private obj3;    // error// ERROR - .* , XFAIL *-*-*
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg1.C b/gcc/testsuite/g++.old-deja/g++.law/arg1.C
new file mode 100644
index 00000000000..f980874e48c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg1.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// Subject: argument matching depending on the def order
+// From: kondo@akane.mech.ibaraki.ac.jp
+// Date: Fri, 04 Sep 92 17:41:05 JST
+
+#include <iostream.h>
+//  check the order of declarations
+class A {
+public:
+      void f(double* p) { cout << "A(double*)\n"; } // ERROR - candidate
+      void f(int* p) { cout << "A(int*)\n"; } // ERROR - candidate
+};
+
+class B {
+public:
+      void f(int* p) { cout << "B(int*)\n"; } // ERROR - candidate
+      void f(double* p) { cout << "B(double*)\n"; } // ERROR - candidate
+};
+
+main()
+{
+    A a;
+    B b;
+
+    a.f(0);// ERROR - .*
+    b.f(0);// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg10.C b/gcc/testsuite/g++.old-deja/g++.law/arg10.C
new file mode 100644
index 00000000000..2c21ced1638
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg10.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// From: Terry Lee <terry@uivlsisd.csl.uiuc.edu>
+// Date:     Sat, 14 May 1994 02:46:15 -0500
+// Subject:  g++ 2.5.8 template<const void*> bug
+// Message-ID: <199405140746.AA03993@uivlsisd.csl.uiuc.edu>
+
+template<class T>
+class A {
+public:
+    void func(const T& val) { }
+};
+
+int main()
+{
+    A<const void*> a;
+    int* ptr = 0;
+    a.func(ptr);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg11.C b/gcc/testsuite/g++.old-deja/g++.law/arg11.C
new file mode 100644
index 00000000000..77ea8d84e45
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg11.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// excess errors test - XFAIL *-*-*
+// From: gustavo@cpqd.br (Gustavo Chaves)
+// Date:     Wed, 25 May 94 09:38:00 EST
+// Subject:  problem with user defined conversions in initialization
+// Message-ID: <9405251238.AA19815@moon.cpqd.br>
+
+struct String { String(const char*); };
+
+struct Ack { Ack(String); };
+
+struct S { void method(Ack); };
+
+void function(Ack);
+
+int
+foo(S *o)
+{ // Neither call has a usable constructor for conversions of char[5] to Ack.
+  function("adsf");// ERROR - 
+  o->method("adsf");// ERROR - 
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg2.C b/gcc/testsuite/g++.old-deja/g++.law/arg2.C
new file mode 100644
index 00000000000..5dbf48389ca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg2.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <199303032114.AA03574@kolvir.Boulder.ParcPlace.COM>
+// From: Warner Losh <imp@boulder.parcplace.com>
+// Subject: Overloading bug in g++ 2.3.3 (sparc) compiled by GNU C version 2.3.3
+// Date: Wed, 03 Mar 1993 14:14:02 MST
+
+class c1 { };
+
+typedef void    (*fnp)(void *);
+typedef void    (c1::*memfnp)(void *);
+extern  void    fn1( fnp );
+extern  void    fn1( c1*, memfnp );
+
+void f3(void *) { }
+
+void fn2()
+{
+        fn1((fnp) &f3);         // Everybody likes this
+        fn1(&f3);               // g++ complains here  line 13
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg3.C b/gcc/testsuite/g++.old-deja/g++.law/arg3.C
new file mode 100644
index 00000000000..0037c40d72a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg3.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+typedef void* Ptr;
+
+
+void func(int, const Ptr& p);
+
+template <class T> void func(T, const Ptr& p);
+
+
+Ptr& return_ref();
+
+
+main()
+{
+  char* x;
+
+  func(x,return_ref());   // bug:
+                          //         call of      func(int,  const Ptr&)
+                          //         instead of   func(char*,const Ptr&)
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg4.C b/gcc/testsuite/g++.old-deja/g++.law/arg4.C
new file mode 100644
index 00000000000..2d4479deebc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg4.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <14t4tyk@rpi.edu>
+// From: jorgej@colossus.cs.rpi.edu (Joaquim Jorge)
+// Subject: g++ 2.3.3 Doesn't check function types in initializer lists ?
+// Date: Tue, 9 Mar 1993 21:39:08 GMT
+
+typedef void (*FuncPtr)(int a, float b);
+class Amazing { int a; int b; int c; };
+
+extern void *Wrong1(char *a, int *b);
+extern void *Wrong2(Amazing a, int *b);
+extern void *Wrong3(char *a, Amazing *b);
+extern void Wrong4(char *a, int *b);
+extern Amazing Wrong5(char *a, int *b);
+
+FuncPtr p = &Wrong5;// ERROR - .*
+FuncPtr func_ptr_array[] = { &Wrong1, &Wrong2, &Wrong3, &Wrong4, &Wrong5, 0 };// ERROR - .*
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg5.C b/gcc/testsuite/g++.old-deja/g++.law/arg5.C
new file mode 100644
index 00000000000..276068aa8b6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg5.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+extern double pow(double,int*);
+
+extern "C" {
+  extern int    printf(char*,...);
+  extern double pow(double, double);
+}
+
+int main()
+{
+	if (pow (2.0, 3.0) != 8.0)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg6.C b/gcc/testsuite/g++.old-deja/g++.law/arg6.C
new file mode 100644
index 00000000000..2ad7732c156
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg6.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <9305032310.AA03900@malachite.bbn.com>
+// From: Dan Franklin <dan@diamond.bbn.com>
+// Subject: overloaded function bug
+// Date: Mon, 3 May 93 19:10:10 EDT
+
+
+    typedef int (*fnp)(int, void*);
+    void dispatch_insert(int, int, fnp, void* = 0);
+    void dispatch_insert(int, int, long*, char*);
+    typedef void (*InsertFunP)(int, int, fnp, void*);
+    extern void f(InsertFunP);
+    void g() { f(dispatch_insert); }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg7.C b/gcc/testsuite/g++.old-deja/g++.law/arg7.C
new file mode 100644
index 00000000000..5cf1cd0b3d3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg7.C
@@ -0,0 +1,33 @@
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <9305041759.AA04913@malachite.bbn.com>
+// From: Dan Franklin <dan@diamond.bbn.com>
+// Subject: overloaded function resolved incorrectly
+// Date: Tue, 4 May 93 13:59:18 EDT
+
+#include <stdio.h>
+
+// Given the following overloaded function definitions
+
+void ovf(unsigned long, short,         short) { printf ("PASS\n"); }
+void ovf(          int, short, unsigned long) { printf ("FAIL\n"); }
+
+// and the call
+//
+//   ovf(unsigned long, unsigned int, unsigned int)
+//
+// it seems to me (and to cfront) that this should resolve to ovf #1 above,
+// but g++ resolves it to ovf #2.  Resolving to ovf #1 requires two conversions
+// (unsigned int => short) while resolving to ovf #2 takes two conversions
+// (unsigned long => int, unsigned int => short) and a promotion
+// (unsigned int => unsigned long).
+
+main(int, char**)
+{
+    unsigned long pixmap = 0;
+    unsigned int x = 0;
+    unsigned int y = 0;
+
+    ovf(pixmap, x, y);
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg8.C b/gcc/testsuite/g++.old-deja/g++.law/arg8.C
new file mode 100644
index 00000000000..802471bae47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg8.C
@@ -0,0 +1,27 @@
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <9307081747.AA14030@tnt>
+// From: mclaugh@tnt.acsys.com (Mark A. McLaughlin)
+// Subject: g++ bug
+// Date: Thu, 8 Jul 93 11:47:28 MDT
+
+
+#include <iostream.h>
+#include <stdio.h>
+
+// With this declaration the program will not link.
+template <class Type> ostream & save(ostream & os, Type T);
+
+   template <class Type> ostream &
+save(ostream & os, Type T) {
+   return os << T;
+}  // save
+
+   int
+main() {
+   int i = 10;
+   save((ostream &)cout, i) << endl;
+   short int s = 5;
+   save((ostream &)cout, s) << endl;
+   printf ("PASS\n");
+}  // main
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arg9.C b/gcc/testsuite/g++.old-deja/g++.law/arg9.C
new file mode 100644
index 00000000000..809f2b76a4a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arg9.C
@@ -0,0 +1,39 @@
+// Build don't link: 
+// GROUPS passed arg-matching
+// arg-matching file
+// Message-Id: <199405132049.QAA06835@elan.cs.UMD.EDU>
+// Subject: Bug in g++ 2.4.5 and 2.5.8
+// Date: Fri, 13 May 1994 16:49:22 -0400
+// From: Evan Rosser <ejr@cs.umd.edu>
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class TupleIterator {
+public:
+    TupleIterator(int *tpl);
+    int& operator*();
+    int  live() const;
+// The compile fails with "no post-increment operator for type" at "TI++"
+// below.
+// It succeeds with the same declarations if set_position does not take an int.
+// This occurs with G++ 2.4.5 and 2.5.8.
+// Sun CC works OK with either case.
+        void operator++(int);
+        void set_position(int);
+private:
+};
+
+main() {
+
+int t[5];
+t[1] = 1; t[2] = 2;t[3] = 3;t[4] = 4;
+TupleIterator TI(t);
+
+    while(TI.live()){
+        printf("%d", *TI);
+        TI++;
+    }
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm1.C b/gcc/testsuite/g++.old-deja/g++.law/arm1.C
new file mode 100644
index 00000000000..112c6d80155
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <9211191128.AA14718@us-es.sel.de>
+// From: dcb@us-es.sel.de
+// Subject: ARM p79 trivial bug
+// Date: Thu, 19 Nov 92 12:28:24 +0100
+
+extern "C" int printf( const char *, ...);
+
+int main()
+{
+        int             a = 1 ;
+        int             b = 2 ;
+        int             c = 3 ;
+
+        (a = b) = c ;
+                printf( " %d %d %d\n", a, b, c);
+        return 0 ;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm10.C b/gcc/testsuite/g++.old-deja/g++.law/arm10.C
new file mode 100644
index 00000000000..a57785e55e1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm10.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <1oab2hINN7m@gap.caltech.edu>
+// From: tll@cco.caltech.edu (Tal Lewis Lancaster)
+// Subject: ARM Page 65
+// Date: 18 Mar 1993 17:21:21 GMT
+
+int(*p)[10]=new int[20][10];
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm11.C b/gcc/testsuite/g++.old-deja/g++.law/arm11.C
new file mode 100644
index 00000000000..14f6b9d4832
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm11.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <9302181055.AA12522@slsvitt>
+// From: dcb@us-es.sel.de (David Binderman 3841)
+// Subject: Page 81 of the ARM
+// Date: Thu, 18 Feb 93 11:55:15 +0100
+
+
+int main() {
+        int x[ 10, 11]; // ERROR - .*
+
+        return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm12.C b/gcc/testsuite/g++.old-deja/g++.law/arm12.C
new file mode 100644
index 00000000000..89e2a4d2c82
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm12.C
@@ -0,0 +1,47 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// From: belley@cae.ca (Benoit Belley 3218)
+// Subject: Bad access control with private constructor and derivation
+// Date: Fri, 28 May 1993 12:39:57 -0400 (EDT)
+
+#include <iostream.h>
+
+class X
+{
+public:
+  void f();
+
+private:
+  X();
+};
+
+class Y : public X
+{
+public:
+  Y();
+};
+
+X::X()
+{// ERROR - .*
+  cout << "X::X()" << endl;
+}
+
+void X::f()
+{
+  cout << "X::f()" << endl;
+}
+
+Y::Y()
+{// ERROR -  within this
+  cout << "Y::Y()" << endl;
+}
+
+
+int main()
+{
+  Y y;
+  y.f();
+}
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm13.C b/gcc/testsuite/g++.old-deja/g++.law/arm13.C
new file mode 100644
index 00000000000..565fbec3da8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm13.C
@@ -0,0 +1,16 @@
+// GROUPS passed ARM-compliance
+#include <stdio.h>
+#include <stdlib.h>
+
+inline void *operator new(size_t, void *place) { return place; }
+void*     malloc(size_t);
+void      free(void*);
+
+main()
+{
+  int* p = (int*) malloc(sizeof(int));
+  (void) new (p) int(1);
+  p->int::~int();
+  free(p);
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm14.C b/gcc/testsuite/g++.old-deja/g++.law/arm14.C
new file mode 100644
index 00000000000..91674288935
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm14.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// unsorted.2 file
+// Message-Id: <BpBu19.GrF@math.waterloo.edu>
+// Date: Thu, 4 Jun 1992 15:07:56 GMT
+// Subject: access control
+// From: gjditchf@plg.waterloo.edu (Glen Ditchfield)
+
+
+class X {
+  private:
+    enum E1 {a1, b1};
+  public:
+    enum E2 {a2, b2};
+    };
+
+void h(X* p) {
+    X::E2 e2;
+    int x2 = X::a2;
+
+    X::E1 e1;                   // Should be rejected, but isn't.// ERROR - .* , XFAIL *-*-*
+    int x1 = X::a1;             // ERROR - Should be rejected, and is.
+    }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm15.C b/gcc/testsuite/g++.old-deja/g++.law/arm15.C
new file mode 100644
index 00000000000..639c1fc5e8b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm15.C
@@ -0,0 +1,53 @@
+// GROUPS passed ARM-compliance
+// arm file
+// From: Johan Bengtsson <jbn@lulea.trab.se>
+// Date:     Thu, 21 Oct 93 16:10:25 +0100
+// Subject:  gcc 2.4.5 initializes base classes in mem-initializer order
+// Message-ID: <9310211510.AA14943@holden.lulea.trab.se>
+
+#include <stdio.h>
+
+int state = 0;
+
+class A { public:
+        A() { 
+		if (state == 0)
+			state = 1;
+		else {
+			printf ("FAIL\n");
+			exit (1);
+		}
+	}
+};
+
+class B { public:
+        B() {
+		if (state == 1)
+			state = 2;
+		else {
+			printf ("FAIL\n");
+			exit (1);
+		}
+	}
+};
+
+class AB : public A, public B { public:
+        AB() : B(), A() { 
+		if (state == 2)
+			state = 3;
+		else {
+			printf ("FAIL\n");
+			exit (1);
+		}
+	}
+};
+
+int main()
+{
+        AB ab;
+	if (state == 3)
+		printf("PASS\n");
+	else
+		printf("FAIL\n");
+	exit (state != 3);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm16.C b/gcc/testsuite/g++.old-deja/g++.law/arm16.C
new file mode 100644
index 00000000000..894c37c44e9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm16.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// Special g++ Options: -ansi -Wall -pedantic
+// GROUPS passed ARM-compliance
+// arm file
+// From: Olaf.Weber@cwi.nl
+// Date:     Fri, 2 Dec 1994 09:14:25 +0100
+// Subject:  Omitting & when obtaining a pointer to member function.
+// Message-ID: <9412020814.AA00604=olaf@havik.cwi.nl>
+
+struct C {
+        void foo();
+};
+
+void (C::*pfm)() = C::foo;// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm2.C b/gcc/testsuite/g++.old-deja/g++.law/arm2.C
new file mode 100644
index 00000000000..de8fe425bda
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm2.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// excess errors test - XFAIL *-*-*
+// arm file
+// Message-Id: <199301260140.AA13734@world.std.com>
+// From: gparker@world.std.com (Glenn P Parker)
+// Subject: gcc bug
+// Date: Mon, 25 Jan 1993 20:40:44 -0500
+
+int f() {  return 1; }
+
+int main()
+{
+  int (&fr)() = f;  // g++ cannot compile it
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm3.C b/gcc/testsuite/g++.old-deja/g++.law/arm3.C
new file mode 100644
index 00000000000..3c888bafd7b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm3.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <199301260139.AA13555@world.std.com>
+// From: gparker@world.std.com (Glenn P Parker)
+// Subject: gcc bug
+// Date: Mon, 25 Jan 1993 20:39:19 -0500
+
+class X {
+        enum S { blue, pink };
+        int S;
+public:
+        void f (enum S arg) ;
+};
+
+void X::f (enum S arg)
+{
+        S = arg;        // g++ gives error on this line.
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm4.C b/gcc/testsuite/g++.old-deja/g++.law/arm4.C
new file mode 100644
index 00000000000..2fa43c3fc17
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm4.C
@@ -0,0 +1,28 @@
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <199301272139.AA25489@world.std.com>
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Subject: g++ bug
+// Date: Wed, 27 Jan 1993 16:39:10 -0500
+
+extern "C" int printf(const char*,...);
+int count = 0;
+
+struct S {
+  int i;
+  S(int b)      {
+    i = b;
+    count++; }
+};
+
+int main(void)
+{
+  double a = 2.0;
+
+  S x(int (a));
+  if (count > 0)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm5.C b/gcc/testsuite/g++.old-deja/g++.law/arm5.C
new file mode 100644
index 00000000000..d39b476a840
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm5.C
@@ -0,0 +1,24 @@
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <9212072127.AA24243@us-es.sel.de>
+// From: dcb@us-es.sel.de
+// Subject: page 78 of the ARM
+// Date: Mon, 7 Dec 92 22:27:09 +0100
+
+extern "C" int printf( const char *, ...);
+
+int & max( int & a, int & b) {
+        return (a < b) ? b : a;
+}
+
+int main( void) {
+        int a = 1;
+        int b = 2;
+        int & c = max( a, b);
+
+        if (&c == &b)
+                printf( "PASS\n");
+        else
+                printf( "FAIL\n");
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm6.C b/gcc/testsuite/g++.old-deja/g++.law/arm6.C
new file mode 100644
index 00000000000..e1715ee4bea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm6.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <9211231051.AA11287@us-es.sel.de>
+// From: dcb@us-es.sel.de
+// Subject: ARM page 87
+// Date: Mon, 23 Nov 92 11:51:38 +0100
+
+
+int main() {
+        int a;
+
+        switch (a) {
+        case 1:
+                int v2 = 3;// ERROR -    crosses.*
+        case 2:// ERROR -  jump.*
+                if (v2 == 7)    // error not flagged by 2.3.1
+                        ;
+        }
+
+        return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm7.C b/gcc/testsuite/g++.old-deja/g++.law/arm7.C
new file mode 100644
index 00000000000..1f3d43056ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm7.C
@@ -0,0 +1,41 @@
+// Special g++ Options: -w
+// GROUPS passed ARM-compliance
+// arm file (also in cvt file)
+// Message-Id: <9303061246.AA09402@gjetost.cs.wisc.edu>
+// From: solomon@cs.wisc.edu (Marvin Solomon)
+// Subject: Incorrect resolution of conversion path
+// Date: Sat, 6 Mar 93 06:46:27 -0600
+
+
+extern "C" void printf(const char *,...);
+
+class Base {
+public:
+	int i;
+	Base(int ii) : i(ii) {}
+};
+
+class Derived : public Base {
+public:
+	Derived(int ii) : Base(ii) {}
+	operator Base&();
+};
+
+Derived::operator Base&() {
+	Base *b = new Base(100*i);
+	return *b;
+}
+
+void f(Base &b) {
+	if (b.i == 99)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+}
+
+int main() {
+	Derived d(99);
+	f(d);
+	return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm8.C b/gcc/testsuite/g++.old-deja/g++.law/arm8.C
new file mode 100644
index 00000000000..ef340c6b24e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm8.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+// arm file
+// Message-Id: <9303161105.AA29336@slsvitt>
+// From: dcb@us-es.sel.de (David Binderman 3841)
+// Subject: Page 141 of the ARM
+// Date: Tue, 16 Mar 93 12:05:24 +0100
+
+struct K {
+      void f( int *p  = 0); // ERROR - previous specification
+};
+
+extern int * q;
+
+void K::f( int *p = q);// ERROR - .*
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/arm9.C b/gcc/testsuite/g++.old-deja/g++.law/arm9.C
new file mode 100644
index 00000000000..528478f9f3f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/arm9.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// GROUPS passed ARM-compliance
+#include        <iostream.h>
+enum f1 {
+     F1
+};
+
+enum f2 {
+    F2
+};
+
+class A {
+public:
+    void set (f1 f);
+};
+void A::set (f1 f) { cout << "called A f1\n";}
+
+class B : public A {
+public:
+    void set (f2 f);
+};
+void B::set (f2 f) { cout << "called B\n";} // ERROR - candidate
+
+main() {
+    B b;
+    b.set(F1); // ARM page 309: should call A.set(f1) and that what g++ does,// ERROR - .*
+               // but 13.1 of ARM clearly states that it should call B::set()
+               // or generate an error because overloading works only for
+               // functions within the same scope (first page of chapter 13)
+               // while member of derived and base classes are considered to
+               // belong to different scopes.  Thus B::set() should have
+               // hidden (completely) the A::set() function.
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/array1.C b/gcc/testsuite/g++.old-deja/g++.law/array1.C
new file mode 100644
index 00000000000..fc40bc581e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/array1.C
@@ -0,0 +1,31 @@
+// GROUPS passed arrays
+// array file
+// Message-Id: <9204120353.AA06266@cs.rice.edu>
+// From: dougm@cs.rice.edu (Doug Moore)
+// Subject: constructors not called on new'ed array elements
+// Date: Sat, 11 Apr 92 22:53:35 CDT
+
+#include <stdio.h>
+
+int i = 0;
+
+class foo
+{
+private:
+  static foo *array;
+public:
+  foo()
+    {
+      i++;
+    }
+};
+
+foo* foo::array = new foo [5];
+
+main()
+{
+  if (i != 5)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/array2.C b/gcc/testsuite/g++.old-deja/g++.law/array2.C
new file mode 100644
index 00000000000..0147a4a2bae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/array2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed arrays
+// excess errors test - XFAIL *-*-*
+// array file
+// Message-Id: <"nac.no.188:05.10.92.14.37.45"@nac.no>
+// From: frode@auticon.no
+// Subject: prototype bug ?
+// Date: Thu, 5 Nov 92 15:37:34 PST
+
+        extern unsigned char * (*trt_def(int))[][2];
+        extern unsigned char * (trt_rplst(unsigned char *(*)[][2]));
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bad-error1.C b/gcc/testsuite/g++.old-deja/g++.law/bad-error1.C
new file mode 100644
index 00000000000..09a68788549
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bad-error1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed bad-errors
+// bad-error file
+// Message-Id: <9301081103.AA29469@jclark.com>
+// From: jjc@jclark.com (James Clark)
+// Subject: initializer for static class member array
+// Date: Fri, 8 Jan 93 11:03:05 GMT
+
+struct A {
+  static int v[];
+};
+
+int A::v[1] = { 1 };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bad-error3.C b/gcc/testsuite/g++.old-deja/g++.law/bad-error3.C
new file mode 100644
index 00000000000..c5ce1188d00
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bad-error3.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed bad-errors
+// bad-error file
+// Date: Sun, 31 Jul 1994 11:37:43 +1000 (EST)
+// From: Rohan LENARD <rjl@iassf.easams.com.au>
+// Subject: g++-2.6.0 gives wrong warning for placement syntax new
+// Message-Id: <0iCk1b0000000z0VY0@iassf.easams.com.au>
+
+
+#include <stddef.h>
+
+void * operator new(size_t, int *);
+void * operator new(size_t, void *);
+
+int *x = 0;
+int foo(){
+new (x) int *;
+new (&x) int *;
+new (x) int *;  // This is identical to line 8 !!!
+return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bad-error4.C b/gcc/testsuite/g++.old-deja/g++.law/bad-error4.C
new file mode 100644
index 00000000000..09461c8db7c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bad-error4.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed bad-errors
+#include <stddef.h>
+
+void * operator new(size_t, int *);
+void * operator new(size_t, void *);
+
+int *x = 0;
+int foo(){
+new (x) int *;
+new (&x) int *;
+new (x) int *;  // This is identical to line 8 !!!
+return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bad-error6.C b/gcc/testsuite/g++.old-deja/g++.law/bad-error6.C
new file mode 100644
index 00000000000..a58a5fad2e4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bad-error6.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed bad-errors
+typedef unsigned long size_t;
+
+class tt {
+    public:
+    tt(int);
+
+    private:
+    void *operator new(size_t a); // Forbid object creation in heap memory.
+};
+
+void st(const tt&, int);
+
+void ff(int i, int j)
+{
+    if( i > 0 ) {
+        // This work ok.
+        tt a_tt(i);
+        st(a_tt, j);
+    }
+    else {
+        // This triggers an error because of private operator new ????.
+        st(tt(-i), j);
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bad-error7.C b/gcc/testsuite/g++.old-deja/g++.law/bad-error7.C
new file mode 100644
index 00000000000..479dbf575f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bad-error7.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed bad-errors
+#include <iostream.h>
+
+class ParX
+        {
+        public:
+                ParX() {}
+        };
+
+class X : public ParX
+        {
+        public:
+                void fn2() { cout << "hi" << endl; }
+        };
+
+main()
+        {
+        X               x;
+        ParX*   pParX                   = &x;
+        void    (ParX::*p)()    = (void (ParX::*)()) &X::fn2;    // line 19
+
+        (pParX->*p)();
+        }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bit-fields1.C b/gcc/testsuite/g++.old-deja/g++.law/bit-fields1.C
new file mode 100644
index 00000000000..ed100af3816
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bit-fields1.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+typedef int A;
+
+struct B
+{
+    int A : 2;
+} ;
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bit-fields2.C b/gcc/testsuite/g++.old-deja/g++.law/bit-fields2.C
new file mode 100644
index 00000000000..beb34d05ba1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bit-fields2.C
@@ -0,0 +1,36 @@
+// GROUPS passed bit-fields
+// bitfield file
+// Message-Id: <92Oct29.191913est.62@jarvis.csri.toronto.edu>
+// From: mdivax1!robinson@ai.mit.edu (Jim Robinson)
+// Subject: gcc 2.2.2 C++ bug in handling :0 bit fields
+// Date:   Thu, 29 Oct 1992 19:18:28 -0500
+//
+// Also applies to:
+// bitfield file
+// From: Jaimie Wilson/MSL <Jaimie_Wilson@msl.isis.org>
+// Date:   Fri, 28 Jan 1994 06:11:43 -0500
+// Subject: GCC bug report
+
+
+#include <stdio.h>
+#include <stddef.h>
+
+struct foo {
+        char a;
+        char b;
+        unsigned int : 0;       /* force word alignment */
+        char c;
+};
+
+int
+main(int argc, char **argv)
+{
+        struct foo bar;
+
+	if (offsetof (struct foo, c) > sizeof (unsigned int))
+		printf ("FAIL\n");
+	else
+		printf ("PASS\n");
+	return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/bit-fields3.C b/gcc/testsuite/g++.old-deja/g++.law/bit-fields3.C
new file mode 100644
index 00000000000..7c7e6940e82
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/bit-fields3.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed bit-fields
+  class t {
+      short           :(sizeof(short)-2);
+    public:
+      t();
+  };
diff --git a/gcc/testsuite/g++.old-deja/g++.law/builtin1.C b/gcc/testsuite/g++.old-deja/g++.law/builtin1.C
new file mode 100644
index 00000000000..e9b465422cf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/builtin1.C
@@ -0,0 +1,17 @@
+// GROUPS passed builtins
+// Apparently not in g++ bug snapshot (was originally sent to bug-gcc)
+// Message-Id: <m0p74Fh-0002fCC@neal.ctd.comsat.com>
+// Date: Tue, 7 Dec 93 10:23 EST
+// From: neal@ctd.comsat.com (Neal Becker)
+// Subject: builtin_alloca on hpux (gcc-2.5.6)
+// We have to avoid using -ansi, which results in a call to alloca instead of
+//  the use of __builtin_alloca, and thus ends up being unresolved.
+// Special g++ Options: 
+
+extern "C" void* alloca( __SIZE_TYPE__ );
+extern "C" int printf (const char *, ...);
+
+void* junk() {
+  return alloca(10);
+}
+main() { printf ("PASS\n");}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/casts1.C b/gcc/testsuite/g++.old-deja/g++.law/casts1.C
new file mode 100644
index 00000000000..9cfeaa1a42d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/casts1.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed casts
+// casts file
+// From: dcb@us-es.sel.de (David Binderman 3841)
+// Date:     Thu, 18 Feb 93 14:42:48 +0100
+// Subject:  Page 67 of the ARM
+// Message-ID: <9302181342.AA14050@slsvitt>
+
+int main() {
+   (struct T { int b; } *) 0;      // ERROR - 
+
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/casts2.C b/gcc/testsuite/g++.old-deja/g++.law/casts2.C
new file mode 100644
index 00000000000..11a36b9f5c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/casts2.C
@@ -0,0 +1,39 @@
+// Build don't link: 
+// GROUPS passed casts
+class VObject;
+
+typedef int boolean;
+
+typedef boolean (VObject::*method)();
+typedef boolean (VObject::*method0)();
+typedef boolean (VObject::*method1)(long);
+
+#define methodOf(o,m)  (method)(&o::m)
+
+
+class VObject {
+    public:
+    boolean perform(method );
+    boolean perform(method , long);
+    void    affectMethod(method );
+    void    dummy(){};
+};
+
+
+boolean VObject::perform(method m)
+{
+        method0 q = (method0)m;
+        return(this->*q)();
+}
+
+
+boolean VObject::perform(method m, long param)
+{
+        method1 q = (method1)m;
+        return(this->*q)(param);
+ }
+
+void VObject::affectMethod(method m)
+{
+        m =   methodOf(VObject, dummy);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/casts3.C b/gcc/testsuite/g++.old-deja/g++.law/casts3.C
new file mode 100644
index 00000000000..e76f61c998d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/casts3.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed casts
+// casts file
+// From: fjh@cs.mu.oz.au
+// Message-Id: <9310121939.29641@munta.cs.mu.OZ.AU>
+// Subject: should emit diagnostic for `int *p = (void *)0;'
+// Date: Wed, 13 Oct 93 5:39:35 EST
+        int *p = (void *)0;// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen1.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen1.C
new file mode 100644
index 00000000000..b122e908988
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen1.C
@@ -0,0 +1,20 @@
+// GROUPS passed code-generation
+// code-gen file
+// From: Jeffrey C. Gealow <jgealow@mtl.mit.edu>
+// Date:     Sun, 4 Jul 93 18:57:53 -0400
+// Subject:  increment bug (0 + 1 + 1 = 3)
+// Message-ID: <9307042257.AA23538@mtl.mit.edu>
+
+#include <stdio.h>
+
+main()
+{
+  int i = 0;
+  (++i)++;
+  if (i == 2)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen2.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen2.C
new file mode 100644
index 00000000000..88dd13fd7ef
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen2.C
@@ -0,0 +1,34 @@
+// GROUPS passed code-generation
+// code-gen file
+// From: Gunther Seitz <Gunther.Seitz@regent.e-technik.tu-muenchen.dbp.de>
+// Date:     Thu, 18 Mar 1993 10:45:29 +0100
+// Message-ID: <93Mar18.104538met.1094@regatta.regent.e-technik.tu-muenchen.de>
+
+
+#include <stdio.h>
+
+class X {
+
+public:
+    double x;
+    X () { x=3.5; }    // Here we go. This assignment fails because
+                       // of X::x being aligned on a doubleword
+                       // boundary, not a quadword one.
+    };
+
+
+class A : public virtual X {};       // Only way to produce the
+class B : public virtual X {};       // error is to use this
+class C : public virtual X {};       // construct of virtual
+                                     // base classes.
+
+class Y : public A, public B, public C {};
+
+
+int main ()
+{
+        Y y;       // To call the constructor
+	printf ("PASS\n");
+        }
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen3.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen3.C
new file mode 100644
index 00000000000..0635d278197
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen3.C
@@ -0,0 +1,33 @@
+// GROUPS passed code-generation
+// execution test fails - 
+// code-gen file
+// From: mscha@anne.wifo.uni-mannheim.de (Martin Schader)
+// Date:     Wed, 4 Aug 93 19:14:52 +0200
+// Message-ID: <9308041714.AA00752@anne.wifo.uni-mannheim.de>
+
+extern "C" int printf (const char *, ...);
+
+template<class T> struct Y {
+    Y* next;
+};
+
+template<class T> struct X {
+    X() { ptrY = 0; }
+    void f();
+    Y<T>* ptrY;
+};
+
+template<class T> void X<T>::f() {
+    ptrY->next = ptrY = new Y<T>;
+//
+//  Use two assignment statements and it works
+//    ptrY = new Y<T>;
+//    ptrY->next = ptrY;
+}
+
+int main() {
+    X<int> x;
+    x.f();
+    printf ("PASS\n");
+    exit(0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen4.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen4.C
new file mode 100644
index 00000000000..a9070ed4ea8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen4.C
@@ -0,0 +1,30 @@
+// GROUPS passed code-generation
+// code-gen file
+// From: david.binderman@pmsr.philips.co.uk
+// Date:     Tue, 17 Aug 93 10:09:38 BST
+// Subject:  .* broken in 2.4.5
+// Message-ID: <9308170909.AA05509@pmsr.philips.co.uk>
+
+class A {
+public:
+        char c;
+};
+
+typedef char A::*PMA;
+
+PMA pmA = &A::c;
+
+A oA;
+
+extern "C" int printf( const char *, ...);
+
+main()
+{
+        oA.c = 'q';
+
+        if ( (oA .* pmA))
+                        printf( "PASS\n");
+        else
+                        printf(" FAIL\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C
new file mode 100644
index 00000000000..fa55dbe8302
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C
@@ -0,0 +1,283 @@
+// GROUPS passed code-generation
+// code-gen file
+// From: "David" <norman@pi14.arc.umn.edu>
+// Date:     Mon, 15 Nov 1993 20:59:14 -0600 (CST)
+// Subject:  An error!
+// Message-ID: <9311160259.AA03353@pi14.arc.umn.edu>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <fstream.h>
+#include <iostream.h>
+#include <math.h>
+
+#define ANSI_C
+
+typedef double VEC ;
+
+class Vector;
+
+class VectorInt 
+{
+	public:
+
+	/* Nothing public!! Only Vector can use this class */
+
+	private:
+
+	VectorInt( int );
+	VectorInt( int, double *, int = 0 );
+	VectorInt( const VectorInt & );
+	~VectorInt();
+
+	VectorInt *refer();
+	void unrefer();
+	int count;				/* Number of Vector's refering to me */
+
+	VEC *vec;
+
+	friend class Vector;
+	friend class VecElem;
+};
+
+class VecElem 
+{
+	public:
+	
+	operator double();
+	double operator=( double );
+
+	private:
+
+	VecElem( Vector &, int );
+	VecElem( const VecElem & );
+
+	Vector &v;
+	int row;						/* Row element refers to */
+
+	friend class Vector;
+};
+
+class Vector 
+{
+	public:
+
+	Vector();					// Must be assigned to before used
+	Vector( VectorInt * );
+	Vector( int );
+	Vector( int, double *, int beg = 0 );
+	Vector( const Vector & );
+	Vector &operator=( const Vector & );
+	~Vector() { if(r) r->unrefer(); };
+
+	int row() const { return 19; }
+	int dim() const { return 10; }
+
+	double operator()( int ) const;
+	VecElem operator()( int );
+
+	double assign( int, double );
+
+	friend ostream& operator<<( ostream&, const Vector& m );
+	
+	private:
+
+	VectorInt *r;			/* Reference to real data */
+
+	friend class VecElem;
+	friend class LUDecom;
+	friend class SVD;
+};
+
+
+Vector::
+Vector()
+	: r(0)
+{}
+
+Vector::
+Vector( VectorInt *vi )
+	: r(vi)
+{
+	r->refer();
+}
+
+Vector::
+Vector( int row )
+{
+	assert( row > 0 );
+
+	r = new VectorInt( row );
+
+	r->refer();
+}
+
+Vector::
+Vector( int row, double *d, int beg )
+{
+	assert( row > 0 );
+
+	r = new VectorInt( row, d, beg );
+
+	r->refer();
+}
+
+Vector::
+Vector( const Vector &A )
+	: r( A.r->refer() )
+{}
+
+Vector& Vector::
+operator=( const Vector &A )
+{
+	if( r )
+		r->unrefer();
+
+	r = A.r->refer();
+
+	return *this;
+}
+
+double Vector::
+operator()( int row ) const
+{
+	assert( r );
+
+	return *r->vec;
+}
+
+VecElem Vector::
+operator()( int r )
+{
+	assert(r);
+
+	return VecElem( *this, r );
+}
+
+	/* assign changes the matrix, it does not create a new one! */
+double Vector::
+assign( int rownum, double d )
+{
+	assert(r);
+
+	if( rownum > row() || rownum <= 0 ) {
+		cerr << "Warning: trying to assign out of bounds" << endl;
+		cerr << "row " << rownum << endl;
+		cerr << "Vector size " << row() << endl;
+		abort();
+	}
+
+	if( r->count == 1 ) {
+			/* Don't need to create a new matrix, since we are the only */
+			/*  one pointing to ours 									*/
+	}
+	else {
+		VectorInt *vi = new VectorInt( *r );
+		r->unrefer();
+		r = vi->refer();
+	}
+
+	return d;
+}
+
+
+VectorInt::
+VectorInt( int sx )
+	: vec( new double[sx] ), count(0)
+{ }
+
+VectorInt::
+VectorInt( int sx, double *, int )
+	: vec( new double[sx] ), count(0)
+{
+}
+
+VectorInt::
+VectorInt( const VectorInt & )
+	: vec( new double[10] ), count(0)
+{
+}
+
+VectorInt * VectorInt::
+refer()
+{
+	count ++;
+	return this;
+
+	// cout << "Refering vec" << endl;
+}
+
+void VectorInt::
+unrefer()
+{
+	count--;
+
+	if( count == 0 ) {
+		delete this;
+	}
+
+	// cout << "Unrefering vec" << endl;
+}
+
+VectorInt::
+~VectorInt()
+{
+	delete vec;
+	vec = 0;
+}
+
+VecElem::
+VecElem( Vector &vec, int r )
+	: v(vec), row(r)
+{
+	if( r < 1 || r > vec.row() ) {
+		cerr << "Trying to access vector element out of bounds" << endl;
+		abort();
+	}
+}
+
+VecElem::
+VecElem( const VecElem &elem )
+	: v(elem.v), row(elem.row)
+{}
+
+VecElem::
+operator double()
+{
+	assert( v.r->vec );
+	return *v.r->vec;
+};
+
+double VecElem::
+operator=( double d )
+{
+	return v.assign( row, d );
+}
+
+
+
+
+
+int makeforms( Vector cen, Vector **a, Vector **b );
+
+main()
+{
+	Vector *a[8], *b[8], disp(3);
+	Vector cen(3), cen2(3);
+	int i, j;
+
+	if (makeforms (cen,a,b) != 10)
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+
+
+}
+
+int
+makeforms( Vector cen, Vector **a, Vector **b)
+{
+	return 10;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/copy1.C b/gcc/testsuite/g++.old-deja/g++.law/copy1.C
new file mode 100644
index 00000000000..cd237068628
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/copy1.C
@@ -0,0 +1,66 @@
+// GROUPS passed copy-ctors
+#include <stdio.h>
+
+int pass = 0;
+class name {
+  int namestuff;
+public:
+  name() {
+    namestuff = 111;
+  }
+  name(const name& subject);
+  
+  name & operator = (const name& right) {
+    this->namestuff = right.namestuff;
+    return *this;
+  }
+  
+  ~name() {
+    ;
+  }
+};
+
+name::name(const name& subject) {
+    pass = 1;
+}
+
+class person {
+  int personstuff;
+  name personname;
+public:
+  person() {
+    ;
+    personstuff = 222;
+  }
+  ~person() {
+    ;
+  }	
+  void print() {
+    ;
+  }
+  
+};
+
+void
+test(person argp)
+{
+  person testp;
+  
+  ;
+  argp.print();
+  testp = argp;
+  argp.print();
+  testp.print();
+  ;
+}
+
+main()
+{
+  person mainp;
+  test(mainp);
+  if (pass)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/copy2.C b/gcc/testsuite/g++.old-deja/g++.law/copy2.C
new file mode 100644
index 00000000000..3935cfd557d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/copy2.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed copy-ctors
+// copy file
+// From: Vivek Khera <khera@cs.duke.edu>
+// Date:     Mon, 15 Nov 1993 16:02:18 -0500
+// Subject:  g++ 2.5.3 fails to automatically generate default initializer
+// Message-ID: <9311152102.AA21248@thneed.cs.duke.edu>
+
+class String
+{
+  private:
+    char a[100];
+    int len;
+  public:
+    String();
+};
+
+String::String()
+{
+    len = 0;
+}
+
+
+struct List
+{
+    String item[100];
+    int num_items;
+//    List();                   // uncomment this line to let compile work
+};
+
+int
+main(int argc, char **argv)
+{
+    List a;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors1.C b/gcc/testsuite/g++.old-deja/g++.law/ctors1.C
new file mode 100644
index 00000000000..79ca94aa9b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors1.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// From: rac@qedinc.com (Robert Clark)
+// Date:     Tue, 14 Dec 93 10:45:50 PST
+// Subject:  bug in g++ 2.5.7 Array of objects
+// Message-ID: <9312141845.AA09188@annapurna.qedinc.com>
+
+
+class POOL {
+public:
+  POOL();
+};
+
+struct VAL_LIST {
+  POOL   pool[2];
+};
+
+VAL_LIST baz;
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors10.C b/gcc/testsuite/g++.old-deja/g++.law/ctors10.C
new file mode 100644
index 00000000000..213b7988b48
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors10.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <9302052351.AA10789@harvey>
+// From: greg@qualcomm.com (Greg Noel)
+// Subject: bug019.cc
+// Date: Fri, 5 Feb 93 15:51:42 -0800
+
+#include <iostream.h>
+
+class Class
+{
+        class Err : public ostream
+        {
+        public:
+                Err(void) : ostream() { }
+                ~Err(void) { }
+        };
+public:
+        //template<class T> Err& operator << (const T x) { return Err() << x; }
+        Err& operator << (const char *x) { return Err() << x; }// ERROR - .*
+private:
+        char x;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors11.C b/gcc/testsuite/g++.old-deja/g++.law/ctors11.C
new file mode 100644
index 00000000000..8472fb89394
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors11.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <9302081631.AA14744@tera.com>
+// From: rrh@tera.com (Robert R. Henry)
+// Date: Mon, 8 Feb 93 08:31:39 PST
+extern "C" void printf(const char *,...);
+class A{
+public:
+  inline A(int x){printf("constructing A with %d\n", x);}
+};
+
+class B:public A{
+private:
+public:
+}; // ERROR - non-default constructor
+
+main()
+{
+  B(10);// ERROR - B doesn't have a constructor taking int
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors12.C b/gcc/testsuite/g++.old-deja/g++.law/ctors12.C
new file mode 100644
index 00000000000..37d45884398
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors12.C
@@ -0,0 +1,33 @@
+// GROUPS passed constructors
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream.h>
+
+#define MAGIC 7654
+
+class complex {
+        double re;
+        double im;
+        int magic;
+        static int count;
+public:
+        complex() { re=im=0; magic=MAGIC; }
+        complex(double d) { re=d; im=0; magic=MAGIC; }
+        complex(double d, double d2) {re=d; im=d2; magic=MAGIC; }
+        ~complex() {if(magic!=MAGIC) {printf("FAIL\n");exit(0);}}
+        friend ostream& operator << (ostream& o, const complex& c)
+                { return o << "(" << c.re << "," << c.im << ")"; }
+};
+
+int complex::count=0;
+
+main()
+{
+        complex v[6] = {1, complex(1,2), complex(), 2 }; // ARM Sect. 12.6.1
+        int i;                                           // page 289
+
+        for(i=0; i<6; i++) ;
+	printf ("PASS\n");
+
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors13.C b/gcc/testsuite/g++.old-deja/g++.law/ctors13.C
new file mode 100644
index 00000000000..a0bb6f2008f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors13.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed constructors
+#include <iostream.h>
+
+class A {
+   A() {}    // private constructor// ERROR - .*
+}; // WARNING - all member functions are private
+
+main() {
+  A* a = new A();// ERROR - .*
+  if (a) {
+     cout << "a != NULL\n";
+  } else {
+     cout << "a == NULL\n";
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors14.C b/gcc/testsuite/g++.old-deja/g++.law/ctors14.C
new file mode 100644
index 00000000000..49abdf79edb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors14.C
@@ -0,0 +1,43 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <199301310203.AA22417@oak.ucsc.edu>
+// From: "Dean R. E. Long" <dlong@cse.ucsc.edu>
+// Subject: problems with default constructors
+// Date: Sat, 30 Jan 1993 18:03:32 -0800
+
+class A0 {
+};
+
+class A1 {
+public:
+    A1(void) {}
+};
+
+class A2 {
+    A1 a;
+};
+
+class B0 : public A0 {
+public:
+    B0(void) {}
+    B0(int)  {}
+    B0(char) : A0() {}
+    B0(short) : A0() {}
+};
+
+class B1 : public A1 {
+public:
+};
+
+class B2 : public A2 {
+public:
+    B2(void) : A2() {}
+    B2(int)  : A2() {}
+};
+
+class C : public B1 {
+public:
+    C(void) : B1() {}
+    C(int)  : B1() {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors15.C b/gcc/testsuite/g++.old-deja/g++.law/ctors15.C
new file mode 100644
index 00000000000..32da1418f3d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors15.C
@@ -0,0 +1,26 @@
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <9303270404.28207@munta.cs.mu.OZ.AU>
+// From: fjh@cs.mu.oz.au
+// Subject: bug with new/delete of multidimensional array
+// Date: Sat, 27 Mar 93 14:04:52 EST
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int construct = 0;
+
+class Element {
+public:
+    Element() { construct++; if (construct > 6) {printf ("FAIL\n"); exit(1);}}
+    ~Element() { }
+};
+
+typedef Element array[2];
+
+int main() {
+    array *x;
+    x = new array[3];
+    delete x;
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors16.C b/gcc/testsuite/g++.old-deja/g++.law/ctors16.C
new file mode 100644
index 00000000000..4da7f058b5a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors16.C
@@ -0,0 +1,49 @@
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <9306021533.AA14347@icepick.jts.com>
+// From: roland@jts.com (Roland Knight )
+// Subject: gcc 2.4.1 bug
+// Date:   Wed, 2 Jun 1993 11:33:34 -0400
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char stuff[50];
+char *p = stuff;
+
+class A {
+public:
+    A() { *p++ = 'A';}
+};
+
+class B {
+public:
+    B() { *p++ = 'B'; }
+};
+
+class C : public A, public B {
+public:
+    C() : B(), A() { *p++ = 'C'; }
+};
+
+class D : public A, public B {
+public:
+    D() : B() { *p++ = 'D'; }
+};
+
+class E : public A, public B {
+public:
+    E() { *p++ = 'E'; }
+};
+
+
+main() {
+    C c;
+    D d;
+    E e;
+    if (strncmp ("ABCABDABE", stuff, 9))
+	printf ("FAIL\n");
+    else
+	printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors17.C b/gcc/testsuite/g++.old-deja/g++.law/ctors17.C
new file mode 100644
index 00000000000..41e3217faf9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors17.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <199306151813.gD28471@mail.Germany.EU.net>
+// From: stephan@ifconnection.de (Stephan Muehlstrasser)
+// Subject: gcc 2.4.3.1: illegal constructor call not rejected
+// Date: Tue, 15 Jun 1993 18:34:14 +0200 (MET DST)
+
+
+#include <fstream.h>
+
+class X : public ifstream {
+    public:
+      X(int a, char *b) {} // ERROR - candidate
+}; // ERROR - candidate
+main()
+{
+    X *y = new X(10, "123");
+    // the compiler must reject this constructor call:
+    X *x = new X("abc");// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors18.C b/gcc/testsuite/g++.old-deja/g++.law/ctors18.C
new file mode 100644
index 00000000000..e7a666e3e80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors18.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed constructors
+class test1 {
+};
+
+template<class T>
+class GC_PTR {
+public:
+  GC_PTR(T &a) {}
+};
+
+
+void
+gotPtrs(GC_PTR<test1> r1)
+{
+}
+
+static void
+short_alloc(int n)
+{
+        test1 here;
+        GC_PTR<test1> foo = here;   // This works fine.
+
+        gotPtrs(here);              // Compile error from this
+        // No constructor named `GC_PTR` in visible scope
+        // conversion between incompatible aggregate types requested
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors19.C b/gcc/testsuite/g++.old-deja/g++.law/ctors19.C
new file mode 100644
index 00000000000..25c58d6954f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors19.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// From: mkohtala@vinkku.hut.fi
+// Date: Tue, 5 Oct 1993 19:31:16 +0200
+// Message-Id: <199310051731.AA12260@lk-hp-11.hut.fi>
+// Subject: Nested class constructor calling bug
+
+class X
+{
+  public:
+    class Y
+    {
+      public:
+        Y(int i) : a(i) {}
+        int a;
+    };
+    static void f(Y y);
+};
+
+void X::f(X::Y y)
+{
+}
+
+int
+main()
+{
+    X::Y y = X::Y(1);   // Tries to call ctor Y instead of X::Y
+    X::f(X::Y(2));      // Tries to call Y instead of X::Y
+
+    return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors2.C b/gcc/testsuite/g++.old-deja/g++.law/ctors2.C
new file mode 100644
index 00000000000..8ceb5395f69
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors2.C
@@ -0,0 +1,69 @@
+// GROUPS passed constructors
+// Message-Id: <m0p8Am6-0002fCC@neal.ctd.comsat.com>
+// Date: Fri, 10 Dec 93 11:33 EST
+// From: neal@ctd.comsat.com (Neal Becker)
+// Subject: serious problems with static constructors
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define CONST const
+
+class Sig {
+
+public:
+
+  enum Type { Byte_t, Word_t, Long_t, Float_t, Double_t, Complex_t, ComplexLong_t, Bad_t };
+
+private:
+
+  Type T;
+
+public:
+
+  static CONST char *ByteMagic, *WordMagic, *LongMagic,
+    *FloatMagic, *DoubleMagic, *ComplexMagic, *ComplexLongMagic, *BadMagic;
+
+  struct SigTable {
+    Type T;
+    CONST char* Magic;
+  };
+
+  static CONST SigTable sigTable[];
+
+};
+
+CONST char 
+*Sig::ByteMagic = "BYTE",
+*Sig::WordMagic = "WORD",
+*Sig::LongMagic = "LONG",
+*Sig::FloatMagic = "FLOA",
+*Sig::DoubleMagic = "DOUB",
+*Sig::ComplexMagic = "COMP",
+*Sig::ComplexLongMagic = "CMPL",
+*Sig::BadMagic = NULL;
+
+
+CONST Sig::SigTable Sig::sigTable[] = {
+  { Byte_t, ByteMagic },
+  { Word_t, WordMagic },
+  { Long_t, LongMagic },
+  { Float_t, FloatMagic },
+  { Double_t, DoubleMagic },
+  { Complex_t, ComplexMagic },
+  { ComplexLong_t, ComplexLongMagic },
+  { Bad_t, BadMagic }
+};
+
+main() {
+  if (strcmp (Sig::sigTable[0].Magic, "BYTE")
+      || strcmp (Sig::sigTable[1].Magic, "WORD")
+      || strcmp (Sig::sigTable[2].Magic, "LONG")
+      || strcmp (Sig::sigTable[3].Magic, "FLOA")
+      || strcmp (Sig::sigTable[4].Magic, "DOUB")
+      || strcmp (Sig::sigTable[5].Magic, "COMP"))
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors20.C b/gcc/testsuite/g++.old-deja/g++.law/ctors20.C
new file mode 100644
index 00000000000..34dbf7bf023
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors20.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <9311011758.AA25157@thneed.cs.duke.edu>
+// From: Vivek Khera <khera@cs.duke.edu>
+// Subject: g++ 2.5.0 fails to automatically generate default initializer
+// Date: Mon, 01 Nov 1993 12:58:34 -0500
+
+class String
+{
+  private:
+    char a[100];
+    int len;
+  public:
+    String();
+};
+
+String::String()
+{
+    len = 0;
+}
+
+
+struct List
+{
+    String item[100];
+    int num_items;
+//    List();                   // uncomment this line to let compile work
+};
+
+int
+main(int argc, char **argv)
+{
+    List a;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors21.C b/gcc/testsuite/g++.old-deja/g++.law/ctors21.C
new file mode 100644
index 00000000000..3f3b3df522a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors21.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// From: mln@tera.com (Mark Niehaus)
+// Subject: g++-2.5.2 -- private copy ctor hides public ctor
+// Date: Mon, 8 Nov 93 10:14:50 PST
+
+class A {
+    A(A&);
+  public:
+    A();
+};
+
+class B {
+    A a;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors3.C b/gcc/testsuite/g++.old-deja/g++.law/ctors3.C
new file mode 100644
index 00000000000..6658764fe47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors3.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <m0oxRi1-0002fPC@nesmith.pactitle.com>
+// From: genehi@nesmith.pactitle.com (Gene Hightower)
+// Subject: Apparent bug in g++ 2.5.2
+// Date: Wed, 10 Nov 93 18:24 PST
+
+class One {
+  public:
+    One() {}
+};
+
+template<class T> class Two : public One {
+};
+
+class Three {
+};
+
+class Four  {
+    Two<Three>  x[1];
+};
+
+class Five {
+    Four        y;
+
+  public:
+    Five() {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors4.C b/gcc/testsuite/g++.old-deja/g++.law/ctors4.C
new file mode 100644
index 00000000000..dc1f08beaf2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors4.C
@@ -0,0 +1,27 @@
+// Special g++ Options: -w
+// GROUPS passed constructors
+// ctors file
+// Message-Id: <ACHILLES.92Nov25192123@i90s8.ira.uka.de>
+// From: Alf-Christian Achilles <achilles@ira.uka.de>
+// Subject: g++ 2.3.1 rejects initialization with object of derived class
+// Date: 25 Nov 92 19:21:23
+
+extern "C" int printf (const char *, ...);
+
+class A {
+public:
+  virtual void foo() {};
+};
+
+class B : public A {
+public:
+  void foo() {};
+};
+
+main ()
+{
+  B b;
+  A a = b;  //unjustified error: unexpected argument to constructor `A'
+  printf ("PASS\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors5.C b/gcc/testsuite/g++.old-deja/g++.law/ctors5.C
new file mode 100644
index 00000000000..3fc58041192
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors5.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctors file
+// Subject: bug in handling static const object of the enclosing class
+// Date: Tue, 1 Sep 92 10:38:44 EDT
+
+class X
+{
+  private:
+    int x;
+  public:
+    static const X x0;
+    X( int );
+}; // ERROR - candidate
+
+class Y
+{
+  private:
+    X xx;
+  public:
+    Y();
+}
+X::X( int xi )
+{// ERROR -  return.*
+    x = xi;
+}
+
+const X X::x0( 0 );
+
+Y::Y()
+{// ERROR -  no mat
+    xx = X::x0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors6.C b/gcc/testsuite/g++.old-deja/g++.law/ctors6.C
new file mode 100644
index 00000000000..a46f4e89bdb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors6.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed constructors
+#include <complex.h>
+
+double foo(double_complex *a)
+{
+  return 0.0;
+}
+
+
+double bar(void)
+{
+  double_complex v[10];
+  return foo(v);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors7.C b/gcc/testsuite/g++.old-deja/g++.law/ctors7.C
new file mode 100644
index 00000000000..4f056cc072c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors7.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed constructors
+// ctors file
+// Message-Id: <3JUL199214462623@envmsa.eas.asu.edu>
+// From: peckham@envmsa.eas.asu.edu (Bill)
+// Subject: const constructor causes crash
+// Date: Fri, 3 Jul 1992 21:46:00 GMT
+
+class base_t {
+public:
+   virtual char *name () { return "base_t"; }
+
+   base_t ();
+   virtual ~base_t ();
+};
+
+class d1_t : public base_t {
+public:
+   virtual char *name () { return "d1_t"; }
+
+   //   The const keyword on this constructor is an error,  but  it shouldn't
+   // cause the compiler to crash.
+
+   d1_t () const;// ERROR - .*const.*
+   virtual ~d1_t ();
+};
+
+class d2_t : public base_t {
+public:
+   virtual char *name () { return "d2_t"; }
+
+   d2_t (int);
+   virtual ~d2_t ();
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors8.C b/gcc/testsuite/g++.old-deja/g++.law/ctors8.C
new file mode 100644
index 00000000000..f773d093633
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors8.C
@@ -0,0 +1,24 @@
+// GROUPS passed constructors
+// ctor file
+// Message-Id: <199212160609.AA18247@phecda.cs.sfu.ca>
+// From: Taj Khattra <khattra@cs.sfu.ca>
+// Subject: gcc 2.3.1 global ctor bug ?
+// Date: Tue, 15 Dec 92 22:09:37 PST
+
+#include <stdio.h>
+
+struct foo {
+     foo() : index(-1) {}
+     int index;
+};
+
+foo *arr = new foo[2];
+
+main()
+{
+  if (arr[0].index == -1
+      && arr[1].index == -1)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/ctors9.C b/gcc/testsuite/g++.old-deja/g++.law/ctors9.C
new file mode 100644
index 00000000000..280b429c352
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/ctors9.C
@@ -0,0 +1,39 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed constructors
+// ctors file
+// Message-Id: <9301132030.AA05210@cs.rice.edu>
+// From: dougm@cs.rice.edu (Doug Moore)
+// Subject: 2.3.3: accepts ctor-less derived class of ctor-ful base class
+// Date: Wed, 13 Jan 93 14:30:21 CST
+// Note: It gives an error now.  But not a very good one.
+
+struct Foo
+{
+  Foo(int aa);
+  int a;
+  const Foo* operator-> () const {return this;}
+};
+
+Foo::Foo(int aa)
+:a(aa)
+{ }
+
+
+struct var_Foo: public Foo
+{
+  var_Foo* operator-> () {return this;}
+};// ERROR -  base.*// ERROR -  in class.*
+
+int blort(Foo& f)
+{
+  return f->a;
+};
+
+main()
+{
+  var_Foo b(2);// ERROR - 
+  b->a = 0;
+  int x = blort(b);
+  return x;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt1.C b/gcc/testsuite/g++.old-deja/g++.law/cvt1.C
new file mode 100644
index 00000000000..82641242b49
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt1.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// From: dak@pool.informatik.rwth-aachen.de
+// Date:     Sun, 21 Nov 93 17:40:32 +0100
+// Subject:  g++ mixes up array dimensions with new
+// Message-ID: <9311211640.AA11787@messua>
+
+main()
+{
+        int (*a)[5] = new int[6][5];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt10.C b/gcc/testsuite/g++.old-deja/g++.law/cvt10.C
new file mode 100644
index 00000000000..01f1e807148
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt10.C
@@ -0,0 +1,60 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <CC7oHn.B4F@izf.tno.nl>
+// From: tom@izfcs.izf.tno.nl (Tom Vijlbrief)
+// Subject: g++ 2.4.5 has problems with NON virtual shared base classes
+// Date: Mon, 23 Aug 1993 12:10:34 GMT
+
+
+#include        <stdio.h>
+
+#define FAIL
+
+class Base {
+public:
+  Base() { printf("Base::Base\n"); }
+  virtual ~Base() { printf("Base::~Base\n"); }
+  virtual void v() { printf("Base::v\n"); }
+};
+
+class Base2 {
+public:
+  Base2() { printf("Base2::Base2\n"); }
+  virtual ~Base2() { printf("Base2::~Base2\n"); }
+  virtual void v() { printf("Base2::v\n"); }
+};
+
+class A: public Base {
+public:
+  A() { printf("A::A\n"); }
+  ~A() { printf("A::~A\n"); }
+  virtual void va() { printf("A::va\n"); }
+};
+
+#ifdef FAIL
+class B: public Base {
+#else
+class B: public Base2 {
+#endif
+public:
+  B() { printf("B::B\n"); }
+  ~B() { printf("B::~B\n"); }
+  virtual void vb() { printf("B::vb\n"); }
+};
+
+class C: public A, public B {
+public:
+  C() { printf("C::C\n"); }
+  ~C() { printf("C::~C\n"); }
+  void va() { printf("C::va\n"); }
+};
+
+
+main()
+{
+  C *cp= new C;
+  cp->va();
+  delete cp;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt11.C b/gcc/testsuite/g++.old-deja/g++.law/cvt11.C
new file mode 100644
index 00000000000..321368caa74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt11.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Date: Tue, 10 Nov 92 11:08:08 PST
+// From: rrh@tera.com (Robert R. Henry)
+// Message-Id: <9211101908.AA13557@tera.com>
+// Subject: type cast of qualified const member breaks g++2.3.1
+
+#include <stdio.h>
+
+class Thing{
+private: int x;
+   public: const int N = -1; // ERROR - bad initialization
+  Thing(int y);
+};
+
+class Bar{ public: void doit(void); };
+
+void Bar::doit(void)
+{
+  int i, j;
+  i = Thing::N;
+  printf("i = %d\n", i);
+
+  j = (int)Thing::N;
+  printf("i = %d\n", j);
+}
+Thing::Thing(int y) { x = y; }
+main(){ Bar x; x.doit(); }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt12.C b/gcc/testsuite/g++.old-deja/g++.law/cvt12.C
new file mode 100644
index 00000000000..cce2d9bcda0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt12.C
@@ -0,0 +1,29 @@
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9301071708.AA03432@muresh.et.tudelft.nl>
+// From: stravers@muresh.et.tudelft.nl (Paul Stravers)
+// Subject: conversion method never called
+// Date: Thu, 7 Jan 93 18:08:33 +0100
+
+#include <stdio.h>
+
+class test
+{
+   double d;
+   int    i;
+public:
+   test(double dd,int ii) {d=dd; i=ii;} // constructor
+   operator int&()        {return i;} // define a conversion from test to int&
+   int& geti()            {return i;} // same thing, but different
+};
+
+main()
+{
+   test t(3.14, 5);  // Create an object t of class "test"
+   int x = (int&)t;  // This should call operator int&() but it does not ...
+   int y = t.geti(); // x and y should both be 5 ...
+   if (x == 5 && y == 5)
+     printf ("PASS\n");
+   else
+     printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt13.C b/gcc/testsuite/g++.old-deja/g++.law/cvt13.C
new file mode 100644
index 00000000000..d2f04cc9ec6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt13.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <ISHAI.93Mar26102509@cs73.technion.ac.il>
+// From: ishai@cs.technion.ac.il (& Ben-Aroya)
+// Subject: Type conversion problem.
+// Date: Fri, 26 Mar 1993 08:25:09 GMT
+
+typedef int array[10];
+
+void f(array &arg)
+{
+}
+
+main()
+{
+    array var;
+    f(var);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt14.C b/gcc/testsuite/g++.old-deja/g++.law/cvt14.C
new file mode 100644
index 00000000000..2cf02359f4a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt14.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9303241504.AA25988@spock.orl.mmc.com>
+// Subject: internal compiler error
+// Date: Wed, 24 Mar 1993 10:04:06 -0500
+// From: "Malcolm C. Strickland" <chucks@orl.mmc.com>
+
+
+        main()
+        {
+          double *d;
+          d = new double(10);
+          return 1;
+        }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt15.C b/gcc/testsuite/g++.old-deja/g++.law/cvt15.C
new file mode 100644
index 00000000000..967cbb6a6a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt15.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9308051530.AA05922@NeoSoft.Com>
+// From: daniels@sugar.neosoft.com (Brad Daniels)
+// Subject: g++ 2.4.5:  Conversion operators to complex types don't work either
+// Date: Thu, 5 Aug 93 15:30:04 CDT
+
+class bar { int x; public: bar() : x(1){} };
+
+class foo {
+    bar a, b;
+public:
+    foo(bar i, bar j) : a(i),b(j) {}
+    operator const bar() const { return a; }
+    const bar f() { return *this; }
+    void g(foo &c) { b = c; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt16.C b/gcc/testsuite/g++.old-deja/g++.law/cvt16.C
new file mode 100644
index 00000000000..c539c96e536
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt16.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9304121647.AA25819@tnt>
+// From: mclaugh@tnt.acsys.com (Mark A. McLaughlin)
+// Subject: g++ bug
+// Date: Mon, 12 Apr 93 10:47:01 MDT
+
+#include <iostream.h>
+
+class B {
+};
+
+class A : public B {
+   short s;
+public:
+   A(short _s = 0) { s = _s; }
+   operator const short &() const { return s; }
+};
+
+   int
+main() {
+   A a(37);
+   //cout << a << endl;
+   cout << (short)a << endl;
+
+   return 0;
+}  // main
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt17.C b/gcc/testsuite/g++.old-deja/g++.law/cvt17.C
new file mode 100644
index 00000000000..6ddffe29d28
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt17.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9305210124.AA02409@kato.cs.brown.edu>
+// From: pcm@cs.brown.edu (Peter C. McCluskey)
+// Subject: illegal code compiles silently
+// Date: Thu, 20 May 93 21:24:22 -0400
+
+
+
+class Point {};
+class Line_Segment{ public: Line_Segment(const Point&){} };
+class Node { public: Point Location(){ Point p; return p; } };
+
+main()
+{
+   Node** node1;
+   Line_Segment(node1->Location()); // intended (*node1)// ERROR - .*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt18.C b/gcc/testsuite/g++.old-deja/g++.law/cvt18.C
new file mode 100644
index 00000000000..79ea67985d5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt18.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9307090042.AA28565@uluru.Stanford.EDU>
+// From: interran@uluru.stanford.edu (John Interrante)
+// Subject: gcc 2.4.5 on sparc-sun-sunos4.1.2: automatic conversion functions
+// Date: Thu, 8 Jul 93 17:42:12 PDT
+
+class Token {
+public:
+    operator const void*() const;
+    int operator !=(int code) const;
+private:
+    int code_;
+};
+
+extern Token next_token();
+
+void foo(Token token) {
+    if (token && token != '{') {}
+
+    const int inside_body = 1;
+    if (inside_body && (token = next_token())) {}
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt19.C b/gcc/testsuite/g++.old-deja/g++.law/cvt19.C
new file mode 100644
index 00000000000..b15bdfd705a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt19.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <1166.9307131600@ace.eng.cam.ac.uk>
+// From: ajp@eng.cam.ac.uk
+// Date: Tue, 13 Jul 93 17:00:44 BST
+
+
+class B {};
+
+class A {
+  public:
+    operator const B*() const {
+        return b;
+    }
+  private:
+    B* b;
+};
+
+
+main()
+{
+    A a;
+    if (a!=0) {
+    }
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt2.C b/gcc/testsuite/g++.old-deja/g++.law/cvt2.C
new file mode 100644
index 00000000000..3a5a1b94303
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt2.C
@@ -0,0 +1,42 @@
+// GROUPS passed conversions
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream.h>
+#include <fstream.h>
+
+extern "C" {
+int strncmp (const char *, const char *, size_t);
+}
+
+class cvec {
+public:
+        ~cvec(){ delete s; }
+        cvec(const char*x) { s = new char[strlen(x)+1]; strcpy(s, x); }
+	cvec(const cvec& c) { s = new char[strlen(c.s)+1]; strcpy(s, c.s); }
+        operator const char*() { return s; }
+private:
+        char *s;
+};
+
+cvec
+B(const char* a)
+{
+        return a;
+}
+
+void
+A(const char* s)
+{
+        // s still ok here
+        ifstream inf(s);
+	if (strncmp ("aaa", s, 3))
+	  printf ("FAIL\n");
+	else
+	  printf ("PASS\n");
+}
+
+main()
+{
+        A(B("aaa"));
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt20.C b/gcc/testsuite/g++.old-deja/g++.law/cvt20.C
new file mode 100644
index 00000000000..72abbb74807
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt20.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9307152250.AA24812@volterra>
+// From: rst@ai.mit.edu (Robert S. Thau)
+// Subject: g++ won't convert char[] to char*&
+// Date: Thu, 15 Jul 93 18:50:59 EDT
+
+
+// Compiles fine with Sun CC 2.1
+
+void f(char *& x)
+{// ERROR - location of error
+  x++;
+}
+
+main()
+{
+  f ("foo");// ERROR - init of non-const ref from char*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt21.C b/gcc/testsuite/g++.old-deja/g++.law/cvt21.C
new file mode 100644
index 00000000000..c4516c85e26
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt21.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9307200528.AA02094@legolas>
+// From: Mark Kuzmycz <kuzmycz@deakin.edu.au>
+// Subject: int & conversion operator
+// Date: Tue, 20 Jul 93 15:28:47 EST
+
+class Int
+{
+	public:
+		Int(void);
+		Int(int);
+		Int(const Int&);
+	
+		Int* copy(void) const;
+		
+		operator int&();
+		
+		Int& operator ++(void);
+		Int& operator --(void);
+		
+	private:
+		int value;
+};
+ 
+main()
+{
+  Int data = 2;
+  Int test;
+
+  test = data * 12;
+  data += 1;
+}
+
+// UNKNOWN "FAIL"
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt22.C b/gcc/testsuite/g++.old-deja/g++.law/cvt22.C
new file mode 100644
index 00000000000..9d72a6c4219
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt22.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <93Aug2.163542pdt.26892@franklin.parc.xerox.com>
+// From: Jesse Hull <jhull@parc.xerox.com>
+// Subject: typedef bug
+// Date:   Mon, 2 Aug 1993 16:35:28 PDT
+
+typedef int A[10];
+
+main()
+{
+   int* a1 = new A;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt23.C b/gcc/testsuite/g++.old-deja/g++.law/cvt23.C
new file mode 100644
index 00000000000..626d01c5932
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt23.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9308051209.AA15962@NeoSoft.Com>
+// From: daniels@sugar.neosoft.com (Brad Daniels)
+// Subject: Bug in g++ 2.4.5: Conversion operators to enumerated types don't wor
+// Date: Thu, 5 Aug 93 12:09:09 CDT
+
+enum bar { AAA, BBB };
+
+class foo {
+   bar a, b;
+public:
+   foo(bar i, bar j) : a(i),b(j) {}
+   operator const bar() const { return a; }
+   bar f() { return *this; }
+   void g(foo &c) { b = c; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt3.C b/gcc/testsuite/g++.old-deja/g++.law/cvt3.C
new file mode 100644
index 00000000000..357dd32f254
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt3.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9308122113.AA14119@tnt.acsys.com>
+// From: mclaugh@tnt.acsys.com (Mark A. McLaughlin)
+// Subject: g++ bug
+// Date: Thu, 12 Aug 93 15:13:23 MDT
+
+
+class C { };
+
+void f(C) { }
+
+void g(const C & c) { f(c); }
+
+void h(const C & c) { f(C(c)); }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt4.C b/gcc/testsuite/g++.old-deja/g++.law/cvt4.C
new file mode 100644
index 00000000000..6863c8f74ae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt4.C
@@ -0,0 +1,27 @@
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9308091213.AA11572@emmy.Mathematik.Uni-Dortmund.DE>
+// From: Michael Strauch <strauch@emmy.mathematik.uni-dortmund.de>
+// Subject: Bug in GCC 2.4.5
+// Date: Mon, 9 Aug 93 14:13:50 MESZ
+
+extern "C" int printf (const char *, ...);
+
+int destruct = 2;
+
+  class Test{
+  protected:
+     long x;
+  public:
+     Test(){;}
+     Test(long l) {x=l;}
+     ~Test() {if (--destruct == 0) printf ("PASS\n");}
+  };
+
+  main()
+  {
+     long i=1;
+     Test t;
+
+     t=(Test)i;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt5.C b/gcc/testsuite/g++.old-deja/g++.law/cvt5.C
new file mode 100644
index 00000000000..d244b4f5225
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt5.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <1992Jul31.142856.10082@ericsson.se>
+// From: jonas@ericsson.se (Jonas Nygren)
+// Subject: g++ bug
+// Date: Fri, 31 Jul 1992 14:28:56 GMT
+
+class A {};
+class B : public A {};
+
+B b;
+
+class R{
+public:
+  R() {}
+  operator B&() { return b; }
+};
+
+void f(A&) {}
+
+main(){
+  R r;
+
+  f(r); // problem to cast to B& and then to A&
+}
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt6.C b/gcc/testsuite/g++.old-deja/g++.law/cvt6.C
new file mode 100644
index 00000000000..85d5af80abd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt6.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <9208261851.AA16997@josquin.media.mit.edu>
+// From: bilmes@media.mit.edu
+// Subject: gcc (g++) 2.2.2 constructing nested class from external scope
+// Date: Wed, 26 Aug 92 14:51:17 -0400
+
+
+class foo {
+
+  class bar {
+    int i;
+  public:
+    bar(int j) { i = j; }
+  };
+
+  bar b;
+public:
+  foo() : b(3) {}
+  void test(bar lb) { b = lb; }
+};
+
+
+main() {
+  foo f;
+  f.test(34);  // line 18
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt7.C b/gcc/testsuite/g++.old-deja/g++.law/cvt7.C
new file mode 100644
index 00000000000..34cccd848e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt7.C
@@ -0,0 +1,74 @@
+// GROUPS passed conversions
+// cvt file
+// From: krste@icsi.berkeley.edu (Krste Asanovic)
+// Date: Mon, 24 Aug 92 19:05:10 PDT
+// Message-Id: <9208250205.AA26351@icsib43.ICSI.Berkeley.EDU>
+// Subject: implicit int. convs. from member refs. in switch expressions
+
+#include <stream.h>
+#include <stdio.h>
+
+class A
+{
+public:
+    A(int j) { i = j; }
+    A(A& a) { i = a.i; }
+    operator int() { return i; }
+
+    void assign(int v) { i = v; }
+    int i;
+};
+
+class B
+{
+public:
+    B(A& inArg) : in(inArg), out(0) {}
+
+    A& in;
+    A out;
+
+    void run();
+};
+
+void
+B::run()
+{
+    // I get a "switch quantity not an integer" error for this statement.
+    switch (in)
+    // Replacing above with "switch (int(in))" removes the error.
+    {
+    case 0:
+        out = 1;
+        break;
+    default:
+        out = 0;
+        break;
+    }
+}
+
+main()
+{
+    A a(1);
+
+    A& ar = a;
+
+    A& ar2 = ar;
+
+    // ....but no errors for this switch statement.
+    switch (ar2)
+    {
+    case 1:
+	printf ("PASS\n");
+        break;
+    default:
+	printf ("FAIL\n");
+    }
+
+    B b(a);
+    a.assign(3);
+    b.run();
+    a.assign(0);
+    b.run();
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt8.C b/gcc/testsuite/g++.old-deja/g++.law/cvt8.C
new file mode 100644
index 00000000000..031e76662a4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt8.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed conversions
+// cvt file
+// From: solomon@cs.wisc.edu (Marvin Solomon)
+// Message-Id: <9209141509.AA23124@gjetost.cs.wisc.edu>
+// Subject: g++ 2.2.2 seems to be forgetting a "const"
+// Date: Mon, 14 Sep 92 10:09:58 -0500
+
+extern "C" void printf(...);
+
+struct A {
+        int i;
+};
+
+struct B {
+        int i;
+        operator const A&() const;
+};
+
+B::operator const A&() const {
+        static A a;
+        a.i = i;
+        printf("convert B to A at %x\n", &a);
+        return a;
+}
+
+void f(A &a) { // ERROR - in passing argument
+        printf("A at %x is %d\n", &a, a.i);
+}
+
+main() {
+        B b;
+        b.i = 99;
+        f(b);// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/cvt9.C b/gcc/testsuite/g++.old-deja/g++.law/cvt9.C
new file mode 100644
index 00000000000..e98508d8482
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/cvt9.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed conversions
+// cvt file
+// Message-Id: <m0mVSRj-0000cEC@mobius.veritas.com>
+// From: joe@veritas.com (Joe Fasano)
+// Subject: gcc-2.2.2 bug report
+// Date: Thu, 17 Sep 92 13:27 PDT
+
+typedef int (*widget) ();
+
+class window {
+public:
+  int Isopen ();
+};
+
+widget fp = (widget) &window::Isopen;	// ERROR - // ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dossier1.C b/gcc/testsuite/g++.old-deja/g++.law/dossier1.C
new file mode 100644
index 00000000000..2977f156ecf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dossier1.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// Special g++ Options: -frtti
+// GROUPS passed rtti
+// dossier file
+// Message-Id: <9212021501.AA02484@olympia.miro.com>
+// From: rme@miro.com (Richard M. Emberson)
+// Subject: bug
+// Date: Wed, 2 Dec 92 07:01:30 PST
+
+class Vector {
+  int *p;
+  int sz;
+public:
+  Vector(int );
+  ~Vector();
+
+  int& operator[](int i);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dtors1.C b/gcc/testsuite/g++.old-deja/g++.law/dtors1.C
new file mode 100644
index 00000000000..5c0999c1763
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dtors1.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed destructors
+// friends file
+// From: offline!marc@ai.mit.edu (Marc Duponcheel) (Marc Duponcheel)
+// Date:     Sat, 6 Feb 93 23:31:22 PST
+// Subject:  some 2.2.2 bugs
+// Message-ID: <9302070731.AA002jw@offline.UUCP>
+
+void    f()
+{
+        int     i;
+        i.i::~i();// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dtors2.C b/gcc/testsuite/g++.old-deja/g++.law/dtors2.C
new file mode 100644
index 00000000000..c1f2d423cc4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dtors2.C
@@ -0,0 +1,40 @@
+// GROUPS passed destructors
+#include <stdio.h>
+
+int destruct = 0;
+
+class bla {
+
+public:
+
+        inline bla(char * jim) { ; };
+
+        inline ~bla() { destruct++; if (destruct == 2) printf ("PASS\n");};
+};
+
+class ulk {
+
+public:
+
+        inline ulk() {};
+        inline ~ulk() {};
+
+        void funk(const bla & bob) { ;};
+             //       ^ interestingly, the code compiles right if
+             //         this & is deleted (and therefore the parameter
+             //         passed as value)
+};
+
+main() {
+
+        ulk dumm;
+
+        dumm.funk(bla("laberababa"));  // this compiles correctly
+
+        dumm.funk((bla)"laberababa");  // this produces incorrect code -
+                                       // the temporary instance of
+                                       // the class "bla" is constructed
+                                       // but never destructed...
+
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dtors3.C b/gcc/testsuite/g++.old-deja/g++.law/dtors3.C
new file mode 100644
index 00000000000..ce5aaf335f0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dtors3.C
@@ -0,0 +1,37 @@
+// GROUPS passed destructors
+// dtor file
+// Message-Id: <9301242117.AA04053@cs.rice.edu>
+// From: dougm@cs.rice.edu (Doug Moore)
+// Subject: 2.3.3: premature dtor of temp?
+// Date: Sun, 24 Jan 93 15:17:07 CST
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int killed = 0;
+
+class Foo
+{
+  int a;
+public:
+  Foo() 
+  :a(0) {;}
+  ~Foo() { killed++;}
+  Foo& operator << (int b)
+  {
+    a += b;
+    if (killed)
+      {
+	printf ("FAIL\n");
+	exit (0);
+      }
+    return *this;
+  }
+};
+
+main()
+{
+  Foo() << 1 << 3 << 5 << 7;
+  printf ("PASS\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dtors4.C b/gcc/testsuite/g++.old-deja/g++.law/dtors4.C
new file mode 100644
index 00000000000..028839515b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dtors4.C
@@ -0,0 +1,22 @@
+// GROUPS passed destructors
+#include <stdio.h>
+
+int destruct = 2;
+
+class a {
+        public:
+                char    *p;
+                a(){ ; }
+                ~a(){ destruct--; if (! destruct) printf ("PASS\n");}
+};
+
+a       test(){
+        return a();
+}
+
+main(){
+        a       ai;
+
+        ai = test();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/dtors5.C b/gcc/testsuite/g++.old-deja/g++.law/dtors5.C
new file mode 100644
index 00000000000..9aa2e6d79ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/dtors5.C
@@ -0,0 +1,33 @@
+// GROUPS passed destructors
+// dtor file:
+// Message-Id: <1992Jun25.181845.18886@leland.Stanford.EDU>
+// From: niz@leland.stanford.edu (Jim Nisbet)
+// Subject: gcc 2.2.2 -- c++ bug: destructor called twice (example)
+// Date: 25 Jun 92 18:18:45 GMT
+
+#include <stdio.h>
+
+int things = 0;
+
+class foo {
+public:
+   foo() { things++; }
+   foo(const foo&) { things++; }
+   ~foo() { things--; }
+
+   int i;
+};
+
+void
+sub(foo f) {
+   ;
+};
+
+
+main() {
+   sub(foo());
+   if (things == 0)
+     printf ("PASS\n");
+   else
+     printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum1.C b/gcc/testsuite/g++.old-deja/g++.law/enum1.C
new file mode 100644
index 00000000000..c3ef73d5c4b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum1.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed enums
+class X {
+  struct X1;
+  enum { A= sizeof(X1 *) };     //Causes a problem.
+  struct X1 { int i; };
+  X1 *f(X1 *);
+public:
+  X(void);
+};
+
+X::X1 *X::f(X1 *x) {
+  return x;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum2.C b/gcc/testsuite/g++.old-deja/g++.law/enum2.C
new file mode 100644
index 00000000000..902d8ed56c5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum2.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed enums
+// enum file
+// From: Jeff Gehlhaar <jbg@qualcomm.com>
+// Date:     Mon, 4 Jan 1993 09:20:50 -0700
+// Subject:  Enum bug, affects library
+// Message-ID: <9301041720.AA17340@harvey>
+
+typedef unsigned long __fmtflags;
+class ios {
+  public:
+    typedef __fmtflags fmtflags;
+    enum { skipws=01, left=02, right=04, internal=010,
+           dec=020, oct=040, hex=0100,
+           showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+           scientific=04000, fixed=010000, unitbuf=020000, stdio=040000,
+           dont_close=0x80000000 //Don't delete streambuf on stream destruction
+           };
+
+    fmtflags setf (fmtflags, fmtflags);
+};
+
+// from <iostream.h>
+inline ios& dec(ios& i)
+{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum3.C b/gcc/testsuite/g++.old-deja/g++.law/enum3.C
new file mode 100644
index 00000000000..c7db587bd24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum3.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed enums
+// enum file
+// From: frode@auticon.no
+// Date:     Wed, 13 Jan 93 9:24:50 PST
+// Subject:  enum trouble
+// Message-ID: <"nac.no.001:13.00.93.18.40.52"@nac.no>
+
+typedef enum{on, off} TOGGLE;
+
+class field {
+private:
+  TOGGLE toggle;
+public:
+  virtual void on(void) { toggle = 3; };// ERROR - .*
+  virtual void off(void) { toggle = on; };// ERROR - .*
+};
+
+main()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum4.C b/gcc/testsuite/g++.old-deja/g++.law/enum4.C
new file mode 100644
index 00000000000..f763656441f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum4.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// GROUPS passed enums
+// enum file
+// From: dougm@cs.rice.edu (Doug Moore)
+// Date:     Thu, 18 Mar 93 00:14:57 CST
+// Subject:  2.3.3:Inconsistent behavior for enum conversions
+// Message-ID: <9303180614.AA12123@cs.rice.edu>
+
+enum Enum {enumerator1, enumerator2};
+
+struct Struct
+{
+  int i;
+      int getI(Enum) {return i;} // ERROR - candidates
+};
+
+int funct (Enum)
+{
+  return 0;
+}
+
+int main()
+{
+  Enum e = enumerator1;
+  Struct s;
+  int x = funct(e+1);// ERROR - .*
+  int y = s.getI(e+1);// ERROR - .*
+  return x+y;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum5.C b/gcc/testsuite/g++.old-deja/g++.law/enum5.C
new file mode 100644
index 00000000000..7f86e2c0eb7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum5.C
@@ -0,0 +1,234 @@
+// Build don't link: 
+// GROUPS passed enums
+// excess errors test - XFAIL *-*-*
+// enum file
+// From: Peter Samuelson <psamuels@osiris.ac.hmc.edu>
+// Date:     Tue, 2 Nov 1993 23:44:34 -0800 (PST)
+// Subject:  compiler error 192
+// Message-ID: <199311030744.XAA23409@osiris.ac.hmc.edu>
+
+#include <iostream.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* My program to generate D&D characters
+*  10/25/93
+*/
+
+//prototypes
+int rndshift();
+int dice(int times, int sides);
+void initialize(struct Crctr &character);
+void cleararray(char thearray[24]);
+void input(struct Crctr &character);
+void rollscores(struct Crctr &character);
+void output(struct Crctr &character);
+
+int main()
+{
+  enum goopes
+    {
+      cleric, druid, fighter, knight, paladin, avenger, magicuser, thief,
+      dwarf, halfelf, elf, halfling, mystic, ranger, scout, monster,
+      immortal, special
+    };
+
+  enum alignments
+    {
+      lawful, neutral, chaotic
+    };
+
+  struct savingthrows
+    {
+      int psn_dth, wands, petr_paral, breath, rod_staff_spell;
+    };
+
+  struct abilities
+    {
+      int str, ite, wis, dex, con, cha;
+    };
+  struct valuables
+    {
+      char type[16];
+      int value;
+    };
+  struct money
+    {
+      int pp, gp, ep, sp, cp;
+      valuables gems[24], jewelry[24];
+    };
+
+  struct Crctr
+    {
+      char dm[24], campaign[24], name[24], player[24];
+      goopes goop = fighter;// ERROR - .*
+      alignments alignment;
+      int level, maxhit, hitpoints, ac;
+      abitities scores;// ERROR - .*
+      savingthrows saves;
+      money wealth;
+      int experience;
+      float bonus;
+    };
+  
+  Crctr character;
+
+  cout << "The D&D Character generator!!" << endl;
+  
+  rndshift();
+
+  initialize(character);// ERROR - .*
+  input(character);
+  rollscores(character);
+  output(character);
+
+  cout << "Thank you for using this program." << endl;
+  cout << "Copyright 1993, Chase Enterprises, Inc." << endl;
+  cout << "D&D and Dungeons and Dragons are registered trademarks" << endl;
+  cout << "of TSR, Inc." << endl;
+} //end of main
+
+
+void initialize(Crctr &character)
+{
+  cleararray(character.dm);
+  cleararray(character.campaign);
+  cleararray(character.name);
+  cleararray(character.player);
+  character.level = 0;
+  character.maxhit = 0;
+  character.hitpoints = 0;
+  character.ac = 9;
+  character.experience = 0;
+  character.bonus = 0.0;
+} //end of initialize
+
+void cleararray(char thearray[])
+{
+  for (int i = 0 ; i < 24 ; i++)
+    thearray[i] = 0;
+} //end of cleararray
+
+void input(Crctr &character)
+{
+  cout << "Please input name of the Dungeon Master." << endl;
+  cin  >> character.dm;
+  cout << endl << "Pleas input the name of the campaign." << endl;
+  cin  >> character.campaign;
+  cout << endl << "Please input the name of the character." << endl;
+  cin  >> character.name;
+  cout << endl << "Please input player name." << endl;
+  cin  >> character.player;
+  cout << endl << "Enter desired goop." << endl;
+  cin  >> character.goop;
+  cout << endl << "Enter desired alignment." << endl;
+} //end of input
+
+void rollscores(Crctr &character)
+{
+  character.scores.str = dice(3,6);
+  character.scores.ite = dice(3,6);
+  character.scores.wis = dice(3,6);
+  character.scores.dex = dice(3,6);
+  character.scores.con = dice(3,6);
+  character.scores.cha = dice(3,6);
+  character.level = 1;
+
+  switch (character.goop)
+    {
+    case fighter:
+    case dwarf:
+    case half-elf:
+      character.maxhit = dice(1,8);
+      character.hitpoints = character.maxhit;
+      break;
+    case cleric:
+    case elf:
+    case halfling:
+    case mystic:
+    case scout:
+      character.maxhit = dice(1,6);
+      character.hitpoints = character.maxhit;
+      break;
+    case magic-user:
+    case thief:
+      character.maxhit = dice(1,4);
+      character.hitpoints = character.maxhit;
+      break;
+    default:
+      character.maxhit = 1;
+      character.hitpoints = character.maxhit;
+      break;
+    }
+} //end of rollscores
+
+
+void output(Crctr &character)
+{
+  cout << "Your character is:" << endl;
+  cout << "Your DM:\t" << character.dm << "\t\t\t" << "Campaign: "
+       << character.campaign << endl;
+  cout << "Player's name:\t" << character.player << endl;
+  cout << "Character Name:\t" << character.name << endl;
+  cout << "goop:\t" << character.goop << "\t\t\t" << "Alignment:\t"
+       << character.alignment << endl;
+  cout << "level:\t" << character.level << endl;
+  cout << "Max. HP:\t" << character.maxhit << "\t\t\t" << "Current HP:\t"
+       << character.hitpoints << endl;
+  cout << "Abilities" << "\t\t\t" << "Saves" << endl;
+  cout << endl;
+  cout << "Str:\t" << character.scores.str << "\t\t" << "Poison/Death Ray:\t"
+       << character.saves.psn_dth << endl;
+  cout << "Int:\t" << character.scores.ite << "\t\t" << "Wands:           \t"
+       << character.saves.wands << endl;
+  cout << "Wis:\t" << character.scores.wis << "\t\t" << "Petrification" 
+       << "/Paralysis" << character.saves.petr_paral << endl;
+
+/*      abitities scores;
+      savingthrows saves;
+      money wealth;
+      int experience;
+      float bonus;
+*/
+}
+
+
+int rndshift()
+{
+//Chase Tsang 10/25/93
+//cheap way to shift the random number generator sequence
+//because I can't change the randomseed
+//requires <stdlib.h> and <iostream.h>
+
+int shiftnumber;
+int date;
+int luckynumber;
+
+cout << "Please input the date in 8 digits, no spaces, no other" << endl;
+cout << "characters. (ex 10041974 for October 4, 1974)" << endl;
+cin >> date;
+cout << "Please input your lucky number for today (7 or less" << endl;
+cout << "digits, and positive integer, please)" << endl;
+cin >> luckynumber;
+
+shiftnumber = date / luckynumber;
+
+for (int i = 0; i < shiftnumber; i++)
+        rand();
+return 0;
+}
+
+
+
+int dice(int times, int sides)
+{
+  //dice rolling function, Chase Tsang 10/25/93
+  //requires #include <stdlib.h>
+
+  int total = 0;
+
+  for (int i = 0; i < times; i++)
+    total = total + (rand() % sides) + 1;
+
+  return total;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum6.C b/gcc/testsuite/g++.old-deja/g++.law/enum6.C
new file mode 100644
index 00000000000..65950e9ab0a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum6.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed enums
+// enum file
+// From: polstra!jdp@uunet.uu.net (John Polstra)
+// Date:     Mon, 15 Nov 93 12:14 PST
+// Subject:  GCC 2.5.3 Enum Bitfield Causes Bogus Warning
+// Message-ID: <m0ozAJo-0001EgC@seattle.polstra.uucp>
+
+   enum Color { Red, Green, Blue };
+
+    struct S {
+        Color c : 8;
+    } s;
+
+    void foo()
+    {
+        s.c = Red;      // <== This statement produces the warning message.
+    }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum7.C b/gcc/testsuite/g++.old-deja/g++.law/enum7.C
new file mode 100644
index 00000000000..444fa489b8b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum7.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed enums
+// friends file
+// From: offline!marc@ai.mit.edu (Marc Duponcheel) (Marc Duponcheel)
+// Date:     Sat, 6 Feb 93 23:31:22 PST
+// Subject:  some 2.2.2 bugs
+// Message-ID: <9302070731.AA002jw@offline.UUCP>
+
+class X
+{
+        enum E { A, B };
+static enum E   e;
+};
+enum X::E X::e = A;
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum8.C b/gcc/testsuite/g++.old-deja/g++.law/enum8.C
new file mode 100644
index 00000000000..192a2b4c468
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum8.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// Special g++ Options: -fshort-enums
+// GROUPS passed enums
+  enum E { A = 0x80000000 };
diff --git a/gcc/testsuite/g++.old-deja/g++.law/enum9.C b/gcc/testsuite/g++.old-deja/g++.law/enum9.C
new file mode 100644
index 00000000000..0a3531e1f3b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/enum9.C
@@ -0,0 +1,14 @@
+// Special g++ Options: -fshort-enums
+// GROUPS passed enums
+  extern "C" int printf (const char *, ...);
+
+  enum E { A = 0x80000000, B = 0 };
+
+  main()
+  {
+    if (sizeof (E) != 4)
+	printf ("FAIL\n");
+    else
+	printf ("PASS\n");
+    return 0;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except1.C b/gcc/testsuite/g++.old-deja/g++.law/except1.C
new file mode 100644
index 00000000000..edfb85f7ce9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except1.C
@@ -0,0 +1,29 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions
+// GROUPS passed exceptions
+// except file
+// Message-Id: <9207221230.AA08566@life.ai.mit.edu>
+// From: EWALLACE@endvmtkl.vnet.ibm.com
+// Subject: Bugs
+// Date: Wed, 22 Jul 92 08:29:30 EDT
+
+extern "C" void puts(const char *);
+
+class foo {
+public:
+  class error {};
+
+  void cause_error(void) { throw error(); }
+};
+
+int main(void)
+{
+  foo f;
+  try {
+    f.cause_error();
+  }
+  catch (foo::error) {
+    puts("Caught it.");
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except2.C b/gcc/testsuite/g++.old-deja/g++.law/except2.C
new file mode 100644
index 00000000000..1bf7108146b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions -g
+// GROUPS passed exceptions
+// except file
+// Message-Id: <9211061330.AA29334@ifad.dk>
+// From: erik@ifad.dk (Erik Toubro Nielsen)
+// Subject: g++-2.3.1 gets fatal signal with -g and -fhandle-exceptions
+// Date: Fri, 6 Nov 92 14:30:33 +0100
+
+int main()
+{
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except3.C b/gcc/testsuite/g++.old-deja/g++.law/except3.C
new file mode 100644
index 00000000000..553da6b6d68
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except3.C
@@ -0,0 +1,50 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions
+// GROUPS passed exceptions
+// except file
+// Message-Id: <9211301118.AA09810@ss670mp.geco.slb.com>
+// From: willoch@ss670mp.oslo.sgp.slb.com (thorbjorn willoch)
+// Subject: -fansi-exceptions bug
+// Date: Mon, 30 Nov 92 11:18:05 GMT
+
+extern "C" int printf(const char *, ...);
+
+class Vector
+{
+    int* p;
+    int sz;
+  public:
+    Vector(int s) { p = new int[sz=s]; }
+    ~Vector() {delete [] p; }
+    int size() {return sz; }
+    class Range{};
+ 
+ 
+    int& operator[](int i);
+};
+ 
+int& Vector::operator[](int i)
+{
+    if(0<=i && i<sz) return p[i];
+    throw Range();
+}
+ 
+void do_something(Vector& v)
+{
+    int i = v[v.size()+10];
+}
+ 
+main()
+{
+    Vector v(10);
+ 
+    try
+    {
+        do_something(v);
+    }
+ 
+    catch (Vector::Range)
+    {
+        printf("Range error exception\n");
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except4.C b/gcc/testsuite/g++.old-deja/g++.law/except4.C
new file mode 100644
index 00000000000..c108c48bf74
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except4.C
@@ -0,0 +1,34 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions
+// GROUPS passed exceptions
+// except file
+// Message-Id: <9307071456.AA05275@davinci.hio.hen.nl>
+// From: akkersdi@hio.hen.nl
+// Subject: exceptions broken
+// Date: Wed, 7 Jul 1993 16:56:52 +0200 (MET DST)
+
+class	ball {
+public:	int	dummy;
+	ball() : dummy(0) { ; }
+};
+
+void	pitcher()
+{
+	throw	ball();
+}
+
+void	catcher()
+{
+	try		// <=== gcc 2.* fails here
+	{
+		pitcher();
+	}
+	catch (ball) {
+		/* sleepy catcher doing nothing */ ;
+	}
+}
+
+int	main()
+{
+	catcher();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except5.C b/gcc/testsuite/g++.old-deja/g++.law/except5.C
new file mode 100644
index 00000000000..623d0d8587f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except5.C
@@ -0,0 +1,39 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions
+// GROUPS passed exceptions
+// except file
+// Message-Id: <199311101607.AA11803@hsi86.hsi.com>
+// From: Grigory Tsipenyuk <grigory@hsi.com>
+// Subject: exception's bug?
+// Date: Wed, 10 Nov 1993 11:07:12 -0500
+
+#include <stream.h>
+class X {
+        int     *a;
+        int     sz;
+public:
+        class range { }; // exception class
+        X(int s)        { a=new int[sz=s]; }
+        int& operator[](int i);
+};
+
+int& X::operator[](int i)
+{
+        if (i < 0 || i >= sz) {
+                throw range();
+        }
+        return a[i];
+}
+
+int
+main()
+{
+        X       c(10);
+        try {
+                for (int i = 0; i < 12; i++)
+                        c[i] = 1;
+        } catch (X::range) {
+                cerr << "invalid range\n";
+        }
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/except6.C b/gcc/testsuite/g++.old-deja/g++.law/except6.C
new file mode 100644
index 00000000000..da09ae6bc1a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/except6.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// Special g++ Options: -fexceptions
+// GROUPS passed exceptions
+// except file
+// From: GUSTAVO%DRAGON@orion.cpqd.ansp.br
+// Date:     15 Dec 1993 09:33:30 +0000 (C)
+// Subject:  exception handling problem
+// Message-ID: <01H6I5GEAF5UPBJ0UV@VENUS.CPQD.ANSP.BR>
+
+struct Exception
+ {
+     int v;
+     Exception(int i) { v = i; };
+ };
+
+ inc(int &i)
+ {
+     try {
+         if (i == 0)
+             throw Exception(i);
+         else
+             i++;
+     }
+     catch (Exception v) {
+         i = v.v;
+     }
+ }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/friend1.C b/gcc/testsuite/g++.old-deja/g++.law/friend1.C
new file mode 100644
index 00000000000..2c26ad67531
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/friend1.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed friends
+// friends file
+// From: rwave!myersn%rwave.roguewave@cs.orst.edu (Nathan Myers)
+// Date:     Thu, 17 Dec 92 16:33 PST
+// Subject:  2.3.2: friend decl of new confuses constructor
+// Message-ID: <m0n2Vec-0000GrC@rwave.roguewave.com>
+
+#include <stddef.h>
+struct Foo {
+  friend void* operator new(size_t);
+  friend void operator delete(void*) throw ();
+  Foo();
+  ~Foo();
+};
+Foo::Foo() { }
+Foo::~Foo() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/friend4.C b/gcc/testsuite/g++.old-deja/g++.law/friend4.C
new file mode 100644
index 00000000000..5502a002dc5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/friend4.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed friends
+// excess errors test - XFAIL *-*-*
+// friends file
+// From: osinski@cs.nyu.edu (Ed Osinski)
+// Date:     Fri, 05 Jun 92 20:47:37 -0400
+// Subject:  parameter name forgotten in certain friends
+// Message-ID: <9206060047.AA05594@MURRAY.CS.NYU.EDU>
+
+class T2;
+
+class T {
+   friend void f (int&);
+};
+
+class T2 {
+      friend void f (int& i)  { // BOGUS - 
+      i = 1;
+   };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/friend5.C b/gcc/testsuite/g++.old-deja/g++.law/friend5.C
new file mode 100644
index 00000000000..2ecc31347b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/friend5.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed friends
+        extern "C" int good_friend(int);
+        extern "C" int bad_friend();
+
+        class assembler {
+            friend int good_friend(int);
+            friend int bad_friend();
+            void *parts;
+        };
+
+        assembler obj;
+
+        int good_friend(int)
+        {
+            obj.parts = 0;
+        } // ERROR - non-void
+
+        int bad_friend()
+        {
+            obj.parts = 0;
+        } // ERROR - non-void
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/global-init1.C b/gcc/testsuite/g++.old-deja/g++.law/global-init1.C
new file mode 100644
index 00000000000..ce641254e62
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/global-init1.C
@@ -0,0 +1,20 @@
+// GROUPS passed initialization
+// global-init file
+// Message-Id: <9212021756.AA12639@grumpy.pocs.com>
+// From: wp@pocs.com (Wolfgang Polak)
+// Subject: Initializers - gcc 2.2.2 (g++), Sparc, SunOS 4.1.1
+// Date: Wed, 2 Dec 92 09:56:01 PST
+
+#include <stdio.h>
+struct S { int  a; int  c; };
+int i = 3;
+S s = {6, i};
+S * the_s  () { return &s; };
+main ()
+{
+  S * cls = the_s ();
+  if (cls->a != 6)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/incdec1.C b/gcc/testsuite/g++.old-deja/g++.law/incdec1.C
new file mode 100644
index 00000000000..ce5903c3c78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/incdec1.C
@@ -0,0 +1,47 @@
+// Build don't link: 
+// Special g++ Options: -w -O3
+// GROUPS passed incdec
+typedef void* Pix;
+class ndbArtPtrVec 
+{
+public:
+                        ndbArtPtrVec (ndbArtPtrVec&);
+};
+class intndbArtPtrVecMap
+{
+protected:
+  int                   count;
+  ndbArtPtrVec                   def;
+                        intndbArtPtrVecMap(ndbArtPtrVec& dflt);
+  virtual ndbArtPtrVec&          operator [] (int  key) = 0;  
+  virtual void          del(int  key) = 0;        
+public:
+  virtual Pix           first() = 0;              
+  virtual void          next(Pix& i) = 0;         
+  virtual int&          key(Pix i) = 0;           
+  virtual ndbArtPtrVec&          contents(Pix i) = 0;      
+};
+struct intndbArtPtrVecAVLNode
+{
+  ndbArtPtrVec                 cont;
+                      intndbArtPtrVecAVLNode(int  h, ndbArtPtrVec& c, 
+                                    intndbArtPtrVecAVLNode* l=0, intndbArtPtrVecAVLNode* r=0);
+};
+class intndbArtPtrVecAVLMap : intndbArtPtrVecMap 
+{
+protected:
+  intndbArtPtrVecAVLNode*   root;
+public:
+  ndbArtPtrVec&          operator [] (int  key);
+  intndbArtPtrVecAVLMap(intndbArtPtrVecAVLMap&);
+};
+ndbArtPtrVec& intndbArtPtrVecAVLMap::operator [] (int  item)
+{
+    ++count;
+    root = new intndbArtPtrVecAVLNode(item, def);
+}
+intndbArtPtrVecAVLMap::intndbArtPtrVecAVLMap(intndbArtPtrVecAVLMap& b) :intndbArtPtrVecMap(b.def)
+{
+  for (Pix i = b.first(); i != 0; b.next(i)) 
+    (*this)[b.key(i)] = b.contents(i);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init1.C b/gcc/testsuite/g++.old-deja/g++.law/init1.C
new file mode 100644
index 00000000000..1f23d78936d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init1.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed initialization
+class foo {
+public:
+  int data;
+  foo(int dat) { data = dat; }
+};
+
+class bar {
+public:
+  foo f[3] = { 1, 2, 3 };   // works: f[0] = 1, f[1] = 2, f[2] = 3 // ERROR - ANSI C++ forbids initialization of member f;
+};
+
+class bar2 {
+public:
+      foo f[3] = { foo(1), foo(2), foo(3) }; // ERROR - ANSI C++ forbids initialization of member f;
+  // does not compile -- error: field initializer is not constant
+};
+
+int main(void)
+{
+  foo f[3] = { foo(1), foo(2), foo(3) };
+  // standard C++ ... and it works too! :)
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init10.C b/gcc/testsuite/g++.old-deja/g++.law/init10.C
new file mode 100644
index 00000000000..b6f2085bfc5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init10.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed initialization
+// init file
+// From: Ingo Donasch <ingo@specs.de>
+// Date:     Wed, 16 Jun 93 13:28:55 +01:00
+// Subject:  g++-2.4.2 bug report
+// Message-ID: <199306161128.AA22079@opamp.specs.de>
+
+class b;
+
+class a {
+public:
+        a(const b*);            // needs this parameter
+};
+
+class b {
+private:
+        a three[3];
+public:
+        b();
+};
+
+b::b() : three(this)
+{ // ERROR - bad array initializer
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init11.C b/gcc/testsuite/g++.old-deja/g++.law/init11.C
new file mode 100644
index 00000000000..d5c4e769e4f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init11.C
@@ -0,0 +1,24 @@
+// GROUPS passed initialization
+// init file
+// From: hansen@srd.ull.rdc.toshiba.co.jp
+// Date:     Mon, 13 Dec 93 18:27:51 +0900
+// Subject:  g++ Bug
+// Message-ID: <9312130927.AA08192@VLCS151.noname>
+
+#include <stdio.h>
+
+int X = 7;
+
+struct foo {
+   int a,b,c;
+};
+
+struct foo Ack = {5, X, 3};
+
+main()
+{
+  if (Ack.a == 5 && Ack.b == 7 && Ack.c == 3)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init13.C b/gcc/testsuite/g++.old-deja/g++.law/init13.C
new file mode 100644
index 00000000000..40917c8917d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init13.C
@@ -0,0 +1,19 @@
+// GROUPS passed initialization
+// init file
+// Message-Id: <9306280834.AA20921@slsvitt.us-es.sel.de>
+// From: David Binderman 3841 <dcb@us-es.sel.de>
+// Subject: Page 289 of the ARM
+// Date: Mon, 28 Jun 93 10:34:37 +0200
+
+struct T {
+  int m;
+
+  T( int g):m(g){}
+};
+
+// T s1[2][2] = {1,2,3,4};
+
+int main() {
+	T s1[2][2] = {1,2,3,4};
+	return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init14.C b/gcc/testsuite/g++.old-deja/g++.law/init14.C
new file mode 100644
index 00000000000..a65dc68af59
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init14.C
@@ -0,0 +1,26 @@
+// GROUPS passed initialization
+// init file
+// From: hansen@srd.ull.rdc.toshiba.co.jp
+// Message-Id: <9312130927.AA08192@VLCS151.noname>
+// Subject: g++ Bug
+// Date: Mon, 13 Dec 93 18:27:51 +0900
+
+#include <stdio.h>
+
+int X = 7;
+
+struct foo {
+   int a,b,c;
+};
+
+struct foo Ack = {5, X, 3};
+
+main()
+{
+    if (Ack.a != 5
+	|| Ack.b != 7
+	|| Ack.c != 3)
+      printf ("FAIL\n");
+    else
+      printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init2.C b/gcc/testsuite/g++.old-deja/g++.law/init2.C
new file mode 100644
index 00000000000..bfc9014acd6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init2.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed initialization
+// init file
+// From: lupine!segfault!rfg@uunet.UU.NET
+// Date:     Sun, 27 Sep 92 14:06:22 MDT
+// Subject:  Bug in g++ (920220) handling reference initializers.
+// Message-ID: <15409.717627982@segfault>
+
+int * const & fiddle = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init3.C b/gcc/testsuite/g++.old-deja/g++.law/init3.C
new file mode 100644
index 00000000000..de0473ec5a1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init3.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed initialization
+// init file
+// From: thayer@moose.cs.columbia.edu (Charles Thayer)
+// Date:     Wed, 30 Sep 92 02:38:17 EDT
+// Subject:  small bug
+// Message-ID: <9209300638.AA22334@moose.cs.columbia.edu>
+
+main() {
+int offset;
+char buf[offset]=""; // ERROR - ansi forbids variable arrays
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init4.C b/gcc/testsuite/g++.old-deja/g++.law/init4.C
new file mode 100644
index 00000000000..084876296d1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed initialization
+class Time;
+class TimeNote;
+
+class SvTime
+{
+public:
+    static TimeNote *time_events = 0;// ERROR - .*
+};
+
+SvTime CurrentTime = {0};// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init5.C b/gcc/testsuite/g++.old-deja/g++.law/init5.C
new file mode 100644
index 00000000000..e5882341afb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init5.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// Special g++ Options: -pedantic-errors
+// GROUPS passed initialization
+// init file
+// From: dcb@us-es.sel.de
+// Date:     Mon, 12 Oct 92 07:51:52 +0100
+// Subject:  G++, ARM Page 141
+// Message-ID: <9210120651.AA15257@us-es.sel.de>
+
+extern int fred( int);
+
+class X {
+      public :
+      void f( int = fred( 0) ) ; // ERROR - previous spec
+} ;
+
+void X::f( int x = fred( 0) ) {// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init6.C b/gcc/testsuite/g++.old-deja/g++.law/init6.C
new file mode 100644
index 00000000000..bcebd6cef8a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init6.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed initialization
+class Vector {
+        double  *v;
+        int             size;
+
+public:
+        Vector(int n);
+        ~Vector();
+};
+
+exmpl() { Vector x(8)[16]; }// ERROR - .*
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init7.C b/gcc/testsuite/g++.old-deja/g++.law/init7.C
new file mode 100644
index 00000000000..2ec97c4fd11
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init7.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed initialization
+class test
+ {
+  public:
+   int x;
+   int y;
+   test (int val) { x = val; y = 0;}
+ };
+
+test ar(34)[5];// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init8.C b/gcc/testsuite/g++.old-deja/g++.law/init8.C
new file mode 100644
index 00000000000..6b52bdcdeea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init8.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed initialization
+// init file
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Date:     Wed, 27 Jan 1993 16:39:13 -0500
+// Subject:  g++ bug
+// Message-ID: <199301272139.AA25514@world.std.com>
+
+
+const int ic = 1;
+void f(int& arg)
+{ // ERROR - argument 1
+        if (arg) ;
+}
+const int& icr = ic;
+
+int main(void)
+{
+  f(icr);   // g++ does not give error here// ERROR - .*
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/init9.C b/gcc/testsuite/g++.old-deja/g++.law/init9.C
new file mode 100644
index 00000000000..baad1396a92
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/init9.C
@@ -0,0 +1,35 @@
+// GROUPS passed initialization
+// init file
+// From: Richard Speed <speed@cs.montana.edu>
+// Date:     Sun, 6 Jun 1993 15:19:41 -0600 (MDT)
+// Subject:  excess elements in aggr initzer
+// Message-ID: <Pine.3.07.9306061541.A10267-b100000@fubar.cs.montana.edu>
+
+extern "C" void printf (char *, ...);
+
+class samp {
+        int a;
+public:
+        samp(int n) { a = n; }
+        int get_a() { return a; }
+};
+
+main() {
+        samp ob[4] [2] = {  // Generated Error
+                1, 2,
+                3, 4,
+                5, 6,
+                7, 8,
+        };
+        int i;
+
+	if (ob[0][0].get_a() == 1 && ob[0][1].get_a() == 2
+	    && ob[1][0].get_a() == 3 && ob[1][1].get_a() == 4
+	    && ob[2][0].get_a() == 5 && ob[2][1].get_a() == 6
+	    && ob[3][0].get_a() == 7 && ob[3][1].get_a() == 8)
+	  printf ("PASS\n");
+	else
+	  printf ("FAIL\n");
+
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/inline1.C b/gcc/testsuite/g++.old-deja/g++.law/inline1.C
new file mode 100644
index 00000000000..11e8d0a6c5d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/inline1.C
@@ -0,0 +1,3598 @@
+// Build don't link: 
+// Special g++ Options: -fno-for-scope
+// GROUPS passed inlining
+# 1 "NISTImages.cc"
+# 1 "Vision.h" 1
+ 
+
+
+
+
+ 
+ 
+ 
+
+extern "C" {
+# 1 "/sym/gnu/lib/g++-include/stdio.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma interface
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+# 1 "/sym/gnu/lib/g++-include/_G_config.h" 1 3
+  
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+ 
+
+# 33 "/sym/gnu/lib/g++-include/stdio.h" 2 3
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdio.h" 1 3
+
+# 1 "/sym/gnu/lib/g++-include/stdarg.h" 1 3
+extern "C" {
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 1 3
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/va-sparc.h" 1 3
+ 
+
+
+ 
+
+
+
+
+
+ 
+
+typedef char * __gnuc_va_list;
+
+
+
+
+
+
+
+ 
+
+# 79 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/va-sparc.h" 3
+
+
+# 32 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 2 3
+
+# 77 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 3
+
+
+
+
+
+
+# 140 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 3
+
+
+
+
+
+# 2 "/sym/gnu/lib/g++-include/stdarg.h" 2 3
+
+}
+# 2 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdio.h" 2 3
+
+ 
+
+
+
+
+extern	struct	_iobuf {
+	int	_cnt;
+	unsigned char *_ptr;
+	unsigned char *_base;
+	int	_bufsiz;
+	short	_flag;
+	char	_file;		 
+} _iob[];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern struct _iobuf 	*__hide_fopen ();
+extern struct _iobuf 	*__hide_fdopen ();
+extern struct _iobuf 	*__hide_freopen ();
+extern struct _iobuf 	*__hide_popen ();
+extern struct _iobuf 	*tmpfile();
+extern long	__hide_ftell ();
+extern char	*fgets();
+extern char	*gets();
+extern char	*__hide_sprintf ();
+extern char	*ctermid();
+extern char	*cuserid();
+extern char	*__hide_tempnam ();
+extern char	*tmpnam();
+
+
+
+
+
+
+# 69 "/sym/gnu/lib/g++-include/stdio.h" 2 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+extern "C" {
+
+int    fclose(struct _iobuf *);
+struct _iobuf *  fdopen(int, const char*);
+int    fflush(struct _iobuf *);
+int    fgetc(struct _iobuf *);
+char*  fgets(char*, int, struct _iobuf  *);
+struct _iobuf *  fopen(const char*, const char*);
+int    fprintf(struct _iobuf *, const char* ...);
+int    fputc(int, struct _iobuf *);
+int    fputs(const char*, struct _iobuf *);
+int   fread(void*, int  , int  , struct _iobuf *);
+
+
+
+struct _iobuf *  freopen(const char*, const char*, struct _iobuf *);
+
+int    fscanf(struct _iobuf *, const char* ...);
+int    fseek(struct _iobuf *, long, int);
+long   ftell(struct _iobuf  *);
+int   fwrite(const void*, int  , int  , struct _iobuf *);
+char*  gets(char*);
+int    getw(struct _iobuf *);
+int    pclose(struct _iobuf *);
+void   perror(const char*);
+struct _iobuf *  popen(const char*, const char*);
+int    printf(const char* ...);
+int    puts(const char*);
+int    putw(int, struct _iobuf *);
+int    rewind(struct _iobuf *);
+int    scanf(const char* ...);
+void   setbuf(struct _iobuf *, char*);
+void   setbuffer(struct _iobuf *, char*, int);
+int    setlinebuf(struct _iobuf *);
+int    setvbuf(struct _iobuf *, char*, int, int  );
+int    sscanf(char*, const char* ...);
+struct _iobuf *  tmpfile();
+int    ungetc(int, struct _iobuf *);
+int    vfprintf (...) ;
+int    vprintf (...) ;
+char*  sprintf (...) ;
+char*  vsprintf (...) ;
+
+extern int _filbuf (...) ;
+extern int _flsbuf (...) ;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 11 "Vision.h" 2
+
+# 1 "/usr/include/floatingpoint.h" 1 3
+ 
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 1 3
+ 
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+enum fp_direction_type 		 
+	{
+	fp_nearest	= 0,
+	fp_tozero	= 1,
+	fp_positive	= 2,
+	fp_negative	= 3
+	} ;
+
+# 34 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+# 43 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+
+# 53 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+enum fp_precision_type		 
+	{
+	fp_extended	= 0,
+	fp_single	= 1,
+	fp_double	= 2,
+	fp_precision_3	= 3
+	} ;
+
+
+# 73 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+enum fp_exception_type		 
+	{
+	fp_inexact	= 0,
+	fp_division	= 1,
+	fp_underflow	= 2,
+	fp_overflow	= 3,
+	fp_invalid	= 4
+	} ;
+
+
+enum fp_class_type		 
+	{
+	fp_zero		= 0,
+	fp_subnormal	= 1,
+	fp_normal	= 2,
+	fp_infinity   	= 3,
+	fp_quiet	= 4,
+	fp_signaling	= 5
+	} ;
+
+
+# 18 "/usr/include/floatingpoint.h" 2 3
+
+
+ 
+
+typedef float   single;
+typedef unsigned long extended[3];	 
+
+typedef long double quadruple;	 
+
+
+
+
+
+
+
+
+typedef unsigned fp_exception_field_type;
+ 
+
+
+
+typedef int     sigfpe_code_type;	 
+
+typedef void    (*sigfpe_handler_type) ();
+ 
+
+
+
+
+
+ 
+
+extern enum fp_direction_type fp_direction;
+ 
+
+
+
+extern enum fp_precision_type fp_precision;
+ 
+
+
+
+extern fp_exception_field_type fp_accrued_exceptions;
+ 
+
+
+
+
+
+ 
+
+
+ 
+
+typedef char    decimal_string[512 ];
+ 
+
+typedef struct {
+	enum fp_class_type fpclass;
+	int             sign;
+	int             exponent;
+	decimal_string  ds;	 
+
+
+	int             more;	 
+
+
+	int             ndigits; 
+
+
+}
+                decimal_record;
+
+enum decimal_form {
+	fixed_form,		 
+
+
+
+	floating_form		 
+
+};
+
+typedef struct {
+	enum fp_direction_type rd;
+	 
+	enum decimal_form df;	 
+	int             ndigits; 
+}
+                decimal_mode;
+
+enum decimal_string_form {	 
+	invalid_form,		 
+	whitespace_form,	 
+	fixed_int_form,		 
+	fixed_intdot_form,	 
+	fixed_dotfrac_form,	 
+	fixed_intdotfrac_form,	 
+	floating_int_form,	 
+	floating_intdot_form,	 
+	floating_dotfrac_form,	 
+	floating_intdotfrac_form,	 
+	inf_form,		 
+	infinity_form,		 
+	nan_form,		 
+	nanstring_form		 
+};
+
+ 
+
+extern void     double_to_decimal();
+extern void     quadruple_to_decimal();
+extern char    *econvert();
+extern char    *fconvert();
+extern char    *gconvert();
+extern char    *qeconvert();
+extern char    *qfconvert();
+extern char    *qgconvert();
+
+ 
+
+
+
+extern sigfpe_handler_type ieee_handlers[5	];
+ 
+
+
+
+
+
+
+extern sigfpe_handler_type sigfpe();
+
+extern void     single_to_decimal();
+extern void     extended_to_decimal();
+
+extern void     decimal_to_single();
+extern void     decimal_to_double();
+extern void     decimal_to_extended();
+extern void     decimal_to_quadruple();
+
+extern char    *seconvert();
+extern char    *sfconvert();
+extern char    *sgconvert();
+
+extern void     string_to_decimal();
+extern void     file_to_decimal();
+extern void     func_to_decimal();
+
+ 
+
+extern double   atof();
+
+ 
+
+extern int      errno;
+
+extern double   strtod();
+
+
+# 12 "Vision.h" 2
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/malloc.h" 1 3
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+struct	mallinfo  {
+	int arena;	 
+	int ordblks;	 
+	int smblks;	 
+	int hblks;	 
+	int hblkhd;	 
+	int usmblks;	 
+	int fsmblks;	 
+	int uordblks;	 
+	int fordblks;	 
+	int keepcost;	 
+
+	int mxfast;	 
+	int nlblks;	 
+	int grain;	 
+	int uordbytes;	 
+	int allocated;	 
+	int treeoverhead;	 
+};
+
+typedef void *	malloc_t;
+
+extern	malloc_t	calloc( );
+extern	void	free( );
+extern	malloc_t	malloc( );
+extern	malloc_t	realloc( );
+extern	int		mallopt();
+extern	struct mallinfo mallinfo();
+
+
+# 13 "Vision.h" 2
+
+long time(long *);
+int ieee_handler();
+}
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/stddef.h" 1 3
+
+
+extern "C" {
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stddef.h" 1 3
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+ 
+
+# 41 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stddef.h" 3
+
+
+ 
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int ptrdiff_t;
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+typedef __wchar_t wchar_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+# 7 "/sym/gnu/lib/g++-include/stddef.h" 2 3
+
+
+
+
+}
+
+# 24 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/stdlib.h" 1 3
+
+
+
+
+
+
+
+extern "C" {
+
+int       abs(int);
+
+
+void abort(void);
+
+
+
+
+double    atof(const char*);
+int       atoi(const char*);
+long      atol(const char*);
+
+int       atexit(auto void (*p) (void));
+int       bsearch (const void *, const void *, int  , 
+                   int  , auto int (*ptf)(const void*, const void*));
+void*     calloc(int  , int  );
+void      cfree(void*);
+
+
+void  exit(int);
+
+
+
+
+char*     fcvt(double, int, int*, int*);
+void      free(void*);
+char*     getenv(const char*);
+int       getopt(int, char * const *, const char*);
+int       getpw(int, char*);
+char*     gcvt(double, int, char*);
+char*     ecvt(double, int, int*, int*);
+extern char**   environ;
+
+long      labs(long);
+void*     malloc(int  );
+int      malloc_usable_size(void*);
+int       putenv(const char*);
+extern char*    optarg;
+extern int      opterr;
+extern int      optind;
+void      qsort(void*, int  , int  , auto int (*ptf)(void*,void*));
+int       rand(void);
+void*     realloc(void*, int  );
+int       setkey(const char*);
+int       srand(unsigned int);
+double    strtod(const char*, char**);
+long      strtol(const char*, char**, int);
+unsigned long stroul(const char**, int);
+int       system(const char*);
+
+long      random(void);
+void      srandom(int);
+char*     setstate(char*);
+char*     initstate(unsigned, char*, int);
+
+double    drand48(void);
+void      lcong48(short*);
+long      jrand48(short*);
+long      lrand48(void);
+long      mrand48(void);
+long      nrand48(short*);
+short*    seed48(short*);
+void      srand48(long);
+
+char*     ctermid(char*);
+char*     cuserid(char*);
+char*     tempnam(const char*, const char*);
+char*     tmpnam(char*);
+
+}
+
+# 25 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/string.h" 1 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+char*     strcat(char*, const char*);
+char*     strchr(const char*, int);
+int       strcmp(const char*, const char*);
+int       strcoll(const char*, const char*);
+char*     strcpy(char*, const char*);
+int      strcspn(const char*, const char*);
+char*     strdup(const char*);
+ 
+ 
+ 
+ 
+char*     strncat(char*, const char*, int  );
+int       strncmp(const char*, const char*, int  );
+char*     strncpy(char*, const char*, int  );
+char*     strpbrk(const char*, const char*);
+char*     strrchr(const char*, int);
+int      strspn(const char*, const char*);
+char*     strstr(const char*, const char *);
+char*     strtok(char*, const char*);
+int      strxfrm(char*, const char*, int  );
+
+char*     index(const char*, int);
+char*     rindex(const char*, int);
+}
+
+# 1 "/sym/gnu/lib/g++-include/memory.h" 1 3
+
+
+
+
+
+
+
+extern "C" {
+
+void*     memalign (...) ;
+void*     memccpy (...) ;
+void*     memchr (...) ;
+int       memcmp (...) ;
+void*     memcpy (...) ;
+void*     memmove (...) ;
+void*     memset (...) ;
+int       ffs (...) ;
+int     getpagesize (...) ;
+void*     valloc (...) ;
+
+void      bcopy (...) ;
+int       bcmp (...) ;
+void      bzero (...) ;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 43 "/sym/gnu/lib/g++-include/string.h" 2 3
+
+
+
+# 26 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+
+# 1 "/sym/gnu/lib/g++-include/unistd.h" 1 3
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/unistd.h" 1 3
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/sys/types.h" 1 3
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/stdtypes.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+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;		 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 16 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 2 3
+
+
+
+# 1 "/usr/include/sys/sysmacros.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+# 19 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 2 3
+
+
+
+
+
+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	unsigned int	uint;		 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef	struct  _physadr_t { int r[1]; } *physadr_t;
+typedef	struct label_t {
+	int	val[2];
+} label_t;
+
+
+
+
+
+
+
+typedef	struct	_quad_t { long val[2]; } quad_t;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef	unsigned long	ino_t;
+typedef	short	dev_t;
+typedef	long	off_t;
+typedef	unsigned short	uid_t;
+typedef	unsigned short	gid_t;
+typedef	long	key_t;
+typedef	char *	addr_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;
+
+
+
+
+
+
+
+# 113 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 3
+
+
+
+# 15 "/sym/gnu/lib/g++-include/sys/types.h" 2 3
+
+
+
+
+
+
+}
+
+
+
+
+# 73 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/unistd.h" 2 3
+
+
+extern int	access( );
+extern unsigned	alarm( );
+extern int	chdir( );
+extern int	__hide_chmod ( );
+extern int	__hide_chown ( );
+extern int	close( );
+extern char	*ctermid( );
+extern char	*cuserid( );
+extern int	dup( );
+extern int	dup2( );
+extern int	__hide_execl ( );
+extern int	__hide_execle ( );
+extern int	__hide_execlp ( );
+extern int	execv( );
+extern int	execve( );
+extern int	execvp( );
+extern pid_t	fork( );
+extern long	fpathconf( );
+extern char	*getcwd( );
+extern gid_t	getegid( );
+extern uid_t	geteuid( );
+extern gid_t	getgid( );
+extern int	getgroups( );
+extern char	*getlogin( );
+extern pid_t	getpgrp( );
+extern pid_t	getpid( );
+extern pid_t	getppid( );
+extern uid_t	getuid( );
+extern int	isatty( );
+extern int	link( );
+extern off_t	lseek( );
+extern long	pathconf( );
+extern int	pause( );
+extern int	pipe( );
+extern int	read( );
+extern int	rmdir( );
+extern int	__hide_setgid ( );
+extern int	setpgid( );
+extern pid_t	setsid( );
+extern int	__hide_setuid ( );
+extern unsigned	sleep( );
+extern long	sysconf( );
+extern pid_t	tcgetpgrp( );
+extern int	tcsetpgrp( );
+extern char	*ttyname( );
+extern int	unlink( );
+extern int	write( );
+
+
+
+# 25 "/sym/gnu/lib/g++-include/unistd.h" 2 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 59 "/sym/gnu/lib/g++-include/unistd.h" 3
+
+
+
+extern void  _exit(int);
+
+
+
+
+extern unsigned alarm (...) ;
+extern int      brk (...) ;
+extern int      chdir (...) ;
+extern int      chmod  (...) ;
+extern int      chown (const char*, unsigned short , unsigned short );
+extern int      close (...) ;
+extern char*    crypt (...) ;
+extern int      dup (...) ;
+extern int      dup2 (...) ;
+extern void	encrypt (...) ;
+extern int      execl (const char*, const char *, ...);
+extern int      execle (const char*, const char *, ...);
+extern int      execlp (const char*, const char*, ...);
+extern int      exect (...) ;
+extern int      execv (...) ;
+extern int      execve (...) ;
+extern int      execvp (...) ;
+extern int      fchown (int, unsigned short , unsigned short );
+extern int  fork (...) ;
+extern int      fsync (...) ;
+extern int      ftruncate (...) ;
+extern char*    getcwd (...) ;
+extern int      getdomainname (...) ;
+extern int      getdtablesize (...) ;
+extern int      getgroups (...) ;
+extern unsigned short  geteuid (...) ;
+extern unsigned short  getegid (...) ;
+extern unsigned short  getgid (...) ;
+extern long     gethostid (...) ;
+extern int      gethostname (...) ;
+extern int  getpgrp (...) ;
+extern int  getpid (...) ;
+extern int  getppid (...) ;
+extern char*    getlogin (...) ;
+extern char*    getpass (...) ;
+extern unsigned short  getuid (...) ;
+extern int      ioctl (int, int, ... );
+extern int      isatty (...) ;
+extern int      link (...) ;
+extern int      mkstemp (...) ;
+extern char*    mktemp (...) ;
+extern int      nice (...) ;
+extern int      pause (...) ;
+extern int      pipe (...) ;
+extern int      readlink (...) ;
+extern int      rename (...) ;
+extern int      rmdir (...) ; 
+extern void*    sbrk (...) ; 
+extern int      syscall (...) ;
+extern int      setgid (unsigned short );
+extern int      sethostname (...) ;
+
+
+
+
+extern int  setpgrp (...) ;
+
+extern int      setregid (...) ;
+extern int      setreuid (...) ;
+extern int      setuid (unsigned short );
+extern unsigned sleep (...) ;
+extern void     swab (...) ;
+extern int      symlink (...) ;
+extern long     sysconf (...) ;
+extern int      truncate (...) ;
+extern char*    ttyname (...) ;
+extern int      ttyslot (...) ;
+ 
+extern int      unlink (...) ;
+extern int  vfork (...) ;
+extern int      vadvise (...) ;
+extern int      vhangup (...) ;
+extern long  lseek (...) ;
+extern int  read (...) ;
+extern int  write (...) ;
+extern int      access (...) ;
+
+extern int      flock (...) ;
+
+
+}
+
+
+# 28 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/stdio.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 174 "/sym/gnu/lib/g++-include/stdio.h" 3
+
+# 29 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/errno.h" 1 3
+
+
+extern "C" {
+
+
+
+
+
+# 1 "/usr/include/errno.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+# 1 "/usr/include/sys/errno.h" 1 3
+ 
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+	 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	 
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+# 10 "/usr/include/errno.h" 2 3
+
+extern int errno;
+
+
+# 9 "/sym/gnu/lib/g++-include/errno.h" 2 3
+
+
+
+
+extern char*    sys_errlist[];
+extern int      sys_nerr;
+
+extern int      errno;
+
+void      perror(const char*);
+char*     strerr(int);
+
+
+}
+
+
+# 30 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/fcntl.h" 1 3
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/fcntl.h" 1 3
+ 
+
+
+
+
+# 1 "/usr/include/sys/fcntlcom.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+struct flock {
+	short	l_type;		 
+	short	l_whence;	 
+	long	l_start;	 
+	long	l_len;		 
+	short	l_pid;		 
+	short	l_xxx;		 
+};
+
+
+ 
+struct eflock {
+	short	l_type;		 
+	short	l_whence;	 
+	long	l_start;	 
+	long	l_len;		 
+	short	l_pid;		 
+	short	l_xxx;		 
+	long	l_rpid;		 
+	long	l_rsys;		 
+};
+
+
+
+# 1 "/sym/gnu/lib/g++-include/sys/stat.h" 1 3
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/stat.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+struct	stat {
+	dev_t	st_dev;
+	ino_t	st_ino;
+	mode_t	st_mode;
+	short	st_nlink;
+	uid_t	st_uid;
+	gid_t	st_gid;
+	dev_t	st_rdev;
+	off_t	st_size;
+	time_t	st_atime;
+	int	st_spare1;
+	time_t	st_mtime;
+	int	st_spare2;
+	time_t	st_ctime;
+	int	st_spare3;
+	long	st_blksize;
+	long	st_blocks;
+	long	st_spare4[2];
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+int	__hide_chmod ( );
+int	fstat( );
+int	mkdir( );
+int	mkfifo( );
+int	stat( );
+mode_t	umask( );
+
+
+
+# 14 "/sym/gnu/lib/g++-include/sys/stat.h" 2 3
+
+
+
+
+
+
+extern int       chmod  (...) ;
+extern int       stat (...) ;
+extern int       lstat (...) ;
+extern int       fstat (...) ;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+# 149 "/usr/include/sys/fcntlcom.h" 2 3
+
+
+int	 __hide_open ( );
+int	__hide_creat ( );
+int	__hide_fcntl ( );
+
+
+# 6 "/usr/include/fcntl.h" 2 3
+
+
+
+
+
+# 14 "/sym/gnu/lib/g++-include/fcntl.h" 2 3
+
+
+
+
+
+
+
+
+int       fcntl(int, int, ...);
+int	  creat (...) ;
+
+int       open (...) ;
+
+
+}
+
+# 31 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+
+extern "C" {
+int strcasecmp (...) ;
+}
+
+
+# 18 "Vision.h" 2
+
+# 1 "/sym/gnu/lib/g++-include/math.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma interface
+
+
+
+
+
+
+
+
+
+
+
+# 64 "/sym/gnu/lib/g++-include/math.h" 3
+
+extern "C" {
+
+double  acos(double);
+double  acosh(double);
+double  asin(double);
+double  asinh(double);
+double  atan(double);
+double  atan2(double, double);
+double  atanh(double);
+double  cbrt(double);
+double  ceil(double);
+double  copysign(double,double);
+double  cos(double);
+double  cosh(double);
+double  drem(double,double);
+double  erf(double);
+double  erfc(double);
+double  exp(double);
+double  expm1(double);
+double  fabs(double);
+double  finite(double);
+double  floor(double);
+double	fmod(double, double);
+double  frexp(double, int*);
+double  gamma(double);
+double  hypot(double,double);
+double  infnan(int);
+
+ 
+int     isinf(double);
+int     isnan(double);
+
+double  j0(double);
+double  j1(double);
+double  jn(int, double);
+double  ldexp(double, int);
+double  lgamma(double);
+double  log(double);
+double  log10(double);
+double  log1p(double);
+double  logb(double);
+double  modf(double, double*);
+double  pow(double, double);
+double  rint(double);
+double  scalb(double, int);
+double  sin(double);
+double  sinh(double);
+double  sqrt(double);
+double  tan(double);
+double  tanh(double);
+double  y0(double);
+double  y1(double);
+double  yn(int, double);
+
+double aint(double);
+double anint(double);
+int irint(double);
+int nint(double);
+}
+
+
+
+ 
+
+ 
+
+
+struct libm_exception
+{
+  int type;
+  char* name;
+  double arg1, arg2, retval;
+};
+
+
+
+
+
+
+
+
+extern "C" int matherr(libm_exception*);
+
+
+
+# 1 "/sym/gnu/lib/g++-include/values.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 57 "/sym/gnu/lib/g++-include/values.h" 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 166 "/sym/gnu/lib/g++-include/values.h" 3
+
+
+
+
+
+
+
+
+
+# 150 "/sym/gnu/lib/g++-include/math.h" 2 3
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 19 "Vision.h" 2
+
+
+# 1 "MiscUtilities.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 6 "MiscUtilities.h" 2
+
+
+
+
+
+
+
+
+
+inline int used_mem() {
+	struct mallinfo mi = mallinfo();
+	return mi.usmblks+mi.uordblks;
+}
+inline void abort(void) {
+	fprintf((&_iob[2]) ,"abort\n");
+	exit(1);
+}
+
+inline volatile void error(char *s) {
+	fprintf((&_iob[2]) ,"FATAL ERROR: ");
+	fprintf((&_iob[2]) ,"%s\n",s);
+	exit(1);
+}
+template <class Y>
+struct NameValuePair {
+	char *name;
+	Y y;
+};
+
+template <class Y>
+Y lookup(NameValuePair<Y> *data,char *name) {
+	while(data->name) {
+		if(!strcmp(data->name,name)) return data->y;
+		data++;
+	}
+	abort();
+	return data->y;		 
+}
+
+template <class T>
+void swap(T &x,T &y) {
+	T temp = x;
+	x = y;
+	y = temp;
+}
+
+
+# 21 "Vision.h" 2
+
+# 1 "Counted.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 6 "Counted.h" 2
+
+
+template <class T>
+struct Counted {
+ private:
+	int *count;
+	T *object;
+	T *operator&() {
+		return object;
+	}
+	void dec_count() {
+		if(!count) return;
+		(*count)--;
+		if(*count<=0) {
+			delete count;
+			delete object;
+			count=0;
+			object=0;
+		}
+	}
+	void inc_count() {
+		if(!count) return;
+		(*count)++;
+	}
+ public:
+	Counted() {
+		count=0;
+		object=0;
+	}
+	Counted(T *object):object(object) {
+		count = new int(1);
+	}
+	~Counted() {
+		dec_count();
+	}
+	Counted(Counted &other) {
+		count=other.count;
+		object=other.object;
+		inc_count();
+	}
+	Counted &operator=(Counted &other) {
+		other.inc_count();
+		dec_count();
+		count=other.count;
+		object=other.object;
+		return *this;
+	}
+
+	T &operator*() {if(!object) abort(); else return *object; return *object;}
+	T *operator->() {if(!object) abort(); else return object; return object;}
+	operator T&() {if(!object) abort(); else return *object; return *object;}
+
+	 
+};
+
+
+# 22 "Vision.h" 2
+
+# 1 "Art.h" 1
+ 
+
+
+
+
+
+extern "C" { void abort(); }
+
+
+
+
+
+
+
+
+
+
+
+
+template <class X>
+inline void art_initialize(X *,int) {}
+
+# 39 "Art.h"
+
+
+ 
+ 
+ 
+
+template <class T>
+class Art {
+protected:
+	int mark_temp;
+	T *data;
+	int dims[1];
+	void constructor(int d) {
+		if(d<0) abort() ;
+		mark_temp=0;
+		dims[0]=d;
+		if(d>0) {
+			data=new T[d];
+			if(!data) abort() ;
+		} else data=0;
+		art_initialize(data,d);
+	}
+	void destructor() {
+		if(!data) return;
+		delete [] data;
+		mark_temp=0;
+		data=0;
+		dims[0]=0;
+	 }
+	void copy(Art &other) {
+		int d0=dims[0]<?other.dims[0];
+		for(int i=0;i<d0;i++) data[i]=other.data[i];
+	}
+public:
+	void copyclear(Art &other) {
+		dims[0]=other.dims[0];
+		data=other.data;
+		other.dims[0]=0;
+		other.data=0;
+	}
+private:
+	void copyconstructor(Art &other) {
+		mark_temp=0;
+		if(other.mark_temp) {
+			copyclear(other);
+		} else {
+			constructor(other.dims[0]);
+			copy(other);
+		}
+	}
+ public:
+	Art() {constructor(0);}
+	Art(int d) {constructor(d);}
+	Art(Art &other) {copyconstructor(other);}
+	~Art() {destructor();}
+	 
+	Art &operator=(Art &other) {
+		destructor();
+		copyconstructor(other);
+		return *this;
+	}
+	int dim(int i) {return dims[i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=unsigned(dims[0])) abort()  ;
+		return data[i];
+	}
+	T &sub(int i) {return data[i];}
+	void resize(int nd) {
+		if(nd<0) abort() ;
+		Art t(nd);
+		int limit=nd<?dims[0];
+		for(int i=0;i<limit;i++) t.data[i]=data[i];
+		t.mark_temp=1;
+		*this=t;
+	}
+	Art &temp() { mark_temp=1; return *this; }
+	T *pointer() {return data;}
+	void fill(T value) {for(int i=0;i<dims[0];i++) data[i]=value;}
+
+	int length() {return dims[0];}
+	T &operator[](int i) {return operator()(i);}
+};
+
+ 
+ 
+ 
+
+ 
+ 
+
+template <class T>
+class Stk {
+protected:
+	Art<T> stack;
+	int fill;
+public:
+	Stk() {stack.resize(4); fill=0;}
+	Stk(Stk &other) {
+		stack=other.stack;
+		fill=other.fill;
+	}
+	int dim(int i) {return stack.dim(i);}
+	void push(const T &element) {
+		if(fill>=stack.dim(0)) stack.resize(2*fill);
+		stack.sub(fill++)=element;
+	}
+	T &tos() {
+		return stack(fill-1);
+	}
+	T &pop() {
+		return stack(--fill);
+	}
+	T &operator()(int i) {return stack(i);}
+	T &sub(int i) {return stack.sub(i);}
+	void clear() {
+		stack.resize(0);
+		stack.resize(4);
+		fill=0;
+	}
+	void compact() {
+		stack.resize(fill+1);
+	}
+	Stk temp() { stack.temp(); return *this; }
+	T *pointer() {return stack.pointer();}
+	operator Art<T>&() {return stack;}
+
+	int length() {return fill;}
+	T &operator[](int i) {return operator()(i);}
+};
+
+ 
+ 
+ 
+
+template <class T>
+class Art2 {
+protected:
+	int mark_temp;
+	T **data;
+	int dims[2];
+	int total_length;
+	void constructor(int d0,int d1) {
+		if(d0<0||d1<0) abort() ;
+		mark_temp=0;
+		dims[0]=d0;
+		dims[1]=d1;
+		total_length=dims[0]*dims[1];
+		if(d0>0) {
+			data=new T*[d0];
+			if(!data) abort() ;
+		} else data=0;
+		if(d0>0&&d1>0) {
+			T *p=new T[d0*d1];
+			if(!p) abort() ;
+			for(int i=0;i<d0;i++) data[i]=p+i*d1;
+			art_initialize(data[0],d0*d1);
+		}
+	}
+	void destructor() {
+		if(dims[0]<1) return;
+		if(!data) return;
+		delete [] data[0];
+		delete [] data;
+		mark_temp=0;
+		data=0;
+		dims[0]=0;
+		dims[1]=0;
+	}
+	void copy(Art2 &other) {
+		int d0=dims[0]<?other.dims[0];
+		int d1=dims[1]<?other.dims[1];
+		for(int i=0;i<d0;i++) for(int j=0;j<d1;j++)
+			data[i][j]=other.data[i][j];
+	}
+public:
+	void copyclear(Art2 &other) {
+		dims[0]=other.dims[0];
+		dims[1]=other.dims[1];
+		total_length=dims[0]*dims[1];
+		data=other.data;
+		other.dims[0]=0;
+		other.dims[1]=0;
+		other.total_length=0;
+		other.data=0;
+	}
+private:
+	void copyconstructor(Art2 &other) {
+		mark_temp=0;
+		if(other.mark_temp) {
+			copyclear(other);
+		} else {
+			constructor(other.dims[0],other.dims[1]);
+			copy(other);
+		}
+	}
+ public:
+	Art2() {constructor(0,0);}
+	Art2(int d0,int d1) {constructor(d0,d1);}
+	Art2(const Art2 &other) {copyconstructor((Art2&)other);}
+	~Art2() {destructor();}
+	 
+	Art2 &operator=(Art2 &other) {
+		destructor();
+		copyconstructor(other);
+		return *this;
+	}
+	int dim(int i) {return dims[i];}
+	T &operator()(int i,int j) {
+		if(unsigned(i)>=unsigned(dims[0])||unsigned(j)>=unsigned(dims[1]))
+			abort() ; 
+		return data[i][j];
+	}
+	T &sub(int i,int j) {return data[i][j];}
+	void resize(int nd0,int nd1) {
+		if(nd0<0||nd1<0) abort() ;
+		Art2 t(nd0,nd1);
+		int limit0=nd0<?dims[0];
+		int limit1=nd1<?dims[1];
+		for(int i=0;i<limit0;i++) for(int j=0;j<limit1;j++) t.data[i][j]=data[i][j];
+		t.mark_temp=1;
+		*this=t;
+	}
+	Art2 &temp() { mark_temp=1; return *this; }
+	T **pointer() {return data;}
+	void fill(T value) {
+		for(int i=0;i<dims[0];i++) for(int j=0;j<dims[1];j++)
+			data[i][j]=value;
+	}
+
+	 
+
+	int length() {return total_length;}
+	T &sub(int i) {return data[0][i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=total_length) abort() ; 
+		return data[0][i];
+	}
+};
+
+template <class T>
+inline void art_swap(T &x,T &y) {
+	T temp = x;
+	x = y;
+	y = temp;
+}
+
+template <class T>
+inline void reverse(Art<T> &a) {
+	int i;
+	for(i=a.length()/2;i>=0;i--) art_swap(a.sub(i),a.sub(a.length()-i-1));
+}
+
+template <class T>
+inline void reverse(Stk<T> &a) {
+	reverse(a.stack);
+}
+
+template <class T>
+inline void bag_remove(Stk<T> &a,T &element) {
+	for(int i=0;i<a.length()-1;i++) {
+		if(a(i)==element) {
+			a.sub(i)=a.tos();
+			a.pop();
+		}
+	}
+	if(i<a.length()&&a.sub(i)==element) a.pop();
+}
+
+template <class T>
+inline void ordered_remove(Stk<T> &a,T &element) {
+	int source=0,dest=0;
+	while(source<a.length()) {
+		if(a(source)!=element) {
+			a(dest)=a(source);
+			dest++;
+		}
+		source++;
+	}
+	a.stack.resize(dest);
+}
+
+template <class T>
+inline Art<T> concatenate(Art<T> &a,Art<T> &b) {
+	int i,k;
+	k=a.length();
+	Art<T> result(k+b.length());
+	for(i=0;i<a.length();i++) result.sub(i)=a.sub(i);
+	for(i=0;i<b.length();i++) result.sub(i+k)=b.sub(i);
+	return result.temp();
+}
+
+template <class T>
+inline Stk<T> concatenate(Stk<T> &a,Stk<T> &b) {
+	int i;
+	Stk<T> result;
+	for(i=0;i<a.length();i++) result.push(a.sub(i));
+	for(i=0;i<b.length();i++) result.push(b.sub(i));
+	return result.temp();
+}
+
+
+# 23 "Vision.h" 2
+
+# 1 "Geo.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/math.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 215 "/sym/gnu/lib/g++-include/math.h" 3
+
+# 6 "Geo.h" 2
+
+
+extern "C" {
+void abort(void);
+}
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+template <class T,int n>
+class vec {
+protected:
+	T v[n];
+public:
+	int length() {return n;}
+	int dim(int) {return n;}
+	vec() {}
+	vec(T v0) { v[0]=v0; }
+	vec(T v0,T v1) { v[0]=v0; v[1]=v1; }
+	vec(T v0,T v1,T v2) { v[0]=v0; v[1]=v1; v[2]=v2; }
+	vec(T v0,T v1,T v2,T v3) { v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; }
+	vec(T v0,T v1,T v2,T v3,T v4) { v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; }
+	
+	T &operator[](int i) {return v[i];}
+	T &sub(int i) {return v[i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=n) abort(); 
+		return v[i];
+	}
+
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+
+	 
+	T operator*(vec &other) {
+		T result=0;
+		for(int i=0;i<n;i++) result=result+sub(i)*other.sub(i);
+		return result;
+	}
+
+	 
+	vec operator-() {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)= -sub(i);
+		return result;
+	}
+	vec operator*(T other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)*other;
+		return result;
+	}
+	vec operator/(T other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)/other;
+		return result;
+	}
+	vec operator+(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)+other.sub(i);
+		return result;
+	}
+	vec operator-(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)-other.sub(i);
+		return result;
+	}
+	vec operator<?(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)<?other.sub(i);
+		return result;
+	}
+	vec operator>?(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)>?other.sub(i);
+		return result;
+	}
+
+	 
+	int operator==(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)!=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator!=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)!=other.sub(i)) return 1;
+		return 0;
+	}
+	int operator<(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)>=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator>(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)<=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator<=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)>other.sub(i)) return 0;
+		return 1;
+	}
+	int operator>=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)<other.sub(i)) return 0;
+		return 1;
+	}
+};
+
+template <class T>
+inline float euclidean_norm(T &v) {
+	float total=0.0;
+	for(int i=0;i<v.dim(0);i++) total+=v(i)*v(i);
+	return sqrt(total);
+}
+
+template <class T>
+inline float euclidean_distance(T &u,T &v) {
+	float total=0.0;
+	for(int i=0;i<u.dim(0);i++) {
+		float d=u(i)-v(i);
+		total+=d*d;
+	}
+	return sqrt(total);
+}
+
+ 
+ 
+ 
+
+template <class T,int n>
+class mat:vec<T,n*n> {
+protected:
+public:
+	int dim(int) {return n;}
+	T &operator[](int i) {return v[i];}
+	T &sub(int i,int j) {return v[i*n+j];}
+	T &operator()(int i,int j) {
+		if(unsigned(i)>=n||unsigned(j)>=n) abort(); 
+		return sub(i,j);
+	}
+	mat operator*(mat &other) {
+		mat result;
+		for(int i=0;i<n;i++) for(int j=0;j<n;j++) {
+			T total=0;
+			for(int k=0;k<n;k++) total=total+sub(i,k)*other.sub(k,j);
+			result.sub(i,j)=total;
+		}
+		return result;
+	}
+	vec<T,n> operator*(vec<T,n> &other) {
+		vec<T,n> result;
+		for(int i=0;i<n;i++) {
+			T total=0;
+			for(int k=0;k<n;k++) total=total+sub(i,k)*other.sub(k);
+			result.sub(i)=total;
+		}
+		return result;
+	}
+};
+
+ 
+ 
+ 
+
+typedef vec<float,2> vec2;
+typedef vec<float,3> vec3;
+typedef vec<float,4> vec4;
+
+typedef mat<float,2> mat2;
+typedef mat<float,3> mat3;
+typedef mat<float,4> mat4;
+
+typedef vec<int,2> ivec2;
+
+ 
+ 
+ 
+
+ 
+
+inline float norm_angle(float p) {
+	while(p<0) p+=2*       3.14159265358979323846 ; while(p>=2*       3.14159265358979323846 ) p-=2*       3.14159265358979323846 ; return p;
+}
+inline float norm_angle0(float p) {
+	while(p<-       3.14159265358979323846 ) p+=2*       3.14159265358979323846 ; while(p>=       3.14159265358979323846 ) p-=2*       3.14159265358979323846 ; return p;
+}
+inline float norm_orientation(float p) {
+	while(p<0) p+=       3.14159265358979323846 ; while(p>=       3.14159265358979323846 ) p-=       3.14159265358979323846 ; return p;
+}
+inline float norm_orientation0(float p) {
+	while(p<-       3.14159265358979323846 /2) p+=       3.14159265358979323846 ; while(p>=       3.14159265358979323846 /2) p-=       3.14159265358979323846 ; return p;
+}
+inline float orientation_difference(float p,float q) {
+	fabs(norm_orientation0(p-q));
+}
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+ 
+
+inline vec2 cmul(vec2 &p,vec2 &q) {
+	return vec2(p.sub(0)*q.sub(0)-p.sub(1)*q.sub(1),
+		    p.sub(0)*q.sub(1)+p.sub(1)*q.sub(0));
+}
+
+inline vec2 cdiv(vec2 &p,vec2 &q) {
+	float n=q*q;
+	return vec2((p.sub(0)*q.sub(0)+p.sub(1)*q.sub(1))/n,
+		    (p.sub(1)*q.sub(0)-p.sub(0)*q.sub(1))/n);
+}
+
+inline vec2 csqrt(vec2 &x) {
+	if (x.sub(0)==0.0&&x.sub(1)==0.0)
+		return vec2(0.0,0.0);
+	else {
+		float a=sqrt((fabs(x.sub(0))+hypot(x.sub(0),x.sub(1)))*0.5);
+		float b=0.5*(x.sub(1)/a);
+		if(x.sub(0)>0.0) return vec2(a, b);
+		else if(x.sub(1)>=0.0) return vec2(a,b);
+		else return vec2(-a,-b);
+	}
+}
+inline vec2 cpow(vec2& x, double p) {
+	float h=hypot(x.sub(0),x.sub(1));
+	if (h<=0.0) abort();
+	float lr=pow(h,p);
+	float a=atan2(x.sub(1),x.sub(0));
+	float li=p*a;
+	return vec2(lr*cos(li),lr*sin(li));
+}
+
+ 
+
+inline float cross(vec2 p,vec2 q) {
+	return p.sub(0)*q.sub(1)-p.sub(1)*q.sub(0);
+}
+
+ 
+ 
+ 
+
+struct TRS2 {
+	vec2 t;
+	vec2 r;
+	TRS2(vec2 t=vec2(0.0,0.0),vec2 r=vec2(1.0,0.0)):t(t),r(r) {
+	}
+	vec2 operator()(vec2 &arg) {
+		return cmul(r,arg)+t;
+	}
+	float rotation() {
+		return atan2(r(1),r(0));
+	}
+};
+
+
+
+# 24 "Vision.h" 2
+
+
+
+
+# 1 "VisionTypes.h" 1
+ 
+ 
+ 
+
+typedef Art2<float> FImage;
+typedef Art2<int> IImage;
+typedef Art2<unsigned char> CImage;
+
+struct FImageOp {virtual FImage operator()(FImage &) = 0;};
+struct FImageOp2 {virtual FImage operator()(FImage &,FImage &) = 0;};
+struct CImageOp {virtual CImage operator()(CImage &) = 0;};
+struct CImageOp2 {virtual CImage operator()(CImage &,CImage &) = 0;};
+
+ 
+ 
+ 
+
+struct PFeature {
+	ivec2 p;
+	float a;
+	short group;
+	short type;
+	PFeature() {}
+	PFeature(ivec2 p,float a,int group,int type):p(p),a(a),group(group),type(type) {}
+};
+
+typedef Stk<PFeature> PFeatureStk;
+
+struct FIExtractor {virtual PFeatureStk operator()(FImage &) = 0;};
+struct CIExtractor {virtual PFeatureStk operator()(CImage &) = 0;};
+# 28 "Vision.h" 2
+
+# 1 "ImageDatabase.h" 1
+ 
+
+
+
+
+# 1 "Art.h" 1
+ 
+
+# 339 "Art.h"
+
+# 6 "ImageDatabase.h" 2
+
+
+typedef Art2<unsigned char> CImage;
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+struct ImageDatabase {
+	 
+	 
+	 
+
+	virtual int length() = 0;
+	virtual int nclassifications() = 0;
+	virtual int nusers() = 0;
+	
+	 
+	 
+
+	virtual int classification(int offset) = 0;
+	virtual int user(int offset) = 0;
+	
+	virtual CImage cimage(int offset) {abort();}
+	virtual PFeatureStk features(int offset) {abort();}
+
+	 
+	 
+	 
+	 
+
+	virtual int user_offset(int user) = 0;
+	virtual int user_length(int user) = 0;
+};
+
+ImageDatabase *make_NISTDigitImages();
+
+ 
+ 
+ 
+
+struct ImageDatabaseIterator {
+	virtual int done() = 0;
+	virtual void next() = 0;
+	virtual operator int() = 0;
+	virtual void mark_upto_here() {}
+};
+
+ImageDatabaseIterator *make_IDI_Sequential(ImageDatabase *digits,int current,int stride);
+ImageDatabaseIterator *make_IDI_OnePerUser(ImageDatabase *digits,int current);
+ImageDatabaseIterator *make_IDI_FromFile(char *name);
+
+
+# 29 "Vision.h" 2
+
+
+
+# 1 "NISTImages.cc" 2
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 11 "NISTImages.cc" 2
+
+# 1 "Art.h" 1
+ 
+
+# 339 "Art.h"
+
+# 12 "NISTImages.cc" 2
+
+
+extern "C" {
+# 1 "./nist/ihead.h" 1
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+typedef struct ihead{
+   char id[	80	];			 
+   char created[	26	];		 
+   char width[	8	];		 
+   char height[	8	];		 
+   char depth[	8	];		 
+   char density[	8	];		 
+   char compress[	8	];		 
+   char complen[	8	];		 
+   char align[	8	];		 
+   char unitsize[	8	];		 
+   char sigbit;				 
+   char byte_order;			 
+   char pix_offset[	8	];	 
+   char whitepix[	8	];		 
+   char issigned;			 
+   char rm_cm;				 
+   char tb_bt;				 
+   char lr_rl;				 
+   char parent[	80	];		 
+   char par_x[	8	];		 
+   char par_y[	8	];		 
+}IHEAD;
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 15 "NISTImages.cc" 2
+
+int readihdrfile();
+
+}
+
+typedef Art2<unsigned char> CImage;
+
+Stk<char*> mis_files;
+
+extern "C" {
+	char *re_comp(char *);
+	int re_exec(char *);
+}
+
+struct NISTCharFile {
+ private:
+	NISTCharFile(NISTCharFile &);
+	void operator=(NISTCharFile &);
+ public:
+	IHEAD *bit_header;
+	int bit_w,bit_h;
+	char *bit_data;
+	int field_w,field_h;
+	Stk<int> classes;
+
+	static void maybe_read_mis_files() {
+		if(mis_files.length()>0) return;
+		struct _iobuf  *stream = fopen("/com/nist/mis-files" ,"r");
+		if(!stream) abort() ;
+		char buf[1024];
+		while(fgets(buf,sizeof buf,stream)) {
+			buf[strlen(buf)-1]='\0';
+			mis_files.push(strdup(buf));
+		}
+		fclose(stream);
+	}
+
+	static char *find_matching_mis_file_prefix(char *pattern) {
+		if(re_comp(pattern)) abort() ;
+		int i;
+		for(i=0;i<mis_files.length();i++) {
+			if(re_exec(mis_files(i))) break;
+		}
+		if(i<mis_files.length()) return mis_files(i);
+		else return 0;
+	}
+
+	static int part_of_user(int user) {
+		int part;
+		if(user<500) part=0;
+		else if(user<1000) part=1;
+		else if(user<1500) part=2;
+		else part=3;
+		return part;
+	}
+
+	static char type_of_itype(int itype) {
+		char type;
+		switch(itype) {
+		case 0: type='d'; break;
+		case 1: type='u'; break;
+		case 2: type='l'; break;
+		default: abort() ;
+		};
+		return type;
+	}
+
+	NISTCharFile(int user,char itype) {
+		maybe_read_mis_files();
+		int type = type_of_itype(itype);
+		int part = part_of_user(user);
+
+		char buf[512];
+		sprintf(buf,"/com/nist3/data/" "hsf_%d/f%04d_.*/%c%04d_.*",part,user,type,user);
+		char *prefix = find_matching_mis_file_prefix(buf);
+		 ;
+		
+		if(!prefix) {
+			bit_w = 0;
+			bit_h = 0;
+			field_w = 0;
+			field_h = 0;
+			return;
+		}
+
+		char file[512];
+
+		strcpy(file,prefix); strcat(file,".mis");
+		if(!readihdrfile(file,&bit_header,&bit_data,&bit_w,&bit_h))
+			abort() ;
+		field_w=atoi(bit_header->par_x);
+		field_h=atoi(bit_header->par_y);
+
+		strcpy(file,prefix); strcat(file,".cls");
+		struct _iobuf  *stream = fopen(file,"r");
+		if(!stream)
+			abort() ;
+		int total=atoi(fgets(buf,sizeof buf,stream));
+		if(total!=bit_h/field_h)
+			abort() ;
+		while(fgets(buf,sizeof buf,stream)) classes.push(strtol(buf,0,16));
+		fclose(stream);
+	}
+
+	~NISTCharFile() {
+		free(bit_header);
+		free(bit_data);
+	}
+
+	int length() {
+		return bit_h/field_h;
+	}
+
+	CImage image(int i0) {
+		 ;
+		CImage result(field_w,field_h);
+		int bit_w8=bit_w/8;
+		int offset=i0*field_h;
+		if(offset>=bit_h) abort() ;
+		int i,j;
+
+
+		for(i=0;i<field_w;i++) for(j=0;j<field_h;j++) {
+			int jj=j+offset;
+			result(i,field_h-j-1)=(!!(bit_data[bit_w8*jj+(i>>3)]&(1<<(7-i&7)))) ;
+		}
+
+		return result.temp();
+	}
+
+	int classification(int i) {
+		return classes(i);
+	}
+};
+
+int *NISTDigitImages_table;
+
+struct NISTDigitImages:ImageDatabase {
+ private:
+	NISTDigitImages(NISTDigitImages&);
+	void operator=(NISTDigitImages&);
+ public:
+	enum {table_size=2101};
+
+	int nclassifications() {return 10;}
+	int nusers() {return 2200;}
+
+	static void init_table() {
+		struct _iobuf  *stream=fopen("/com/nist/nist-digits" ,"r");
+		NISTDigitImages_table = new int[table_size];
+		if(!stream) abort() ;
+		int i=1;
+		while(fscanf(stream,"%d",&NISTDigitImages_table[i])==1) i++;
+		if(i!=table_size) abort() ;
+		fclose(stream);
+		int total=0;
+		for(i=1;i<table_size;i++) NISTDigitImages_table[i]+=NISTDigitImages_table[i-1];
+	}
+
+	static int locate(int v) {
+		int low=0;
+		int high=table_size;
+		if(v>=NISTDigitImages_table[table_size-1]) abort() ;
+		while(low+1<high) {
+			int mid=(low+high)/2;
+			if(NISTDigitImages_table[mid]<=v) low=mid;
+			else high=mid;
+		}
+		while(low<table_size-1&&NISTDigitImages_table[low+1]<=v) low++;
+		return low;
+	}
+
+	int user_offset(int user) {
+		if(unsigned(user)>=2100) abort() ;
+		return NISTDigitImages_table[user];
+	}
+
+	int user_length(int user) {
+		if(unsigned(user)>=2100) abort() ;
+		return NISTDigitImages_table[user+1]-NISTDigitImages_table[user];
+	}
+
+	int current_user;
+	NISTCharFile *current_file;
+
+ private:
+	void get_cache(int user) {
+		if(user!=current_user) {
+			delete current_file;
+			current_file = new NISTCharFile(user,0);
+			current_user = user;
+		}
+	}
+
+ public:
+	NISTDigitImages() {
+		 ;
+		if(!NISTDigitImages_table) init_table();
+		current_user=0;
+		current_file=new NISTCharFile(0,0);
+		 ;
+	}
+
+	~NISTDigitImages() {
+		delete current_file;
+	}
+
+	int length() {return NISTDigitImages_table[table_size-1];}
+
+	int user(int i) {
+		return locate(i);
+	}
+
+	CImage image(int i) {
+		int user = locate(i);
+		get_cache(user);
+		int offset = i-NISTDigitImages_table[user];
+		return current_file->image(offset);
+	}
+
+	int classification(int i) {
+		int user = locate(i);
+		get_cache(user);
+		int offset = i-NISTDigitImages_table[user];
+		return current_file->classification(offset);
+	}
+};
+
+ImageDatabase *make_NISTDigitImages() {
+	return new NISTDigitImages();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/inline2.C b/gcc/testsuite/g++.old-deja/g++.law/inline2.C
new file mode 100644
index 00000000000..2eb5b38f7e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/inline2.C
@@ -0,0 +1,3601 @@
+// excess errors test - XFAIL - *-*-*
+// Build don't link: 
+// Special g++ Options: -O2
+// GROUPS passed inlining
+# 1 "NISTImages.cc"
+# 1 "Vision.h" 1
+ 
+
+
+
+
+ 
+ 
+ 
+
+extern "C" {
+# 1 "/sym/gnu/lib/g++-include/stdio.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma interface
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+# 1 "/sym/gnu/lib/g++-include/_G_config.h" 1 3
+  
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+ 
+
+# 33 "/sym/gnu/lib/g++-include/stdio.h" 2 3
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdio.h" 1 3
+
+# 1 "/sym/gnu/lib/g++-include/stdarg.h" 1 3
+extern "C" {
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 1 3
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/va-sparc.h" 1 3
+ 
+
+
+ 
+
+
+
+
+
+ 
+
+typedef char * __gnuc_va_list;
+
+
+
+
+
+
+
+ 
+
+# 79 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/va-sparc.h" 3
+
+
+# 32 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 2 3
+
+# 77 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 3
+
+
+
+
+
+
+# 140 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdarg.h" 3
+
+
+
+
+
+# 2 "/sym/gnu/lib/g++-include/stdarg.h" 2 3
+
+}
+# 2 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stdio.h" 2 3
+
+ 
+
+
+
+
+extern	struct	_iobuf {
+	int	_cnt;
+	unsigned char *_ptr;
+	unsigned char *_base;
+	int	_bufsiz;
+	short	_flag;
+	char	_file;		 
+} _iob[];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern struct _iobuf 	*__hide_fopen ();
+extern struct _iobuf 	*__hide_fdopen ();
+extern struct _iobuf 	*__hide_freopen ();
+extern struct _iobuf 	*__hide_popen ();
+extern struct _iobuf 	*tmpfile();
+extern long	__hide_ftell ();
+extern char	*fgets();
+extern char	*gets();
+extern char	*__hide_sprintf ();
+extern char	*ctermid();
+extern char	*cuserid();
+extern char	*__hide_tempnam ();
+extern char	*tmpnam();
+
+
+
+
+
+
+# 69 "/sym/gnu/lib/g++-include/stdio.h" 2 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+extern "C" {
+
+int    fclose(struct _iobuf *);
+struct _iobuf *  fdopen(int, const char*);
+int    fflush(struct _iobuf *);
+int    fgetc(struct _iobuf *);
+char*  fgets(char*, int, struct _iobuf  *);
+struct _iobuf *  fopen(const char*, const char*);
+int    fprintf(struct _iobuf *, const char* ...);
+int    fputc(int, struct _iobuf *);
+int    fputs(const char*, struct _iobuf *);
+int   fread(void*, int  , int  , struct _iobuf *);
+
+
+
+struct _iobuf *  freopen(const char*, const char*, struct _iobuf *);
+
+int    fscanf(struct _iobuf *, const char* ...);
+int    fseek(struct _iobuf *, long, int);
+long   ftell(struct _iobuf  *);
+int   fwrite(const void*, int  , int  , struct _iobuf *);
+char*  gets(char*);
+int    getw(struct _iobuf *);
+int    pclose(struct _iobuf *);
+void   perror(const char*);
+struct _iobuf *  popen(const char*, const char*);
+int    printf(const char* ...);
+int    puts(const char*);
+int    putw(int, struct _iobuf *);
+int    rewind(struct _iobuf *);
+int    scanf(const char* ...);
+void   setbuf(struct _iobuf *, char*);
+void   setbuffer(struct _iobuf *, char*, int);
+int    setlinebuf(struct _iobuf *);
+int    setvbuf(struct _iobuf *, char*, int, int  );
+int    sscanf(char*, const char* ...);
+struct _iobuf *  tmpfile();
+int    ungetc(int, struct _iobuf *);
+int    vfprintf (...) ;
+int    vprintf (...) ;
+char*  sprintf (...) ;
+char*  vsprintf (...) ;
+
+extern int _filbuf (...) ;
+extern int _flsbuf (...) ;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 11 "Vision.h" 2
+
+# 1 "/usr/include/floatingpoint.h" 1 3
+ 
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 1 3
+ 
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+enum fp_direction_type 		 
+	{
+	fp_nearest	= 0,
+	fp_tozero	= 1,
+	fp_positive	= 2,
+	fp_negative	= 3
+	} ;
+
+# 34 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+# 43 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+
+# 53 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+enum fp_precision_type		 
+	{
+	fp_extended	= 0,
+	fp_single	= 1,
+	fp_double	= 2,
+	fp_precision_3	= 3
+	} ;
+
+
+# 73 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/ieeefp.h" 3
+
+enum fp_exception_type		 
+	{
+	fp_inexact	= 0,
+	fp_division	= 1,
+	fp_underflow	= 2,
+	fp_overflow	= 3,
+	fp_invalid	= 4
+	} ;
+
+
+enum fp_class_type		 
+	{
+	fp_zero		= 0,
+	fp_subnormal	= 1,
+	fp_normal	= 2,
+	fp_infinity   	= 3,
+	fp_quiet	= 4,
+	fp_signaling	= 5
+	} ;
+
+
+# 18 "/usr/include/floatingpoint.h" 2 3
+
+
+ 
+
+typedef float   single;
+typedef unsigned long extended[3];	 
+
+typedef long double quadruple;	 
+
+
+
+
+
+
+
+
+typedef unsigned fp_exception_field_type;
+ 
+
+
+
+typedef int     sigfpe_code_type;	 
+
+typedef void    (*sigfpe_handler_type) ();
+ 
+
+
+
+
+
+ 
+
+extern enum fp_direction_type fp_direction;
+ 
+
+
+
+extern enum fp_precision_type fp_precision;
+ 
+
+
+
+extern fp_exception_field_type fp_accrued_exceptions;
+ 
+
+
+
+
+
+ 
+
+
+ 
+
+typedef char    decimal_string[512 ];
+ 
+
+typedef struct {
+	enum fp_class_type fpclass;
+	int             sign;
+	int             exponent;
+	decimal_string  ds;	 
+
+
+	int             more;	 
+
+
+	int             ndigits; 
+
+
+}
+                decimal_record;
+
+enum decimal_form {
+	fixed_form,		 
+
+
+
+	floating_form		 
+
+};
+
+typedef struct {
+	enum fp_direction_type rd;
+	 
+	enum decimal_form df;	 
+	int             ndigits; 
+}
+                decimal_mode;
+
+enum decimal_string_form {	 
+	invalid_form,		 
+	whitespace_form,	 
+	fixed_int_form,		 
+	fixed_intdot_form,	 
+	fixed_dotfrac_form,	 
+	fixed_intdotfrac_form,	 
+	floating_int_form,	 
+	floating_intdot_form,	 
+	floating_dotfrac_form,	 
+	floating_intdotfrac_form,	 
+	inf_form,		 
+	infinity_form,		 
+	nan_form,		 
+	nanstring_form		 
+};
+
+ 
+
+extern void     double_to_decimal();
+extern void     quadruple_to_decimal();
+extern char    *econvert();
+extern char    *fconvert();
+extern char    *gconvert();
+extern char    *qeconvert();
+extern char    *qfconvert();
+extern char    *qgconvert();
+
+ 
+
+
+
+extern sigfpe_handler_type ieee_handlers[5	];
+ 
+
+
+
+
+
+
+extern sigfpe_handler_type sigfpe();
+
+extern void     single_to_decimal();
+extern void     extended_to_decimal();
+
+extern void     decimal_to_single();
+extern void     decimal_to_double();
+extern void     decimal_to_extended();
+extern void     decimal_to_quadruple();
+
+extern char    *seconvert();
+extern char    *sfconvert();
+extern char    *sgconvert();
+
+extern void     string_to_decimal();
+extern void     file_to_decimal();
+extern void     func_to_decimal();
+
+ 
+
+extern double   atof();
+
+ 
+
+extern int      errno;
+
+extern double   strtod();
+
+
+# 12 "Vision.h" 2
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/malloc.h" 1 3
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+struct	mallinfo  {
+	int arena;	 
+	int ordblks;	 
+	int smblks;	 
+	int hblks;	 
+	int hblkhd;	 
+	int usmblks;	 
+	int fsmblks;	 
+	int uordblks;	 
+	int fordblks;	 
+	int keepcost;	 
+
+	int mxfast;	 
+	int nlblks;	 
+	int grain;	 
+	int uordbytes;	 
+	int allocated;	 
+	int treeoverhead;	 
+};
+
+typedef void *	malloc_t;
+
+extern	malloc_t	calloc( );
+extern	void	free( );
+extern	malloc_t	malloc( );
+extern	malloc_t	realloc( );
+extern	int		mallopt();
+extern	struct mallinfo mallinfo();
+
+
+# 13 "Vision.h" 2
+
+long time(long *);
+int ieee_handler();
+}
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/stddef.h" 1 3
+
+
+extern "C" {
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stddef.h" 1 3
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+ 
+
+# 41 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/stddef.h" 3
+
+
+ 
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int ptrdiff_t;
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int int  ;
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+typedef __wchar_t wchar_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+# 7 "/sym/gnu/lib/g++-include/stddef.h" 2 3
+
+
+
+
+}
+
+# 24 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/stdlib.h" 1 3
+
+
+
+
+
+
+
+extern "C" {
+
+int       abs(int);
+
+
+void volatile abort(void);
+
+
+
+
+double    atof(const char*);
+int       atoi(const char*);
+long      atol(const char*);
+
+int       atexit(auto void (*p) (void));
+int       bsearch (const void *, const void *, int  , 
+                   int  , auto int (*ptf)(const void*, const void*));
+void*     calloc(int  , int  );
+void      cfree(void*);
+
+
+void volatile exit(int);
+
+
+
+
+char*     fcvt(double, int, int*, int*);
+void      free(void*);
+char*     getenv(const char*);
+int       getopt(int, char * const *, const char*);
+int       getpw(int, char*);
+char*     gcvt(double, int, char*);
+char*     ecvt(double, int, int*, int*);
+extern char**   environ;
+
+long      labs(long);
+void*     malloc(int  );
+int      malloc_usable_size(void*);
+int       putenv(const char*);
+extern char*    optarg;
+extern int      opterr;
+extern int      optind;
+void      qsort(void*, int  , int  , auto int (*ptf)(void*,void*));
+int       rand(void);
+void*     realloc(void*, int  );
+int       setkey(const char*);
+int       srand(unsigned int);
+double    strtod(const char*, char**);
+long      strtol(const char*, char**, int);
+unsigned long stroul(const char**, int);
+int       system(const char*);
+
+long      random(void);
+void      srandom(int);
+char*     setstate(char*);
+char*     initstate(unsigned, char*, int);
+
+double    drand48(void);
+void      lcong48(short*);
+long      jrand48(short*);
+long      lrand48(void);
+long      mrand48(void);
+long      nrand48(short*);
+short*    seed48(short*);
+void      srand48(long);
+
+char*     ctermid(char*);
+char*     cuserid(char*);
+char*     tempnam(const char*, const char*);
+char*     tmpnam(char*);
+
+}
+
+# 25 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/string.h" 1 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+
+char*     strcat(char*, const char*);
+char*     strchr(const char*, int);
+int       strcmp(const char*, const char*);
+int       strcoll(const char*, const char*);
+char*     strcpy(char*, const char*);
+int      strcspn(const char*, const char*);
+char*     strdup(const char*);
+ 
+ 
+ 
+ 
+int      strlen(const char*);
+char*     strncat(char*, const char*, int  );
+int       strncmp(const char*, const char*, int  );
+char*     strncpy(char*, const char*, int  );
+char*     strpbrk(const char*, const char*);
+char*     strrchr(const char*, int);
+int      strspn(const char*, const char*);
+char*     strstr(const char*, const char *);
+char*     strtok(char*, const char*);
+int      strxfrm(char*, const char*, int  );
+
+char*     index(const char*, int);
+char*     rindex(const char*, int);
+}
+
+# 1 "/sym/gnu/lib/g++-include/memory.h" 1 3
+
+
+
+
+
+
+
+extern "C" {
+
+void*     memalign (...) ;
+void*     memccpy (...) ;
+void*     memchr (...) ;
+int       memcmp (...) ;
+void*     memcpy (...) ;
+void*     memmove (...) ;
+void*     memset (...) ;
+int       ffs (...) ;
+int     getpagesize (...) ;
+void*     valloc (...) ;
+
+void      bcopy (...) ;
+int       bcmp (...) ;
+void      bzero (...) ;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 43 "/sym/gnu/lib/g++-include/string.h" 2 3
+
+
+
+# 26 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+
+# 1 "/sym/gnu/lib/g++-include/unistd.h" 1 3
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/unistd.h" 1 3
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/sys/types.h" 1 3
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+# 1 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/stdtypes.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+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;		 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 16 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 2 3
+
+
+
+# 1 "/usr/include/sys/sysmacros.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+# 19 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 2 3
+
+
+
+
+
+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	unsigned int	uint;		 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef	struct  _physadr_t { int r[1]; } *physadr_t;
+typedef	struct label_t {
+	int	val[2];
+} label_t;
+
+
+
+
+
+
+
+typedef	struct	_quad_t { long val[2]; } quad_t;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef	unsigned long	ino_t;
+typedef	short	dev_t;
+typedef	long	off_t;
+typedef	unsigned short	uid_t;
+typedef	unsigned short	gid_t;
+typedef	long	key_t;
+typedef	char *	addr_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;
+
+
+
+
+
+
+
+# 113 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/sys/types.h" 3
+
+
+
+# 15 "/sym/gnu/lib/g++-include/sys/types.h" 2 3
+
+
+
+
+
+
+}
+
+
+
+
+# 73 "/sym/gnu/lib/gcc-lib/sparc-sun-sunos4.1/2.3.1/include/unistd.h" 2 3
+
+
+extern void	_exit( );
+extern int	access( );
+extern unsigned	alarm( );
+extern int	chdir( );
+extern int	__hide_chmod ( );
+extern int	__hide_chown ( );
+extern int	close( );
+extern char	*ctermid( );
+extern char	*cuserid( );
+extern int	dup( );
+extern int	dup2( );
+extern int	__hide_execl ( );
+extern int	__hide_execle ( );
+extern int	__hide_execlp ( );
+extern int	execv( );
+extern int	execve( );
+extern int	execvp( );
+extern pid_t	fork( );
+extern long	fpathconf( );
+extern char	*getcwd( );
+extern gid_t	getegid( );
+extern uid_t	geteuid( );
+extern gid_t	getgid( );
+extern int	getgroups( );
+extern char	*getlogin( );
+extern pid_t	getpgrp( );
+extern pid_t	getpid( );
+extern pid_t	getppid( );
+extern uid_t	getuid( );
+extern int	isatty( );
+extern int	link( );
+extern off_t	lseek( );
+extern long	pathconf( );
+extern int	pause( );
+extern int	pipe( );
+extern int	read( );
+extern int	rmdir( );
+extern int	__hide_setgid ( );
+extern int	setpgid( );
+extern pid_t	setsid( );
+extern int	__hide_setuid ( );
+extern unsigned	sleep( );
+extern long	sysconf( );
+extern pid_t	tcgetpgrp( );
+extern int	tcsetpgrp( );
+extern char	*ttyname( );
+extern int	unlink( );
+extern int	write( );
+
+
+
+# 25 "/sym/gnu/lib/g++-include/unistd.h" 2 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 59 "/sym/gnu/lib/g++-include/unistd.h" 3
+
+
+
+extern void volatile _exit(int);
+
+
+
+
+extern unsigned alarm (...) ;
+extern int      brk (...) ;
+extern int      chdir (...) ;
+extern int      chmod  (...) ;
+extern int      chown (const char*, unsigned short , unsigned short );
+extern int      close (...) ;
+extern char*    crypt (...) ;
+extern int      dup (...) ;
+extern int      dup2 (...) ;
+extern void	encrypt (...) ;
+extern int      execl (const char*, const char *, ...);
+extern int      execle (const char*, const char *, ...);
+extern int      execlp (const char*, const char*, ...);
+extern int      exect (...) ;
+extern int      execv (...) ;
+extern int      execve (...) ;
+extern int      execvp (...) ;
+extern int      fchown (int, unsigned short , unsigned short );
+extern int  fork (...) ;
+extern int      fsync (...) ;
+extern int      ftruncate (...) ;
+extern char*    getcwd (...) ;
+extern int      getdomainname (...) ;
+extern int      getdtablesize (...) ;
+extern int      getgroups (...) ;
+extern unsigned short  geteuid (...) ;
+extern unsigned short  getegid (...) ;
+extern unsigned short  getgid (...) ;
+extern long     gethostid (...) ;
+extern int      gethostname (...) ;
+extern int  getpgrp (...) ;
+extern int  getpid (...) ;
+extern int  getppid (...) ;
+extern char*    getlogin (...) ;
+extern char*    getpass (...) ;
+extern unsigned short  getuid (...) ;
+extern int      ioctl (int, int, ... );
+extern int      isatty (...) ;
+extern int      link (...) ;
+extern int      mkstemp (...) ;
+extern char*    mktemp (...) ;
+extern int      nice (...) ;
+extern int      pause (...) ;
+extern int      pipe (...) ;
+extern int      readlink (...) ;
+extern int      rename (...) ;
+extern int      rmdir (...) ; 
+extern void*    sbrk (...) ; 
+extern int      syscall (...) ;
+extern int      setgid (unsigned short );
+extern int      sethostname (...) ;
+
+
+
+
+extern int  setpgrp (...) ;
+
+extern int      setregid (...) ;
+extern int      setreuid (...) ;
+extern int      setuid (unsigned short );
+extern unsigned sleep (...) ;
+extern void     swab (...) ;
+extern int      symlink (...) ;
+extern long     sysconf (...) ;
+extern int      truncate (...) ;
+extern char*    ttyname (...) ;
+extern int      ttyslot (...) ;
+ 
+extern int      unlink (...) ;
+extern int  vfork (...) ;
+extern int      vadvise (...) ;
+extern int      vhangup (...) ;
+extern long  lseek (...) ;
+extern int  read (...) ;
+extern int  write (...) ;
+extern int      access (...) ;
+
+extern int      flock (...) ;
+
+
+}
+
+
+# 28 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/stdio.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 174 "/sym/gnu/lib/g++-include/stdio.h" 3
+
+# 29 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/errno.h" 1 3
+
+
+extern "C" {
+
+
+
+
+
+# 1 "/usr/include/errno.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+# 1 "/usr/include/sys/errno.h" 1 3
+ 
+
+ 
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+ 
+
+	 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	 
+
+
+
+
+
+
+
+
+
+
+
+
+
+	 
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+# 10 "/usr/include/errno.h" 2 3
+
+extern int errno;
+
+
+# 9 "/sym/gnu/lib/g++-include/errno.h" 2 3
+
+
+
+
+extern char*    sys_errlist[];
+extern int      sys_nerr;
+
+extern int      errno;
+
+void      perror(const char*);
+char*     strerr(int);
+
+
+}
+
+
+# 30 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+# 1 "/sym/gnu/lib/g++-include/fcntl.h" 1 3
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/fcntl.h" 1 3
+ 
+
+
+
+
+# 1 "/usr/include/sys/fcntlcom.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ 
+struct flock {
+	short	l_type;		 
+	short	l_whence;	 
+	long	l_start;	 
+	long	l_len;		 
+	short	l_pid;		 
+	short	l_xxx;		 
+};
+
+
+ 
+struct eflock {
+	short	l_type;		 
+	short	l_whence;	 
+	long	l_start;	 
+	long	l_len;		 
+	short	l_pid;		 
+	short	l_xxx;		 
+	long	l_rpid;		 
+	long	l_rsys;		 
+};
+
+
+
+# 1 "/sym/gnu/lib/g++-include/sys/stat.h" 1 3
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/sys/stat.h" 1 3
+ 
+
+ 
+
+
+
+
+
+
+
+
+struct	stat {
+	dev_t	st_dev;
+	ino_t	st_ino;
+	mode_t	st_mode;
+	short	st_nlink;
+	uid_t	st_uid;
+	gid_t	st_gid;
+	dev_t	st_rdev;
+	off_t	st_size;
+	time_t	st_atime;
+	int	st_spare1;
+	time_t	st_mtime;
+	int	st_spare2;
+	time_t	st_ctime;
+	int	st_spare3;
+	long	st_blksize;
+	long	st_blocks;
+	long	st_spare4[2];
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+int	__hide_chmod ( );
+int	fstat( );
+int	mkdir( );
+int	mkfifo( );
+int	stat( );
+mode_t	umask( );
+
+
+
+# 14 "/sym/gnu/lib/g++-include/sys/stat.h" 2 3
+
+
+
+
+
+
+extern int       chmod  (...) ;
+extern int       stat (...) ;
+extern int       lstat (...) ;
+extern int       fstat (...) ;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+# 149 "/usr/include/sys/fcntlcom.h" 2 3
+
+
+int	 __hide_open ( );
+int	__hide_creat ( );
+int	__hide_fcntl ( );
+
+
+# 6 "/usr/include/fcntl.h" 2 3
+
+
+
+
+
+# 14 "/sym/gnu/lib/g++-include/fcntl.h" 2 3
+
+
+
+
+
+
+
+
+int       fcntl(int, int, ...);
+int	  creat (...) ;
+
+int       open (...) ;
+
+
+}
+
+# 31 "/sym/gnu/lib/g++-include/std.h" 2 3
+
+
+extern "C" {
+int strcasecmp (...) ;
+}
+
+
+# 18 "Vision.h" 2
+
+# 1 "/sym/gnu/lib/g++-include/math.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma interface
+
+
+
+
+
+
+
+
+
+
+
+# 64 "/sym/gnu/lib/g++-include/math.h" 3
+
+extern "C" {
+
+double  acos(double);
+double  acosh(double);
+double  asin(double);
+double  asinh(double);
+double  atan(double);
+double  atan2(double, double);
+double  atanh(double);
+double  cbrt(double);
+double  ceil(double);
+double  copysign(double,double);
+double  cos(double);
+double  cosh(double);
+double  drem(double,double);
+double  erf(double);
+double  erfc(double);
+double  exp(double);
+double  expm1(double);
+double  fabs(double);
+double  finite(double);
+double  floor(double);
+double	fmod(double, double);
+double  frexp(double, int*);
+double  gamma(double);
+double  hypot(double,double);
+double  infnan(int);
+
+ 
+int     isinf(double);
+int     isnan(double);
+
+double  j0(double);
+double  j1(double);
+double  jn(int, double);
+double  ldexp(double, int);
+double  lgamma(double);
+double  log(double);
+double  log10(double);
+double  log1p(double);
+double  logb(double);
+double  modf(double, double*);
+double  pow(double, double);
+double  rint(double);
+double  scalb(double, int);
+double  sin(double);
+double  sinh(double);
+double  sqrt(double);
+double  tan(double);
+double  tanh(double);
+double  y0(double);
+double  y1(double);
+double  yn(int, double);
+
+double aint(double);
+double anint(double);
+int irint(double);
+int nint(double);
+}
+
+
+
+ 
+
+ 
+
+
+struct libm_exception
+{
+  int type;
+  char* name;
+  double arg1, arg2, retval;
+};
+
+
+
+
+
+
+
+
+extern "C" int matherr(libm_exception*);
+
+
+
+# 1 "/sym/gnu/lib/g++-include/values.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 57 "/sym/gnu/lib/g++-include/values.h" 3
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 166 "/sym/gnu/lib/g++-include/values.h" 3
+
+
+
+
+
+
+
+
+
+# 150 "/sym/gnu/lib/g++-include/math.h" 2 3
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 19 "Vision.h" 2
+
+
+# 1 "MiscUtilities.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 6 "MiscUtilities.h" 2
+
+
+
+
+
+
+
+
+
+inline int used_mem() {
+	struct mallinfo mi = mallinfo();
+	return mi.usmblks+mi.uordblks;
+}
+inline volatile void abort() {
+	fprintf((&_iob[2]) ,"abort\n");
+	exit(1);
+}
+
+inline volatile void error(char *s) {
+	fprintf((&_iob[2]) ,"FATAL ERROR: ");
+	fprintf((&_iob[2]) ,"%s\n",s);
+	exit(1);
+}
+template <class Y>
+struct NameValuePair {
+	char *name;
+	Y y;
+};
+
+template <class Y>
+Y lookup(NameValuePair<Y> *data,char *name) {
+	while(data->name) {
+		if(!strcmp(data->name,name)) return data->y;
+		data++;
+	}
+	abort();
+	return data->y;		 
+}
+
+template <class T>
+void swap(T &x,T &y) {
+	T temp = x;
+	x = y;
+	y = temp;
+}
+
+
+# 21 "Vision.h" 2
+
+# 1 "Counted.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 6 "Counted.h" 2
+
+
+template <class T>
+struct Counted {
+ private:
+	int *count;
+	T *object;
+	T *operator&() {
+		return object;
+	}
+	void dec_count() {
+		if(!count) return;
+		(*count)--;
+		if(*count<=0) {
+			delete count;
+			delete object;
+			count=0;
+			object=0;
+		}
+	}
+	void inc_count() {
+		if(!count) return;
+		(*count)++;
+	}
+ public:
+	Counted() {
+		count=0;
+		object=0;
+	}
+	Counted(T *object):object(object) {
+		count = new int(1);
+	}
+	~Counted() {
+		dec_count();
+	}
+	Counted(Counted &other) {
+		count=other.count;
+		object=other.object;
+		inc_count();
+	}
+	Counted &operator=(Counted &other) {
+		other.inc_count();
+		dec_count();
+		count=other.count;
+		object=other.object;
+		return *this;
+	}
+
+	T &operator*() {if(!object) abort(); else return *object; return *object;}
+	T *operator->() {if(!object) abort(); else return object; return object;}
+	operator T&() {if(!object) abort(); else return *object; return *object;}
+
+	 
+};
+
+
+# 22 "Vision.h" 2
+
+# 1 "Art.h" 1
+ 
+
+
+
+
+
+extern "C" { void abort(); }
+
+
+
+
+
+
+
+
+
+
+
+
+template <class X>
+inline void art_initialize(X *,int) {}
+
+# 39 "Art.h"
+
+
+ 
+ 
+ 
+
+template <class T>
+class Art {
+protected:
+	int mark_temp;
+	T *data;
+	int dims[1];
+	void constructor(int d) {
+		if(d<0) abort() ;
+		mark_temp=0;
+		dims[0]=d;
+		if(d>0) {
+			data=new T[d];
+			if(!data) abort() ;
+		} else data=0;
+		art_initialize(data,d);
+	}
+	void destructor() {
+		if(!data) return;
+		delete [] data;
+		mark_temp=0;
+		data=0;
+		dims[0]=0;
+	 }
+	void copy(Art &other) {
+		int d0=dims[0]<?other.dims[0];
+		for(int i=0;i<d0;i++) data[i]=other.data[i];
+	}
+public:
+	void copyclear(Art &other) {
+		dims[0]=other.dims[0];
+		data=other.data;
+		other.dims[0]=0;
+		other.data=0;
+	}
+private:
+	void copyconstructor(Art &other) {
+		mark_temp=0;
+		if(other.mark_temp) {
+			copyclear(other);
+		} else {
+			constructor(other.dims[0]);
+			copy(other);
+		}
+	}
+ public:
+	Art() {constructor(0);}
+	Art(int d) {constructor(d);}
+	Art(Art &other) {copyconstructor(other);}
+	~Art() {destructor();}
+	 
+	Art &operator=(Art &other) {
+		destructor();
+		copyconstructor(other);
+		return *this;
+	}
+	int dim(int i) {return dims[i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=unsigned(dims[0])) abort()  ;
+		return data[i];
+	}
+	T &sub(int i) {return data[i];}
+	void resize(int nd) {
+		if(nd<0) abort() ;
+		Art t(nd);
+		int limit=nd<?dims[0];
+		for(int i=0;i<limit;i++) t.data[i]=data[i];
+		t.mark_temp=1;
+		*this=t;
+	}
+	Art &temp() { mark_temp=1; return *this; }
+	T *pointer() {return data;}
+	void fill(T value) {for(int i=0;i<dims[0];i++) data[i]=value;}
+
+	int length() {return dims[0];}
+	T &operator[](int i) {return operator()(i);}
+};
+
+ 
+ 
+ 
+
+ 
+ 
+
+template <class T>
+class Stk {
+protected:
+	Art<T> stack;
+	int fill;
+public:
+	Stk() {stack.resize(4); fill=0;}
+	Stk(Stk &other) {
+		stack=other.stack;
+		fill=other.fill;
+	}
+	int dim(int i) {return stack.dim(i);}
+	void push(T &element) {
+		if(fill>=stack.dim(0)) stack.resize(2*fill);
+		stack.sub(fill++)=element;
+	}
+	T &tos() {
+		return stack(fill-1);
+	}
+	T &pop() {
+		return stack(--fill);
+	}
+	T &operator()(int i) {return stack(i);}
+	T &sub(int i) {return stack.sub(i);}
+	void clear() {
+		stack.resize(0);
+		stack.resize(4);
+		fill=0;
+	}
+	void compact() {
+		stack.resize(fill+1);
+	}
+	Stk temp() { stack.temp(); return *this; }
+	T *pointer() {return stack.pointer();}
+	operator Art<T>&() {return stack;}
+
+	int length() {return fill;}
+	T &operator[](int i) {return operator()(i);}
+};
+
+ 
+ 
+ 
+
+template <class T>
+class Art2 {
+protected:
+	int mark_temp;
+	T **data;
+	int dims[2];
+	int total_length;
+	void constructor(int d0,int d1) {
+		if(d0<0||d1<0) abort() ;
+		mark_temp=0;
+		dims[0]=d0;
+		dims[1]=d1;
+		total_length=dims[0]*dims[1];
+		if(d0>0) {
+			data=new T*[d0];
+			if(!data) abort() ;
+		} else data=0;
+		if(d0>0&&d1>0) {
+			T *p=new T[d0*d1];
+			if(!p) abort() ;
+			for(int i=0;i<d0;i++) data[i]=p+i*d1;
+			art_initialize(data[0],d0*d1);
+		}
+	}
+	void destructor() {
+		if(dims[0]<1) return;
+		if(!data) return;
+		delete [] data[0];
+		delete [] data;
+		mark_temp=0;
+		data=0;
+		dims[0]=0;
+		dims[1]=0;
+	}
+	void copy(Art2 &other) {
+		int d0=dims[0]<?other.dims[0];
+		int d1=dims[1]<?other.dims[1];
+		for(int i=0;i<d0;i++) for(int j=0;j<d1;j++)
+			data[i][j]=other.data[i][j];
+	}
+public:
+	void copyclear(Art2 &other) {
+		dims[0]=other.dims[0];
+		dims[1]=other.dims[1];
+		total_length=dims[0]*dims[1];
+		data=other.data;
+		other.dims[0]=0;
+		other.dims[1]=0;
+		other.total_length=0;
+		other.data=0;
+	}
+private:
+	void copyconstructor(Art2 &other) {
+		mark_temp=0;
+		if(other.mark_temp) {
+			copyclear(other);
+		} else {
+			constructor(other.dims[0],other.dims[1]);
+			copy(other);
+		}
+	}
+ public:
+	Art2() {constructor(0,0);}
+	Art2(int d0,int d1) {constructor(d0,d1);}
+	Art2(Art2 &other) {copyconstructor(other);}
+	~Art2() {destructor();}
+	 
+	Art2 &operator=(Art2 &other) {
+		destructor();
+		copyconstructor(other);
+		return *this;
+	}
+	int dim(int i) {return dims[i];}
+	T &operator()(int i,int j) {
+		if(unsigned(i)>=unsigned(dims[0])||unsigned(j)>=unsigned(dims[1]))
+			abort() ; 
+		return data[i][j];
+	}
+	T &sub(int i,int j) {return data[i][j];}
+	void resize(int nd0,int nd1) {
+		if(nd0<0||nd1<0) abort() ;
+		Art2 t(nd0,nd1);
+		int limit0=nd0<?dims[0];
+		int limit1=nd1<?dims[1];
+		for(int i=0;i<limit0;i++) for(int j=0;j<limit1;j++) t.data[i][j]=data[i][j];
+		t.mark_temp=1;
+		*this=t;
+	}
+	Art2 &temp() { mark_temp=1; return *this; }
+	T **pointer() {return data;}
+	void fill(T value) {
+		for(int i=0;i<dims[0];i++) for(int j=0;j<dims[1];j++)
+			data[i][j]=value;
+	}
+
+	 
+
+	int length() {return total_length;}
+	T &sub(int i) {return data[0][i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=total_length) abort() ; 
+		return data[0][i];
+	}
+};
+
+template <class T>
+inline void art_swap(T &x,T &y) {
+	T temp = x;
+	x = y;
+	y = temp;
+}
+
+template <class T>
+inline void reverse(Art<T> &a) {
+	int i;
+	for(i=a.length()/2;i>=0;i--) art_swap(a.sub(i),a.sub(a.length()-i-1));
+}
+
+template <class T>
+inline void reverse(Stk<T> &a) {
+	reverse(a.stack);
+}
+
+template <class T>
+inline void bag_remove(Stk<T> &a,T &element) {
+	for(int i=0;i<a.length()-1;i++) {
+		if(a(i)==element) {
+			a.sub(i)=a.tos();
+			a.pop();
+		}
+	}
+	if(i<a.length()&&a.sub(i)==element) a.pop();
+}
+
+template <class T>
+inline void ordered_remove(Stk<T> &a,T &element) {
+	int source=0,dest=0;
+	while(source<a.length()) {
+		if(a(source)!=element) {
+			a(dest)=a(source);
+			dest++;
+		}
+		source++;
+	}
+	a.stack.resize(dest);
+}
+
+template <class T>
+inline Art<T> concatenate(Art<T> &a,Art<T> &b) {
+	int i,k;
+	k=a.length();
+	Art<T> result(k+b.length());
+	for(i=0;i<a.length();i++) result.sub(i)=a.sub(i);
+	for(i=0;i<b.length();i++) result.sub(i+k)=b.sub(i);
+	return result.temp();
+}
+
+template <class T>
+inline Stk<T> concatenate(Stk<T> &a,Stk<T> &b) {
+	int i;
+	Stk<T> result;
+	for(i=0;i<a.length();i++) result.push(a.sub(i));
+	for(i=0;i<b.length();i++) result.push(b.sub(i));
+	return result.temp();
+}
+
+
+# 23 "Vision.h" 2
+
+# 1 "Geo.h" 1
+ 
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/math.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 215 "/sym/gnu/lib/g++-include/math.h" 3
+
+# 6 "Geo.h" 2
+
+
+extern "C" {
+void abort();
+}
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+template <class T,int n>
+class vec {
+protected:
+	T v[n];
+public:
+	int length() {return n;}
+	int dim(int) {return n;}
+	vec() {}
+	vec(T v0) { v[0]=v0; }
+	vec(T v0,T v1) { v[0]=v0; v[1]=v1; }
+	vec(T v0,T v1,T v2) { v[0]=v0; v[1]=v1; v[2]=v2; }
+	vec(T v0,T v1,T v2,T v3) { v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; }
+	vec(T v0,T v1,T v2,T v3,T v4) { v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; }
+	
+	T &operator[](int i) {return v[i];}
+	T &sub(int i) {return v[i];}
+	T &operator()(int i) {
+		if(unsigned(i)>=n) abort(); 
+		return v[i];
+	}
+
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+	 
+
+	 
+	T operator*(vec &other) {
+		T result=0;
+		for(int i=0;i<n;i++) result=result+sub(i)*other.sub(i);
+		return result;
+	}
+
+	 
+	vec operator-() {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)= -sub(i);
+		return result;
+	}
+	vec operator*(T other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)*other;
+		return result;
+	}
+	vec operator/(T other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)/other;
+		return result;
+	}
+	vec operator+(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)+other.sub(i);
+		return result;
+	}
+	vec operator-(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)-other.sub(i);
+		return result;
+	}
+	vec operator<?(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)<?other.sub(i);
+		return result;
+	}
+	vec operator>?(vec &other) {
+		vec result;
+		for(int i=0;i<n;i++) result.sub(i)=sub(i)>?other.sub(i);
+		return result;
+	}
+
+	 
+	int operator==(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)!=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator!=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)!=other.sub(i)) return 1;
+		return 0;
+	}
+	int operator<(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)>=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator>(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)<=other.sub(i)) return 0;
+		return 1;
+	}
+	int operator<=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)>other.sub(i)) return 0;
+		return 1;
+	}
+	int operator>=(vec &other) {
+		for(int i=0;i<n;i++) if(sub(i)<other.sub(i)) return 0;
+		return 1;
+	}
+};
+
+template <class T>
+inline float euclidean_norm(T &v) {
+	float total=0.0;
+	for(int i=0;i<v.dim(0);i++) total+=v(i)*v(i);
+	return sqrt(total);
+}
+
+template <class T>
+inline float euclidean_distance(T &u,T &v) {
+	float total=0.0;
+	for(int i=0;i<u.dim(0);i++) {
+		float d=u(i)-v(i);
+		total+=d*d;
+	}
+	return sqrt(total);
+}
+
+ 
+ 
+ 
+
+template <class T,int n>
+class mat:vec<T,n*n> {
+protected:
+public:
+	int dim(int) {return n;}
+	T &operator[](int i) {return v[i];}
+	T &sub(int i,int j) {return v[i*n+j];}
+	T &operator()(int i,int j) {
+		if(unsigned(i)>=n||unsigned(j)>=n) abort(); 
+		return sub(i,j);
+	}
+	mat operator*(mat &other) {
+		mat result;
+		for(int i=0;i<n;i++) for(int j=0;j<n;j++) {
+			T total=0;
+			for(int k=0;k<n;k++) total=total+sub(i,k)*other.sub(k,j);
+			result.sub(i,j)=total;
+		}
+		return result;
+	}
+	vec<T,n> operator*(vec<T,n> &other) {
+		vec<T,n> result;
+		for(int i=0;i<n;i++) {
+			T total=0;
+			for(int k=0;k<n;k++) total=total+sub(i,k)*other.sub(k);
+			result.sub(i)=total;
+		}
+		return result;
+	}
+};
+
+ 
+ 
+ 
+
+typedef vec<float,2> vec2;
+typedef vec<float,3> vec3;
+typedef vec<float,4> vec4;
+
+typedef mat<float,2> mat2;
+typedef mat<float,3> mat3;
+typedef mat<float,4> mat4;
+
+typedef vec<int,2> ivec2;
+
+ 
+ 
+ 
+
+ 
+
+inline float norm_angle(float p) {
+	while(p<0) p+=2*       3.14159265358979323846 ; while(p>=2*       3.14159265358979323846 ) p-=2*       3.14159265358979323846 ; return p;
+}
+inline float norm_angle0(float p) {
+	while(p<-       3.14159265358979323846 ) p+=2*       3.14159265358979323846 ; while(p>=       3.14159265358979323846 ) p-=2*       3.14159265358979323846 ; return p;
+}
+inline float norm_orientation(float p) {
+	while(p<0) p+=       3.14159265358979323846 ; while(p>=       3.14159265358979323846 ) p-=       3.14159265358979323846 ; return p;
+}
+inline float norm_orientation0(float p) {
+	while(p<-       3.14159265358979323846 /2) p+=       3.14159265358979323846 ; while(p>=       3.14159265358979323846 /2) p-=       3.14159265358979323846 ; return p;
+}
+inline float orientation_difference(float p,float q) {
+	fabs(norm_orientation0(p-q));
+}
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+ 
+
+inline vec2 cmul(vec2 &p,vec2 &q) {
+	return vec2(p.sub(0)*q.sub(0)-p.sub(1)*q.sub(1),
+		    p.sub(0)*q.sub(1)+p.sub(1)*q.sub(0));
+}
+
+inline vec2 cdiv(vec2 &p,vec2 &q) {
+	float n=q*q;
+	return vec2((p.sub(0)*q.sub(0)+p.sub(1)*q.sub(1))/n,
+		    (p.sub(1)*q.sub(0)-p.sub(0)*q.sub(1))/n);
+}
+
+inline vec2 csqrt(vec2 &x) {
+	if (x.sub(0)==0.0&&x.sub(1)==0.0)
+		return vec2(0.0,0.0);
+	else {
+		float a=sqrt((fabs(x.sub(0))+hypot(x.sub(0),x.sub(1)))*0.5);
+		float b=0.5*(x.sub(1)/a);
+		if(x.sub(0)>0.0) return vec2(a, b);
+		else if(x.sub(1)>=0.0) return vec2(a,b);
+		else return vec2(-a,-b);
+	}
+}
+inline vec2 cpow(vec2& x, double p) {
+	float h=hypot(x.sub(0),x.sub(1));
+	if (h<=0.0) abort();
+	float lr=pow(h,p);
+	float a=atan2(x.sub(1),x.sub(0));
+	float li=p*a;
+	return vec2(lr*cos(li),lr*sin(li));
+}
+
+ 
+
+inline float cross(vec2 p,vec2 q) {
+	return p.sub(0)*q.sub(1)-p.sub(1)*q.sub(0);
+}
+
+ 
+ 
+ 
+
+struct TRS2 {
+	vec2 t;
+	vec2 r;
+	TRS2(vec2 t=vec2(0.0,0.0),vec2 r=vec2(1.0,0.0)):t(t),r(r) {
+	}
+	vec2 operator()(vec2 &arg) {
+		return cmul(r,arg)+t;
+	}
+	float rotation() {
+		return atan2(r(1),r(0));
+	}
+};
+
+
+
+# 24 "Vision.h" 2
+
+
+
+
+# 1 "VisionTypes.h" 1
+ 
+ 
+ 
+
+typedef Art2<float> FImage;
+typedef Art2<int> IImage;
+typedef Art2<unsigned char> CImage;
+
+struct FImageOp {virtual FImage operator()(FImage &) = 0;};
+struct FImageOp2 {virtual FImage operator()(FImage &,FImage &) = 0;};
+struct CImageOp {virtual CImage operator()(CImage &) = 0;};
+struct CImageOp2 {virtual CImage operator()(CImage &,CImage &) = 0;};
+
+ 
+ 
+ 
+
+struct PFeature {
+	ivec2 p;
+	float a;
+	short group;
+	short type;
+	PFeature() {}
+	PFeature(ivec2 p,float a,int group,int type):p(p),a(a),group(group),type(type) {}
+};
+
+typedef Stk<PFeature> PFeatureStk;
+
+struct FIExtractor {virtual PFeatureStk operator()(FImage &) = 0;};
+struct CIExtractor {virtual PFeatureStk operator()(CImage &) = 0;};
+# 28 "Vision.h" 2
+
+# 1 "ImageDatabase.h" 1
+ 
+
+
+
+
+# 1 "Art.h" 1
+ 
+
+# 339 "Art.h"
+
+# 6 "ImageDatabase.h" 2
+
+
+typedef Art2<unsigned char> CImage;
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+struct ImageDatabase {
+	 
+	 
+	 
+
+	virtual int length() = 0;
+	virtual int nclassifications() = 0;
+	virtual int nusers() = 0;
+	
+	 
+	 
+
+	virtual int classification(int offset) = 0;
+	virtual int user(int offset) = 0;
+	
+	virtual CImage cimage(int offset) {abort();}
+	virtual PFeatureStk features(int offset) {abort();}
+
+	 
+	 
+	 
+	 
+
+	virtual int user_offset(int user) = 0;
+	virtual int user_length(int user) = 0;
+};
+
+ImageDatabase *make_NISTDigitImages();
+
+ 
+ 
+ 
+
+struct ImageDatabaseIterator {
+	virtual int done() = 0;
+	virtual void next() = 0;
+	virtual operator int() = 0;
+	virtual void mark_upto_here() {}
+};
+
+ImageDatabaseIterator *make_IDI_Sequential(ImageDatabase *digits,int current,int stride);
+ImageDatabaseIterator *make_IDI_OnePerUser(ImageDatabase *digits,int current);
+ImageDatabaseIterator *make_IDI_FromFile(char *name);
+
+
+# 29 "Vision.h" 2
+
+
+
+# 1 "NISTImages.cc" 2
+
+
+
+
+
+
+
+
+
+
+# 1 "/sym/gnu/lib/g++-include/std.h" 1 3
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 37 "/sym/gnu/lib/g++-include/std.h" 3
+
+# 11 "NISTImages.cc" 2
+
+# 1 "Art.h" 1
+ 
+
+# 339 "Art.h"
+
+# 12 "NISTImages.cc" 2
+
+
+extern "C" {
+# 1 "./nist/ihead.h" 1
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+typedef struct ihead{
+   char id[	80	];			 
+   char created[	26	];		 
+   char width[	8	];		 
+   char height[	8	];		 
+   char depth[	8	];		 
+   char density[	8	];		 
+   char compress[	8	];		 
+   char complen[	8	];		 
+   char align[	8	];		 
+   char unitsize[	8	];		 
+   char sigbit;				 
+   char byte_order;			 
+   char pix_offset[	8	];	 
+   char whitepix[	8	];		 
+   char issigned;			 
+   char rm_cm;				 
+   char tb_bt;				 
+   char lr_rl;				 
+   char parent[	80	];		 
+   char par_x[	8	];		 
+   char par_y[	8	];		 
+}IHEAD;
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 15 "NISTImages.cc" 2
+
+int readihdrfile();
+
+}
+
+typedef Art2<unsigned char> CImage;
+
+Stk<char*> mis_files;
+
+extern "C" {
+	char *re_comp(char *);
+	int re_exec(char *);
+}
+
+struct NISTCharFile {
+ private:
+	NISTCharFile(NISTCharFile &);
+	void operator=(NISTCharFile &);
+ public:
+	IHEAD *bit_header;
+	int bit_w,bit_h;
+	char *bit_data;
+	int field_w,field_h;
+	Stk<int> classes;
+
+	static void maybe_read_mis_files() {
+		if(mis_files.length()>0) return;
+		struct _iobuf  *stream = fopen("/com/nist/mis-files" ,"r");
+		if(!stream) abort() ;
+		char buf[1024];
+		while(fgets(buf,sizeof buf,stream)) {
+			buf[strlen(buf)-1]='\0';
+			mis_files.push(strdup(buf));
+		}
+		fclose(stream);
+	}
+
+	static char *find_matching_mis_file_prefix(char *pattern) {
+		if(re_comp(pattern)) abort() ;
+		for(int i=0;i<mis_files.length();i++) {
+			if(re_exec(mis_files(i))) break;
+		}
+		if(i<mis_files.length()) return mis_files(i);
+		else return 0;
+	}
+
+	static int part_of_user(int user) {
+		int part;
+		if(user<500) part=0;
+		else if(user<1000) part=1;
+		else if(user<1500) part=2;
+		else part=3;
+		return part;
+	}
+
+	static char type_of_itype(int itype) {
+		char type;
+		switch(itype) {
+		case 0: type='d'; break;
+		case 1: type='u'; break;
+		case 2: type='l'; break;
+		default: abort() ;
+		};
+		return type;
+	}
+
+	NISTCharFile(int user,char itype) {
+		maybe_read_mis_files();
+		int type = type_of_itype(itype);
+		int part = part_of_user(user);
+
+		char buf[512];
+		sprintf(buf,"/com/nist3/data/" "hsf_%d/f%04d_.*/%c%04d_.*",part,user,type,user);
+		char *prefix = find_matching_mis_file_prefix(buf);
+		 ;
+		
+		if(!prefix) {
+			bit_w = 0;
+			bit_h = 0;
+			field_w = 0;
+			field_h = 0;
+			return;
+		}
+
+		char file[512];
+
+		strcpy(file,prefix); strcat(file,".mis");
+		if(!readihdrfile(file,&bit_header,&bit_data,&bit_w,&bit_h))
+			abort() ;
+		field_w=atoi(bit_header->par_x);
+		field_h=atoi(bit_header->par_y);
+
+		strcpy(file,prefix); strcat(file,".cls");
+		struct _iobuf  *stream = fopen(file,"r");
+		if(!stream)
+			abort() ;
+		int total=atoi(fgets(buf,sizeof buf,stream));
+		if(total!=bit_h/field_h)
+			abort() ;
+		while(fgets(buf,sizeof buf,stream)) classes.push(strtol(buf,0,16));
+		fclose(stream);
+	}
+
+	~NISTCharFile() {
+		free(bit_header);
+		free(bit_data);
+	}
+
+	int length() {
+		return bit_h/field_h;
+	}
+
+	CImage image(int i) {
+		 ;
+		CImage result(field_w,field_h);
+		int bit_w8=bit_w/8;
+		int offset=i*field_h;
+		if(offset>=bit_h) abort() ;
+		int i,j;
+
+
+		for(i=0;i<field_w;i++) for(j=0;j<field_h;j++) {
+			int jj=j+offset;
+			result(i,field_h-j-1)=(!!(bit_data[bit_w8*jj+(i>>3)]&(1<<(7-i&7)))) ;
+		}
+
+		return result.temp();
+	}
+
+	int classification(int i) {
+		return classes(i);
+	}
+};
+
+int *NISTDigitImages_table;
+
+struct NISTDigitImages:ImageDatabase {
+ private:
+	NISTDigitImages(NISTDigitImages&);
+	void operator=(NISTDigitImages&);
+ public:
+	enum {table_size=2101};
+
+	int nclassifications() {return 10;}
+	int nusers() {return 2200;}
+
+	static void init_table() {
+		struct _iobuf  *stream=fopen("/com/nist/nist-digits" ,"r");
+		NISTDigitImages_table = new int[table_size];
+		if(!stream) abort() ;
+		int i=1;
+		while(fscanf(stream,"%d",&NISTDigitImages_table[i])==1) i++;
+		if(i!=table_size) abort() ;
+		fclose(stream);
+		int total=0;
+		for(i=1;i<table_size;i++) NISTDigitImages_table[i]+=NISTDigitImages_table[i-1];
+	}
+
+	static int locate(int v) {
+		int low=0;
+		int high=table_size;
+		if(v>=NISTDigitImages_table[table_size-1]) abort() ;
+		while(low+1<high) {
+			int mid=(low+high)/2;
+			if(NISTDigitImages_table[mid]<=v) low=mid;
+			else high=mid;
+		}
+		while(low<table_size-1&&NISTDigitImages_table[low+1]<=v) low++;
+		return low;
+	}
+
+	int user_offset(int user) {
+		if(unsigned(user)>=2100) abort() ;
+		return NISTDigitImages_table[user];
+	}
+
+	int user_length(int user) {
+		if(unsigned(user)>=2100) abort() ;
+		return NISTDigitImages_table[user+1]-NISTDigitImages_table[user];
+	}
+
+	int current_user;
+	NISTCharFile *current_file;
+
+ private:
+	void get_cache(int user) {
+		if(user!=current_user) {
+			delete current_file;
+			current_file = new NISTCharFile(user,0);
+			current_user = user;
+		}
+	}
+
+ public:
+	NISTDigitImages() {
+		 ;
+		if(!NISTDigitImages_table) init_table();
+		current_user=0;
+		current_file=new NISTCharFile(0,0);
+		 ;
+	}
+
+	~NISTDigitImages() {
+		delete current_file;
+	}
+
+	int length() {return NISTDigitImages_table[table_size-1];}
+
+	int user(int i) {
+		return locate(i);
+	}
+
+	CImage image(int i) {
+		int user = locate(i);
+		get_cache(user);
+		int offset = i-NISTDigitImages_table[user];
+		return current_file->image(offset);
+	}
+
+	int classification(int i) {
+		int user = locate(i);
+		get_cache(user);
+		int offset = i-NISTDigitImages_table[user];
+		return current_file->classification(offset);
+	}
+};
+
+ImageDatabase *make_NISTDigitImages() {
+	return new NISTDigitImages();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/inline4.C b/gcc/testsuite/g++.old-deja/g++.law/inline4.C
new file mode 100644
index 00000000000..c6a15a9ad8f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/inline4.C
@@ -0,0 +1,20 @@
+// GROUPS passed inlining
+// inline file
+// Message-Id: <9306020823.AA14027@joker>
+// From: stefan@mpi-sb.mpg.de
+// Subject: gcc-2.4.2  template function bug  (1)
+// Date: Wed, 2 Jun 93 10:23:14 +0200
+
+extern "C" int printf (const char *, ...);
+
+template <class T> inline T func(const T& x) { return x; }
+
+inline int func(const int& x) { return x; }
+
+
+main()
+{ int x;
+  func(x);
+  printf ("PASS\n");
+ }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/inline6.C b/gcc/testsuite/g++.old-deja/g++.law/inline6.C
new file mode 100644
index 00000000000..f5306798bde
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/inline6.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed inlining
+// inline file
+// Message-Id: <199307162240.AA04019@world.std.com>
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Subject: g++ bug: crash with extern C friend
+// Date: Fri, 16 Jul 1993 18:40:48 -0400
+
+inline void Ignore(){}
+
+extern "C" void foo() {}  // but without extern C  g++ compiles it
+
+struct A
+{
+  void f()     {Ignore();}
+  friend void foo ();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/inline7.C b/gcc/testsuite/g++.old-deja/g++.law/inline7.C
new file mode 100644
index 00000000000..0a1d373d44e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/inline7.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed inlining
+   template <class Type>
+struct A {
+   typedef int X;
+   A() {}
+   virtual ~A() { }
+};
+   template <class Type>
+struct B : public A<Type> {
+   B() { }
+}; 
+B<int>::X x;
diff --git a/gcc/testsuite/g++.old-deja/g++.law/memoized1.C b/gcc/testsuite/g++.old-deja/g++.law/memoized1.C
new file mode 100644
index 00000000000..16e63e2161f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/memoized1.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// Special g++ Options: -fsave-memoized
+// GROUPS passed memoized
+class CArray
+{
+public:
+  CArray();
+};
+class CBTree : public CArray
+{
+};
+class CData
+{
+public:
+  virtual               ~CData();
+};
+class CStr  : public CData
+{
+  inline int     Read();
+  inline int     Write() const;
+};
+class CResource : private CBTree
+{
+  struct SResourceNode
+  {
+    CStr xKey;
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/mentor1.C b/gcc/testsuite/g++.old-deja/g++.law/mentor1.C
new file mode 100644
index 00000000000..a9362e07da8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/mentor1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed mentor
+struct Word {
+   struct S1 *p1;
+};
+struct S1 {
+   Word o;
+   void shift_left(int delta, int ct);
+};
+inline void S1::shift_left(int delta, int ct)
+{
+   int cnt = ct;
+   for (S1 *to_p = this, *from_p = to_p + delta; cnt--;) *to_p++ = *from_p++;
+}
+
+void dispose_t(S1 *tp, int from_index, int ct, const int d_last_t)
+{
+        int new_ct = d_last_t + 1 - ct;
+        tp[0].o.p1[from_index].shift_left(ct, new_ct - from_index);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/missed-error1.C b/gcc/testsuite/g++.old-deja/g++.law/missed-error1.C
new file mode 100644
index 00000000000..50accb55440
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/missed-error1.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed missed-error
+// missed-error file
+// From: John Carr <jfc@Athena.MIT.EDU>
+// Date:     Tue, 02 Feb 1993 07:38:53 EST
+// Subject:  Re: g++ ignores language context of function pointers
+// Message-ID: <9302021238.AA01513@Achates.MIT.EDU>
+
+        typedef void (*pfv2)(double, double);
+        extern "C" { typedef void (*pfv3)(double, double); }// ERROR -  , XFAIL *-*-*
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/missed-error2.C b/gcc/testsuite/g++.old-deja/g++.law/missed-error2.C
new file mode 100644
index 00000000000..c8768055d93
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/missed-error2.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed missed-error
+// missed-error file
+// From: ndc!don@csvax.cs.caltech.edu (Don Erway)
+// Date:     Thu, 21 May 92 15:40:45 PDT
+// Subject:  More on [g++ 2.1 : overloaded function selection incorrect]
+// Message-ID: <9205212240.AA17934@ndc.com>
+
+#include <iostream.h>
+
+inline int max(int a, int b) {return a > b ? a : b;}; // ERROR - candidate
+inline double max(double a, double b) {return a > b ? a : b;}; // ERROR - candidate
+
+main() {
+   static void foo(int i, int j, double x, double y) ;// ERROR - .*
+
+   foo(4, -37, 14.39, 14.38);
+}
+
+static void foo(int i, int j, double x, double y) { // ERROR - extern
+
+   cout << "Max(int): " << max(i,j) << " Max(double): " <<
+max(x,y) << '\n';
+   cout << "Max(int, double): " << max(i, y) << '\n';// ERROR - 
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/missed-error3.C b/gcc/testsuite/g++.old-deja/g++.law/missed-error3.C
new file mode 100644
index 00000000000..017ce5dd420
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/missed-error3.C
@@ -0,0 +1,124 @@
+// Build don't link: 
+// GROUPS passed missed-error
+// missed-error file
+// From: Neil Wilson <csf004@cch.coventry.ac.uk>
+// Date:     Tue, 28 Apr 92 13:53:54 WET DST
+// Subject:  g++ version 2.1 bugs
+// Message-ID: <15717.9204281253@cch.coventry.ac.uk>
+
+
+// enum bool { FALSE = 0, TRUE = 1 };
+
+typedef int T;
+
+class Traversable {
+public:
+    virtual const T item() const = 0;
+    virtual const bool off() const = 0;
+    virtual ~Traversable() { };
+};
+
+class Chain : public Traversable {
+public:
+    virtual const int count() const = 0;
+    virtual const bool empty() const = 0;
+    virtual void forth() const = 0;
+    virtual const bool isfirst() const = 0;
+    virtual const bool islast() const = 0;
+    virtual const int position() const = 0;
+    virtual const T first() const = 0;
+    virtual const T last() const = 0;
+    virtual const T i_th(const int index) const = 0;
+    virtual void start() const = 0;
+    virtual void back() const = 0;
+    virtual void finish() const = 0;
+    virtual void move(const int index) const = 0;
+    virtual void go(const int index) const = 0;
+    virtual void put(const T value) = 0;
+    virtual void put_i_th(const T value, const int index) = 0;
+    virtual void swap(const int index) = 0;
+    virtual void wipe_out() = 0;
+};
+class List : public Chain {
+protected:
+    int item_count;
+    int cursor_position;
+    virtual void go_offleft() const = 0;
+    virtual void go_offright() const = 0;
+    virtual void copy(const List& other) = 0;
+public:
+    List() : item_count(0), cursor_position(0) { };
+    virtual const int count() const;
+    virtual const bool empty() const;
+    virtual const bool isfirst() const;
+    virtual const bool islast() const;
+    virtual const bool offleft() const;
+    virtual const bool offright() const;
+    virtual const bool off() const;
+    virtual const int position() const;
+    virtual const T first() const;
+    virtual const T last() const;
+    virtual const T i_th(const int index) const;
+    virtual void start() const;
+    virtual void forth() const;
+    virtual void back() const;
+    virtual void finish() const;
+    virtual void move(const int index) const;
+    virtual void go(const int index) const;
+    friend const bool operator==(const List& left,
+	const List& right);
+    friend const bool operator!=(const List& left,
+	const List& right);
+    virtual void put_i_th(const T value, const int index);
+    virtual void swap(const int index);
+};
+typedef int T;
+class Array {
+private:
+    int lower_index;
+    int upper_index;
+    T *array;
+protected:
+    virtual void allocate(const int minindex, const int maxindex);
+    virtual void copy(const Array&other);
+public:
+    Array(const int minindex, const int maxindex);
+    Array(const Array& other);
+    virtual const int count() const;
+    virtual const int lower() const;
+    virtual const int upper() const;
+    virtual const T item(const int index) const;
+      const T Array::operator[](const int index); // ERROR - qualification ignored
+    virtual const bool valid_index(const int index) const;
+    virtual const bool empty() const;
+    friend const bool operator==(const Array& left, const Array& right);
+    friend const bool operator!=(const Array& left, const Array& right);
+    virtual void put(const T value, const int index);
+    virtual void wipe_out();
+    Array& operator=(const Array& other);
+    virtual ~Array();
+};
+class Fixed_List: public List, private Array {
+protected:
+    virtual void go_offleft() const;
+    virtual void go_offright() const;
+    virtual void copy(const List& other);
+public:
+    Fixed_List(const List& other);
+    Fixed_List(const int size): Array(1, size) { };
+    virtual const bool empty() const;
+    virtual const int count() const;
+    virtual const T item() const;
+    virtual const T i_th(const int index) const;
+    virtual void move(const int index) const;
+    virtual void put(const T value);
+    virtual void put_i_th(const T value, const int index);
+    virtual void wipe_out() { };
+    Fixed_List& operator=(const List& other);
+};
+
+void Fixed_List::go_offleft() const
+{
+    cursor_position = 0;// ERROR - 
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/missing1.C b/gcc/testsuite/g++.old-deja/g++.law/missing1.C
new file mode 100644
index 00000000000..e6505f578a5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/missing1.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed missing
+// missing file
+// Message-Id: <9207100259.AA11702@quaestor>
+// From: adam@inference.com (David Adam)
+// Subject: G++ does not allow parens around declarators.
+// Date: Thu, 9 Jul 92 19:59:51 PDT
+
+void foo()
+{
+  long (bar)[5];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/nest1.C b/gcc/testsuite/g++.old-deja/g++.law/nest1.C
new file mode 100644
index 00000000000..e8fa80ca9f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/nest1.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed nest
+// nest file
+// From: gs4t@virginia.edu (Gnanasekaran  Swaminathan)
+// Date:     Wed, 30 Dec 1992 20:38:07 GMT
+// Subject:  Local type names bug in g++ 2.3.3
+// Message-ID: <1992Dec30.203807.17504@murdoch.acc.Virginia.EDU>
+
+typedef char* T; // ERROR - previous declaration
+
+struct Y {
+    T a;
+    typedef long T; // error. See ARM p189-191 for details// ERROR - 
+    T b;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/nest2.C b/gcc/testsuite/g++.old-deja/g++.law/nest2.C
new file mode 100644
index 00000000000..adc05568332
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/nest2.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed nest
+struct B
+{
+    class B_I { };
+};
+
+struct D : public B
+{
+    B_I foo;
+    class I : public B_I { };
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/nest3.C b/gcc/testsuite/g++.old-deja/g++.law/nest3.C
new file mode 100644
index 00000000000..405a1604250
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/nest3.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed nest
+#include <iostream.h>
+
+struct inner {
+  static void f() { cout << "inner::f()\n";}
+};
+
+struct outer {
+
+  struct inner {
+    static void f() { cout << "outer::inner::f()\n";}
+  };
+
+  static void f() {
+    inner::f();     //call of outer::inner::f()
+    ::inner::f();   //(try to) call inner::f() => parse error
+  }
+};
+
+main() {
+  outer::f();
+  cout << endl;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/nest4.C b/gcc/testsuite/g++.old-deja/g++.law/nest4.C
new file mode 100644
index 00000000000..183442d61db
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/nest4.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed nest
+// nest file
+// From: Neal Young <ney@princeton.edu>
+// Date:     Mon, 11 Oct 93 17:03:59 EDT
+// Subject:  g++ 2.4.5 bug report: local class decl can't access local static var
+// Message-ID: <9310112103.AA06326@cs>
+
+void f()
+{
+  static int s;
+
+  struct local {
+    int j() { return s; }       // should be okay, see 1991 ref. man. r.9.8
+  };
+}
+
+main()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/nest5.C b/gcc/testsuite/g++.old-deja/g++.law/nest5.C
new file mode 100644
index 00000000000..99e8508e852
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/nest5.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed nest
+// nest file
+// From: tal@vlsi.cs.caltech.edu
+// Date:     Mon, 11 Oct 93 16:26:02 -0700
+// Subject:  Serious bug: g++2.4.5 -Doesn't support local classes
+// Message-ID: <9310112325.AA13386@vlsi.cs.caltech.edu>
+
+void foo() {
+  class Wrapper {
+  public:
+    void F (void * Wrapperptr)
+    {
+      Wrapper * wrapptr = (  Wrapper  *) Wrapperptr;
+    }
+  };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators1.C b/gcc/testsuite/g++.old-deja/g++.law/operators1.C
new file mode 100644
index 00000000000..fa4c10cf3b9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators1.C
@@ -0,0 +1,27 @@
+// GROUPS passed operators
+// opr-conv file
+// Message-Id: <199301040217.AA04377@cypress.ucsc.edu>
+// From: "Dean R. E. Long" <dlong@cse.ucsc.edu>
+// Subject: conversion operator bug?
+// Date: Sun, 3 Jan 1993 18:17:20 -0800
+
+#include <stdio.h>
+class B {};
+
+class A {
+    B *p;
+public:
+    A() { p = 0; }
+    operator B * () { return p; }
+    operator B & () { return *p; }
+};
+
+main()
+{
+    A a;
+    B &b = (B &)a;
+    B *bp = (B *)a;
+    B &br = a.operator B&();
+// What's the right test?
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators10.C b/gcc/testsuite/g++.old-deja/g++.law/operators10.C
new file mode 100644
index 00000000000..fe4f13d4b99
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators10.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-eq file
+// Message-Id: <9306040324.AA22954@balder.cs.wisc.edu>
+// From: so@cs.wisc.edu (Bryan So)
+// Subject: g++ bug
+// Date: Thu, 3 Jun 93 22:24:13 -0500
+
+template <class T>
+struct Test {
+    int data;
+    Test& operator=(int i) { data = i; return *this; }
+};
+
+
+main()
+{
+    Test<int> i, j;
+
+    i = j;
+
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators11.C b/gcc/testsuite/g++.old-deja/g++.law/operators11.C
new file mode 100644
index 00000000000..16eccea6e40
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators11.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-eq file
+// Message-Id: <CCJrut.9M7@csc.ti.com>
+// From: rowlands@hc.ti.com (Jon Rowlands)
+// Subject: g++ 2.4.5: assignment operator in base class
+// Date: Mon, 30 Aug 1993 00:54:29 GMT
+
+class B {
+public:
+	B &	operator = (B);	// delete this line and problem goes away
+};
+
+class D : public B {
+public:
+	D();
+	D(int);
+	D(B);
+};
+
+int
+main() {
+	B	b;
+	D	d;
+
+	d = d;
+
+	d = 0;	// t.cxx:20: assignment not defined for type `D'
+	d = D(0);
+
+	d = b;	// t.cxx:23: assignment not defined for type `D'
+	d = D(b);
+
+	return(0);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators12.C b/gcc/testsuite/g++.old-deja/g++.law/operators12.C
new file mode 100644
index 00000000000..cd5312bc093
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators12.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-eq file
+// Message-Id: <199311181618.AA27761@oil.cs.columbia.edu>
+// From: Sam Fenster <fenster@cs.columbia.edu>
+// Subject: g++ 2.5.3 can't disable assignment
+// Date: Thu, 18 Nov 1993 11:18:18 -0500
+
+class B
+   {
+   B &operator = (const B &);      //Disable assignment!
+  public:
+   virtual ~B () {}
+   };
+
+class D: public B
+   {
+  public:
+   D () {}
+   };
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators13.C b/gcc/testsuite/g++.old-deja/g++.law/operators13.C
new file mode 100644
index 00000000000..3675d50b7fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators13.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-eq file
+// Message-Id: <1993Nov18.210502.28842@midway.uchicago.edu>
+// From: mps@dent.uchicago.edu (Michael Spertus)
+// Subject: g++ 2.5.4 bug : operator=
+// Date: Thu, 18 Nov 1993 21:05:02 GMT
+
+class T {
+};
+
+class EP {
+public:
+  void operator=(T *);
+};
+
+
+void EP::operator=(T *) { }
+
+main()
+{
+  EP ep1, ep2;
+  ep1 = ep2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators14.C b/gcc/testsuite/g++.old-deja/g++.law/operators14.C
new file mode 100644
index 00000000000..191266fe4a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators14.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed operators
+void foo (int * a, int * b, int * c) {}
+
+main() {
+	int a,b,c;
+	foo (&a, &b, &c);
+	(a = b) = c;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators15.C b/gcc/testsuite/g++.old-deja/g++.law/operators15.C
new file mode 100644
index 00000000000..08d952de82c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators15.C
@@ -0,0 +1,27 @@
+// GROUPS passed operators
+// opr-del file
+// Message-Id: <199301272137.AA25213@world.std.com>
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Subject: bug report
+// Date: Wed, 27 Jan 1993 16:37:30 -0500
+
+extern "C" int printf(const char* ...);
+
+int     delete_counter = -1;
+
+struct T{
+  void operator delete (void * p) {delete_counter ++; ::delete p;}
+};
+
+int main(void)
+{
+  T * ps1 = new T;
+
+  ::delete ps1;             // Wrong T::operator delete() is called here
+
+  if (delete_counter != -1)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators16.C b/gcc/testsuite/g++.old-deja/g++.law/operators16.C
new file mode 100644
index 00000000000..384c4e9c286
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators16.C
@@ -0,0 +1,29 @@
+// GROUPS passed operators
+// copy file
+// From: gfm@mencon.mencon.oz.au (Graham Menhennitt)
+// Date:     Thu, 29 Apr 93 20:53:07 EST
+// Subject:  4 bugs in g++ 2.3.3
+// Message-ID: <9304291053.AA00090@mencon>
+
+#include <stdio.h>
+
+int pass = 0;
+struct A {
+        A(void) {}
+        A(const A& a) { ; }
+        A& operator = (const A& a) { pass = 1; }
+};
+
+struct B {
+        B(const A& aa) { B::a = aa; }
+        A a;
+};
+
+main(void)
+{
+        B(A());
+	if (pass)
+		printf ("PASS\n");
+	else
+		printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators17.C b/gcc/testsuite/g++.old-deja/g++.law/operators17.C
new file mode 100644
index 00000000000..e652d9cdd79
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators17.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// Special g++ Options: -Wall -pedantic-errors
+// GROUPS passed operators
+// copy file
+// From: gfm@mencon.mencon.oz.au (Graham Menhennitt)
+// Date:     Thu, 29 Apr 93 20:53:07 EST
+// Subject:  4 bugs in g++ 2.3.3
+// Message-ID: <9304291053.AA00090@mencon>
+
+        struct A {
+                A& operator = (const A& a) {}// ERROR - 
+        };
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators18.C b/gcc/testsuite/g++.old-deja/g++.law/operators18.C
new file mode 100644
index 00000000000..74ea15915f5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators18.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-ampr file
+// From: mecklen@oops.cs.utah.edu (Robert Mecklenburg)
+// Date:     Thu, 8 Oct 92 16:33:08 -0600
+// Subject:  Type conversion and overloading bugs in 2.2.2
+// Message-ID: <9210082233.AA28203@hellgate.utah.edu>
+
+        enum E { a, b, c };
+        struct Estr {
+            E value;
+            Estr()                              {}
+            Estr( int i ) : value( (E)i )       {}
+            operator E()                        { return value; }
+        };
+        extern Estr baz();
+        int bazz() { return baz() & 2; }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators19.C b/gcc/testsuite/g++.old-deja/g++.law/operators19.C
new file mode 100644
index 00000000000..37560411151
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators19.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-ampr file
+// From: Jarkko Sonninen <Jarkko.Sonninen@lut.fi>
+// Date:     Thu, 7 Oct 1993 08:25:26 +0200
+// Subject:  type of base class member
+// Message-ID: <199310070625.AA18653@kaisa.it.lut.fi>
+
+class A {
+  public:
+    int j;
+};
+
+class B: public A {
+  public:
+    B () {
+        !(A::j);
+    };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators2.C b/gcc/testsuite/g++.old-deja/g++.law/operators2.C
new file mode 100644
index 00000000000..82954ff7abe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators2.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-conv file
+// Message-Id: <199301260142.AA13995@world.std.com>
+// From: gparker@world.std.com (Glenn P Parker)
+// Subject: gcc bug
+// Date: Mon, 25 Jan 1993 20:42:35 -0500
+
+int main(void)
+{
+  int i = int();  // g++ 2.3.3 cannot compile it.
+
+  return 0;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators21.C b/gcc/testsuite/g++.old-deja/g++.law/operators21.C
new file mode 100644
index 00000000000..c1f8b8be133
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators21.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed operators
+
+struct A {
+        int x;
+};
+
+int operator()(A x,float y) {// ERROR - .*
+        return 1;
+}
+
+main() {
+        A x;
+        x(1.0); // ERROR - no match
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators22.C b/gcc/testsuite/g++.old-deja/g++.law/operators22.C
new file mode 100644
index 00000000000..e550dac48a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators22.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed operators
+template <class T>
+class t {
+public:
+  t() {}
+};
+
+class m {
+  t<int> c;
+public:
+  m() : c() {}
+};
+
+m *p() {return new m;}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators23.C b/gcc/testsuite/g++.old-deja/g++.law/operators23.C
new file mode 100644
index 00000000000..64036550934
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators23.C
@@ -0,0 +1,35 @@
+// GROUPS passed operators
+// opr-new file
+// From: (The Crossjammer) <xjam@cork.cs.berkeley.edu>
+// Date:     Mon, 23 Nov 92 23:35:26 PST
+// Subject:  g++-2.3.1 : Incorrectly calls overloaded operator new
+// Message-ID: <9211240735.AA06872@cork.CS.Berkeley.EDU>
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+class blah {
+     int j;
+   public:
+     blah();
+     void *operator new(size_t size);
+};
+
+inline blah::blah() : j(0) {
+	  
+}
+
+
+void *blah::operator new(size_t size) {
+     printf ("FAIL\n");
+     exit (1);
+     return NULL;
+}
+
+int main(int arg, char** argv) {
+     blah* blahPtr;
+
+     blahPtr = new blah[100];
+     printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators24.C b/gcc/testsuite/g++.old-deja/g++.law/operators24.C
new file mode 100644
index 00000000000..46346e5942c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators24.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-new file
+// From: rwave!myersn%rwave.roguewave@cs.orst.edu (Nathan Myers)
+// Date:     Wed, 16 Dec 92 11:55 PST
+// Subject:  2.3.2: friend decl breaks member op new
+// Message-ID: <m0n24qP-0000GmC@rwave.roguewave.com>
+
+#include <stddef.h>
+struct Link {
+  void* operator new(size_t, int);
+  friend void* __builtin_new(size_t);  // This declaration triggers the bug
+};
+void f() { new(2) Link; }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators25.C b/gcc/testsuite/g++.old-deja/g++.law/operators25.C
new file mode 100644
index 00000000000..4b701b6136f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators25.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-new file
+// From: gparker@world.std.com (Glenn P Parker)
+// Date:     Mon, 25 Jan 1993 20:43:43 -0500
+// Subject:  gcc bug
+// Message-ID: <199301260143.AA14133@world.std.com>
+
+typedef int (**PPF)(int);
+
+int main(void)
+{
+  PPF pf2 = new (int (*) (int));     // internal compiler error on this line.
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators27.C b/gcc/testsuite/g++.old-deja/g++.law/operators27.C
new file mode 100644
index 00000000000..f8ca9d17317
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators27.C
@@ -0,0 +1,33 @@
+// GROUPS passed operators
+// opr-new file
+// From: David Binderman 3841 <dcb@us-es.sel.de>
+// Date:     Mon, 21 Jun 93 11:42:11 +0200
+// Subject:  G++ 2.4.3 and operator new
+// Message-ID: <9306210942.AA10276@slsvitt.us-es.sel.de>
+
+int FLAG=0;
+
+#include <new>
+
+extern "C" int printf( const char *, ...);
+
+void * operator new(size_t, const nothrow_t&) throw()         { FLAG=1; return 0; }
+
+class K {
+private:
+        int i;
+public:
+        K( int j) {
+                i = j;
+        }
+};
+
+int main(void)
+{
+    K * pK = new (nothrow) K( 10);
+    if ( FLAG != 1 )
+	printf ("FAIL\n");
+    else
+	printf ("PASS\n");
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators28.C b/gcc/testsuite/g++.old-deja/g++.law/operators28.C
new file mode 100644
index 00000000000..c0d1ecdad2d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators28.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed operators
+#include <sys/types.h>
+#include <stdio.h>
+
+class new_test
+{
+  int type;
+public:
+  void* operator new(size_t sz, int count, int type);
+};
+
+void* new_test::operator new(size_t sz, int count, int type)
+{
+  void *p;
+
+  printf("%d %d %d\n", sz, count, type);
+
+  p = new char[sz * count];
+  ((new_test *)p)->type = type;
+  return p;
+};
+
+main()
+{
+  new_test *test;
+  int count = 13;
+
+  test = new(count, 1) new_test;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators29.C b/gcc/testsuite/g++.old-deja/g++.law/operators29.C
new file mode 100644
index 00000000000..ec0d47c3dc4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators29.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed operators
+// excess errors test - XFAIL *-*-*
+// (Message bugs/opr-del:4)
+// From: jamshid@ses.com (Jamshid Afshar)
+// Date:     Fri, 25 Feb 94 18:44:01 CST
+// Subject:  Re: delete on "smart pointers"
+// Message-ID: <9402262328.AA16321@pancake>
+// 
+// Who was apparently replying to kuhlins@hawk.wifo.uni-mannheim.de
+
+
+template<class T> class Ptr {
+public:
+  Ptr(T*);
+  operator T*();
+};
+
+int main() {
+  Ptr<int> ip = new int(2);
+  delete ip;
+  operator delete(ip);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators3.C b/gcc/testsuite/g++.old-deja/g++.law/operators3.C
new file mode 100644
index 00000000000..e4a8341cca9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators3.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-pl file
+// Message-Id: <9212010409.AA24967@zeus.research.otc.com.au>
+// From: grahamd@zeus.research.otca.oz.au (Graham Dumpleton)
+// Subject: Failure to use conversion operator.
+// Date: Tue, 1 Dec 92 15:11:18 EST
+
+class BUG1
+{
+  public:
+
+    operator char*() const { return myData; }
+    char* myData;
+};
+
+void bug1()
+{
+  BUG1 bug1;
+  bug1.myData = "0123456789";
+  char* s = bug1 + 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators30.C b/gcc/testsuite/g++.old-deja/g++.law/operators30.C
new file mode 100644
index 00000000000..3c23a060a2d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators30.C
@@ -0,0 +1,25 @@
+// GROUPS passed operators
+// opr-mm file
+// Date: Thu, 2 Jun 94 10:00:29 +0200
+// From: chatty@cenatls.cena.dgac.fr (Stephane Chatty)
+// Message-Id: <9406020800.AA14201@geant.cenatls.cena.dgac.fr>
+// Subject: result of operator -- with g++-2.5.8
+
+#include <stdio.h>
+
+nop()
+{
+} // ERROR - non-void
+
+main ()
+{
+        int a = 2;
+
+        if (----a == 0)
+		nop ();
+
+	if (a == 0)
+		printf("PASS\n");
+	else
+		printf("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators31.C b/gcc/testsuite/g++.old-deja/g++.law/operators31.C
new file mode 100644
index 00000000000..a2ba7201d6b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators31.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-del file
+// From: Eberhard Mattes <mattes@azu.informatik.uni-stuttgart.de>
+// Date:     Thu, 4 Aug 94 08:19:20 +0200
+// Subject:  delete [] A::s
+// Message-ID: <9408040619.AA27602@azu.informatik.uni-stuttgart.de>
+
+class A
+{
+  char *s;
+public:
+  void f ();
+};
+
+void A::f ()
+{
+  delete [] A::s;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators32.C b/gcc/testsuite/g++.old-deja/g++.law/operators32.C
new file mode 100644
index 00000000000..bb6f8c902ae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators32.C
@@ -0,0 +1,55 @@
+// Build don't link: 
+// GROUPS passed operators
+#include <iostream.h>
+
+//
+// frees space allocated for N-D array
+//
+
+template <class T>
+void free(long rows, T** array)
+{
+for( long i = 0; i < rows; i++ )
+  delete [] array[i];                   // delete row
+delete [] array;                        // delete outer array
+}
+
+template <class T>
+T* allocate1d(long size, T*& array)
+{
+return array = new T[size];
+}
+
+template <class T>
+T** allocate2d(long d1, long d2, T**& array)
+{
+if( allocate1d(d1, array) != 0 )
+  {
+  for( long i = 0; i < d1; i++ )
+    {
+    if( allocate1d(d2, array[i]) == 0 )
+      {
+      free(i,array);
+      return array;
+      }
+    }
+  }
+return array;
+}
+
+main()
+{
+long d1 = 3, d2 = 4;
+class foo
+{
+public:
+foo() {cout << "foo created" << endl; }
+
+~foo() {cout << "foo deleted" << endl; }
+};
+
+foo **f2;
+allocate2d(d1, d2, f2);// ERROR -  type.*// ERROR -    trying to.*
+free(d1, f2);// ERROR -  type.*// ERROR -    trying to.*
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators33.C b/gcc/testsuite/g++.old-deja/g++.law/operators33.C
new file mode 100644
index 00000000000..bdf5147b875
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators33.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-new file
+// From: flisakow@cae.wisc.edu
+// Date:     Thu, 1 Sep 94 18:21:09 CDT
+// Subject:  g++ bug?
+// Message-ID: <9409012321.AA05346@hprisc-19.cae.wisc.edu>
+
+#include <stdio.h>
+
+
+struct fcell {
+        FILE *fd;
+        struct fcell *next;
+};
+
+
+class FStack {
+public:
+        struct fcell *top;
+        FStack() { top = NULL ; } ;
+        inline void push(FILE * fd1, int line_num, char *fname = NULL) {
+                struct fcell *tmp = new struct fcell;
+                tmp->fd = fd1;
+                tmp->next = top;
+                top = tmp ;
+        }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators34.C b/gcc/testsuite/g++.old-deja/g++.law/operators34.C
new file mode 100644
index 00000000000..316500e5841
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators34.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed operators
+class A {
+    public:
+      A() {
+      }
+};
+
+static class A *A_new_() {
+    return new class A;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators4.C b/gcc/testsuite/g++.old-deja/g++.law/operators4.C
new file mode 100644
index 00000000000..259d3e53f21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators4.C
@@ -0,0 +1,30 @@
+// GROUPS passed operators
+// opr-del file
+// From: rollins@bart.ee.queensu.ca (Mark Rollins)
+// Date:     Thu, 3 Sep 1992 22:01:03 -0400 Fri, 4 Sep 1992 02:00:25 GMT
+// Subject:  delete [size] pointer; Problem
+// Message-ID: <92Sep3.220137edt.30@jarvis.csri.toronto.edu>
+
+#include <Complex.h>
+#include <stdio.h>
+
+class Vector {
+  int           size;
+  Complex       *v;
+ public:
+  Vector(int s=1) { size = s; v = new Complex[size];};
+  ~Vector() { delete [size] v;}// ERROR -  warning
+};
+
+void foo(int s)
+{
+  Vector junk(s);
+}
+
+main()
+{
+  Vector* test;
+  for (int i=0;i<40;i++) // was 100000
+        foo(1000);
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators6.C b/gcc/testsuite/g++.old-deja/g++.law/operators6.C
new file mode 100644
index 00000000000..f66f6496f39
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators6.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-as file
+// From: Klaus Ahrens <ahrens@informatik.hu-berlin.de>
+// Date:     Fri, 26 Mar 93 12:50:37 mez
+// Subject:  no default assignment
+// Message-ID: <199303261149.TA23114@mail.Germany.EU.net>
+
+class A {
+public:
+        A(int){}
+        A& operator=(const A&){return *this;}
+};
+
+class B: public A {
+public:
+        B(int i): A(i) {}
+};
+
+int main()
+{
+        B b=1;
+        b=1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators7.C b/gcc/testsuite/g++.old-deja/g++.law/operators7.C
new file mode 100644
index 00000000000..7d00bd7c2ba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators7.C
@@ -0,0 +1,44 @@
+// GROUPS passed operators
+// opr-as file
+// From: amichail@lambert.waterloo.edu (Amir Michail)
+// Date:     Mon, 15 Jun 1992 19:41:37 GMT
+// Subject:  inheretance bug
+// Message-ID: <AMICHAIL.92Jun15144137@lambert.waterloo.edu>
+
+#include <stdio.h>
+class window {
+ public:
+  int k;
+  virtual void inc() {}
+};
+
+class window_border : public virtual window {
+ public:
+  void inc () { k++; }
+};
+
+class container {
+ public:
+  window_border c;
+#if 0
+  container& operator = (const container& o) {
+    this->c = o.c;
+    return *this;
+  }
+#endif
+};
+
+int main() {
+  container test, *test2;
+  void *vp;
+  test2 = new container;
+  test.c.k = 34;
+  vp = (window *)&test2->c;
+  *test2 = test;
+  test.c.k = 60;
+  if (test2->c.k == 35
+      && test.c.k == 60)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators8.C b/gcc/testsuite/g++.old-deja/g++.law/operators8.C
new file mode 100644
index 00000000000..0b59d3cd1b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators8.C
@@ -0,0 +1,49 @@
+// GROUPS passed operators
+#include <stdio.h>
+
+class shape {
+  public:
+    virtual void vDisplay(void) const = 0;
+  protected:
+    int X;
+    int Y;
+};
+
+class square :public shape {
+  public:
+    square(int x, int y, int width_) {
+	X = x;
+	Y = y;
+	width = width_;
+    }
+    void vDisplay(void) const {
+	printf ("PASS\n");
+    }
+  protected:
+    int width;
+};
+
+
+class triangle :public shape {
+  public:
+    triangle(int x, int y, int width_, int height_) {
+	X = x;
+	Y = y;
+	width = width_;
+	height = height_;
+    }
+    void vDisplay(void) const {
+	printf ("FAIL\n");
+    }
+  protected:
+    int width;
+    int height;
+};
+
+main() {
+    shape* s1 = new square(4,4,5);
+    shape* s2 = new triangle(6,6,2,3);
+    *s1 = *s2;
+    s1->vDisplay();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/operators9.C b/gcc/testsuite/g++.old-deja/g++.law/operators9.C
new file mode 100644
index 00000000000..8aeac843b7b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/operators9.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed operators
+// opr-eq file
+// Message-Id: <9301141514.AA05925@mi.el.utwente.nl>
+// From: klamer@mi.el.utwente.nl (Klamer Schutte)
+// Subject: 2.3.3: failed to detect error
+// Date: Thu, 14 Jan 93 16:14:21 +0100
+
+class B
+{
+public:
+      operator=(B &); // ERROR - no type or storage class
+};
+
+void
+test(B &b1, const B &b2)
+{
+        b1 = b2;// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing1.C b/gcc/testsuite/g++.old-deja/g++.law/parsing1.C
new file mode 100644
index 00000000000..7b032e3eb57
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: hendrik%vedge.UUCP@iro.umontreal.ca
+// Date:     Wed, 23 Sep 92 17:10:28 -0400
+// Subject:  parenthesized method
+// Message-ID: <9209232110.AA02533@.>
+
+
+class goo{
+public:
+      void noo_bloo();
+};
+
+void choo(goo* too)
+{     (too->noo_bloo)();
+}
+
+void choo_too(goo* too)
+{     too->noo_bloo();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing10.C b/gcc/testsuite/g++.old-deja/g++.law/parsing10.C
new file mode 100644
index 00000000000..9fee9ebc808
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing10.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: Eirik Fuller <eirik@elf.ithaca.ny.us>
+// Date:     Wed, 15 Dec 1993 17:06:11 -0500
+// Subject:  parse error
+// Message-ID: <199312152206.AA06584@tonttu.TC.Cornell.EDU>
+
+
+class s;
+
+template <class T>
+class t
+{
+public:
+  void f(T *t);
+};
+
+class l
+{
+public:
+  void s() {};
+};
+
+extern t<l> g;
+
+class p
+{
+public:
+  void *h;
+  s *a() {return (s *) h;};
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing2.C b/gcc/testsuite/g++.old-deja/g++.law/parsing2.C
new file mode 100644
index 00000000000..5570ad93832
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: jonathan@Pescadero.Stanford.EDU
+// Date:     Tue, 15 Sep 92 14:15:29 PDT
+// Subject:  Function taking as argument a pointer to a pointer to a function
+//	     that returns int causes coredump in cc1plus
+// Message-ID: <9209152115.AA07423@Pescadero.Stanford.EDU>
+
+    unsigned char FindMdc ( int (**)() );
+    unsigned char FindMdc2 ( int (**funcname)() );
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing3.C b/gcc/testsuite/g++.old-deja/g++.law/parsing3.C
new file mode 100644
index 00000000000..85b7932f209
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing3.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: tll@cco.caltech.edu (Tal Lewis Lancaster)
+// Date:     18 Mar 1993 17:09:43 GMT
+// Subject:  Re: unexpected difference between gcc and g++ (both 2.3.3)
+// Message-ID: <1oaacnINNt20@gap.caltech.edu>
+
+/* Notice that that this case parses fine */
+int (* volatile y)[10];
+
+void foo2() {
+        /* The parser can't handle it now */
+        int (* volatile x)[10];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing4.C b/gcc/testsuite/g++.old-deja/g++.law/parsing4.C
new file mode 100644
index 00000000000..e834d6f939e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing4.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: Glenn Engel <glenne@lsid.hp.com>
+// Date:     Fri, 29 Jan 93 18:42:03 PST
+// Subject:  Parse Error
+// Message-ID: <9301300242.AA15550@hplslk.lsid.hp.com>
+
+int test1(void (**roc)(int,int)); // parse error
+int test2(int id,void (**orc)(int,int)); // works
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing5.C b/gcc/testsuite/g++.old-deja/g++.law/parsing5.C
new file mode 100644
index 00000000000..f3f847302c4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing5.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed parsing
+// From: Teemu Torma <Teemu.Torma@frend.fi>
+// Date:     Mon, 15 Jun 92 18:42:25 +0300
+// Subject:  G++ 2.2.2: Strange parse error
+// Message-ID: <"relay.fren.501:15.05.92.15.42.30"@frend.fi>
+
+long (*foo1 ()) (); // This is ok.
+
+typedef long INT;
+INT (*foo2 ()) ();  // This is not, g++ says "parse error before `('"
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing6.C b/gcc/testsuite/g++.old-deja/g++.law/parsing6.C
new file mode 100644
index 00000000000..7fcc13c5071
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing6.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: "James S. Vera" <vera@fanaraaken.stanford.edu>
+// Date:     Thu, 01 Jul 1993 16:36:32 -0700
+// Subject:  Mildly complicated type not understood, 2.4.5
+// Message-ID: <9307012336.AA13841@fanaraaken.Stanford.EDU>
+
+typedef  int (*cow[3])(...);
+
+main() {
+  cow fs;
+  int (*pig[3])(...); // line 5
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing7.C b/gcc/testsuite/g++.old-deja/g++.law/parsing7.C
new file mode 100644
index 00000000000..1b73c951dd4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing7.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: szahn%Robinie@goesser.sie.siemens.co.at (Hr. Zahn)
+// Date:     Mon, 5 Jul 93 10:45:51 +0200
+// Subject:  Bug report g++ 2.4.5, unexpected syntax errors
+// Message-ID: <9307050845.AA00499@ets5.uebemc.siemens.de>
+
+int f1(
+    int (**a1)()
+    );
+
+int f2(
+    int (**a1)()
+    );
+
+
+int f3(
+    int (**a1)( int a, int b )
+    );
+
+int f4(
+    int (**a1)( int a, int b )
+    );
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing8.C b/gcc/testsuite/g++.old-deja/g++.law/parsing8.C
new file mode 100644
index 00000000000..9a714a35493
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing8.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// GROUPS passed parsing
+// parsing folder
+// From: nag@soft.flab.fujitsu.co.jp
+// Date:     Thu, 08 Jul 1993 10:54:59 +0900
+// Subject:  g++ cannot understand `void (**f)()'
+// Message-ID: <9307080155.AA00496@kumade.soft.flab.fujitsu.co.jp>
+
+        void
+        func() {
+                int ( * * i )[ 2 ];
+        }
+
+// Looks like this is probably the same problem
+// parsing folder
+// From: nag@soft.flab.fujitsu.co.jp
+// Date:     Thu, 08 Jul 1993 10:54:59 +0900
+// Subject:  g++ cannot understand `void (**f)()'
+// Message-ID: <9307080155.AA00496@kumade.soft.flab.fujitsu.co.jp>
+main()
+{
+        void (**f)();
+}
+
+
+// Same as
+// From: Chris Dodd <dodd@csl.sri.com>
+// Date:     Fri, 16 Jul 93 17:05:04 -0700
+// Subject:  bug in declaration parsing in g++ 2.4.5
+// Message-ID: <9307170005.AA03857@pekoe.csl.sri.com>
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/parsing9.C b/gcc/testsuite/g++.old-deja/g++.law/parsing9.C
new file mode 100644
index 00000000000..13138ed9fce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/parsing9.C
@@ -0,0 +1,32 @@
+// Build don't link: 
+// GROUPS passed parsing
+// From: Jason Merrill <jason@cygnus.com>
+// Date:     Fri, 13 Aug 93 12:49:11 PDT
+// Subject:  2.4.5 won't compile array of pointers to functions returning T
+// Message-ID: <9308131949.AA26348@cygnus.com>
+// From: "Robert M. Keller" <keller@jarthur.Claremont.EDU>
+// Subject: g++ bug
+// Date: Fri, 13 Aug 93 10:09:27 PDT
+
+/* Testing declaration of "array of pointers to functions returning T" */
+
+typedef int T;
+
+T foo()
+{ return 10; }
+
+T bar()
+{ return 20; }
+
+T baz()
+{ return 30; }
+
+main()
+{
+T (*apfrt[10])();
+
+apfrt[0] = foo;
+apfrt[1] = bar;
+apfrt[2] = baz;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/patches1.C b/gcc/testsuite/g++.old-deja/g++.law/patches1.C
new file mode 100644
index 00000000000..e151a33fa24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/patches1.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed patches
+// patches file
+// From: david.binderman@pmsr.philips.co.uk
+// Date:     Wed, 6 Oct 93 17:05:54 BST
+// Subject:  Reno 1.2 bug fix
+// Message-ID: <9310061605.AA04160@pmsr.philips.co.uk>
+
+int type(float)       { return 1; }
+int type(double)      { return 2; }
+int type(long double) { return 3; }
+
+extern "C" int printf( const char *, ...);
+
+main()
+{
+      int i = 0;
+      if (type(0.0) != 2)
+              ++i;
+      if (i > 0)
+	printf ("FAIL\n");
+      else
+	printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/pic1.C b/gcc/testsuite/g++.old-deja/g++.law/pic1.C
new file mode 100644
index 00000000000..818d3d0dd82
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/pic1.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+// GROUPS passed operators
+// pic file
+// Message-Id: <199406132030.NAA23508@dewitt.eecs.berkeley.edu>
+// Subject: gcc-2.5.8 -fpic fails to compile extern const char static initializer
+// Date: Mon, 13 Jun 1994 13:30:14 -0700
+// From: Christopher Hylands <cxh@dewitt.eecs.berkeley.edu>
+
+extern const char SDFdomainName[] = "SDF";
diff --git a/gcc/testsuite/g++.old-deja/g++.law/profile1.C b/gcc/testsuite/g++.old-deja/g++.law/profile1.C
new file mode 100644
index 00000000000..7c602a0fb20
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/profile1.C
@@ -0,0 +1,9 @@
+// Special g++ Options: -pg
+// GROUPS passed profiling
+// Skip if not native
+// excess errors test - XFAIL mips*-*-* alpha*-*-* i[3456]86-*-sco3.2v5*
+#include <stdio.h>
+main()
+{
+  printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/refs1.C b/gcc/testsuite/g++.old-deja/g++.law/refs1.C
new file mode 100644
index 00000000000..f0b7f118a0f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/refs1.C
@@ -0,0 +1,42 @@
+// GROUPS passed references
+// (Message bugs/refs:1)
+// From: tal@vlsi.cs.caltech.edu
+// Date:     Fri, 25 Feb 94 23:55:50 -0800
+// Subject:  g++-2.5.8 produces incorrect code for references
+// Message-ID: <9402260755.AA27693@vlsi.cs.caltech.edu>
+
+#include <stdio.h>
+
+class C {
+private:
+   char** list;
+public:
+   C(char** );
+   void count (int&);
+};
+
+C::C (char** l) {
+   list = l;
+}
+
+void C::count (int& total) {
+   if (*list == NULL)
+      return;
+   else {
+      list++;
+      count (++total); // THIS IS WHERE THE TROUBLE STARTS
+   }
+}
+
+char * foo[] = {
+   "one", "two", "three", NULL};
+
+main() {
+   C c(foo);
+   int i = 0;
+   c.count(i);
+   if (i == 3)
+     printf ("PASS\n");
+   else
+     printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/refs2.C b/gcc/testsuite/g++.old-deja/g++.law/refs2.C
new file mode 100644
index 00000000000..b310bf63317
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/refs2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed references
+int func(int& i)
+{
+  static int& v = i;
+  return v;
+}
+
+int main()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/refs3.C b/gcc/testsuite/g++.old-deja/g++.law/refs3.C
new file mode 100644
index 00000000000..e77dd7fad49
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/refs3.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed references
+const int& min(const int& n, const int& m)
+{
+        return n < m ? n : m;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/refs4.C b/gcc/testsuite/g++.old-deja/g++.law/refs4.C
new file mode 100644
index 00000000000..a73c078ce98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/refs4.C
@@ -0,0 +1,21 @@
+// GROUPS passed references
+extern "C" void printf (char *, ...);
+
+const int& min(const int& tX, const int& tY)
+{
+        return tX < tY ? tX : tY;
+}
+
+void foo(const int m, const int n)
+{
+	if (m == 1 && n == 100)
+	  printf("PASS\n");
+	else
+	  printf("FAIL\n");
+}
+
+main()
+{
+        foo(min(2, 1), min(100, 200));
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/scope1.C b/gcc/testsuite/g++.old-deja/g++.law/scope1.C
new file mode 100644
index 00000000000..aa70fde059c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/scope1.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed scoping
+// scoping file
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Date:     Fri, 16 Jul 1993 18:48:32 -0400
+// Subject:  g++ gives wrong error for local structure
+// Message-ID: <199307162248.AA05360@world.std.com>
+
+int main(void)
+{
+  struct A{
+  public:       int i;
+    void set (int i)
+      {A::i = i;}           // g++ gives wrong error
+  };
+
+  A a;
+  a.set(17);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/scope2.C b/gcc/testsuite/g++.old-deja/g++.law/scope2.C
new file mode 100644
index 00000000000..f8b90529d73
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/scope2.C
@@ -0,0 +1,44 @@
+// GROUPS passed scoping
+// scoping file
+// From: svkakkad@cs.utexas.edu (Sheetal V. Kakkad)
+// Date:     Tue, 5 Oct 93 12:38:49 -0500
+// Subject:  G++ 2.4.5 - global delete operator not called when using "::delete"
+// Message-ID: <9310051738.AA14586@boogie.cs.utexas.edu>
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+class foo
+{
+ public:
+  foo () { ; }
+  ~foo () { ; }
+  void *operator new (size_t);
+  void operator delete (void *);
+};
+
+void *foo::operator new (size_t size)
+{
+  return malloc (size);
+}
+
+int overloaded_delete = 0;
+
+void foo::operator delete (void *data)
+{
+  free ((char *) data);
+  overloaded_delete++;
+}
+
+main ()
+{
+  foo *f = new foo;
+  foo *ff = ::new foo;
+  ::delete ff;		// should call the default delete operator
+  delete f;
+  if (overloaded_delete == 1)
+    printf ("PASS\n");
+  else
+    printf ("FAIL\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/scope3.C b/gcc/testsuite/g++.old-deja/g++.law/scope3.C
new file mode 100644
index 00000000000..0f36e1b16e8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/scope3.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed scoping
+// local-class file
+// From: dcb@us-es.sel.de
+// Date:     Fri, 27 Nov 92 15:34:28 +0100
+// Subject:  GNU G++ 2.3.1 bug report
+// Message-ID: <9211271434.AA15612@us-es.sel.de>
+
+
+void f()
+{
+        {
+                struct A {
+                        A() {};
+                } a;
+        };
+        {
+                struct A {
+                        A() {};
+                } a ;
+        };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/scope4.C b/gcc/testsuite/g++.old-deja/g++.law/scope4.C
new file mode 100644
index 00000000000..1cfb54e9c34
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/scope4.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed scoping
+// local-class file
+// From: daniels@sugar.neosoft.com (Brad Daniels)
+// Date:     Thu, 5 Aug 93 15:36:36 CDT
+// Subject:  Bug in g++ 2.4.5: Can't touch nested class identifier inside its members
+// Message-ID: <9308051536.AA06115@NeoSoft.Com>
+
+void f() {
+    class foo {
+        int x;
+    public:
+        foo() : x(1) {}
+        int bar() { foo p; return p.x; }
+    };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/scope5.C b/gcc/testsuite/g++.old-deja/g++.law/scope5.C
new file mode 100644
index 00000000000..2aea15bd94c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/scope5.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed scoping
+// local-class file
+// From: schlaege@methusalix.ert.rwth-aachen.de (Chris Schlaeger H Zivojnovic)
+// Date:     Tue, 10 Aug 93 16:50:33 +0200
+// Subject:  Bug report
+// Message-ID: <9308101450.AA28016@methusalix.ert.rwth-aachen.de>
+
+main()
+{
+        class foo
+        {
+                int i;
+        } ;
+        class bar
+        {
+                public:
+                        bar() { y = 0; }
+                        void f() { foo x; }
+                private:
+                        int y;
+        } ;
+
+        bar     c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/shadow1.C b/gcc/testsuite/g++.old-deja/g++.law/shadow1.C
new file mode 100644
index 00000000000..5338bea3c98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/shadow1.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// Special g++ Options: -Wshadow
+// GROUPS passed shadow-warnings
+// shadow file
+// Message-Id: <9211061827.AA03517@harvey>
+// From: Jeff Gehlhaar <jbg@qualcomm.com>
+// Subject: GCC Bug..
+// Date: Fri, 6 Nov 1992 10:27:10 -0700
+
+class Class
+{
+public:
+        Class(void);            // constructor
+        int Shadow(void);       // member function
+private:
+        long value;
+};
+
+Class::Class(void)
+{
+        value = 0;
+}
+
+static inline unsigned char
+Function(int Shadow)
+{
+        return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/shadow2.C b/gcc/testsuite/g++.old-deja/g++.law/shadow2.C
new file mode 100644
index 00000000000..899fe938640
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/shadow2.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// Special g++ Options: -Wshadow
+// GROUPS passed shadow-warnings
+// (Message bugs/shadow:2)
+// From: michael@utex.rni.sub.org (Michael Utech)
+// Date:     Sat, 22 Jan 1994 04:28:00 +0100
+// Subject:  very minor problem/bug in gcc-2.5.4, -Wshadow
+// Message-ID: <m0pNZ1T-0008QUC@utex.rni.sub.org>
+
+class X
+{
+  int count;
+public:
+  X() {} // necessary to produce the `count' warning
+};
+
+template <class T>
+class Y
+{
+  T t;
+public:
+  int f (int count) { return (count); }
+};
+
+main ()
+{
+  Y<char> y;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/static-mem2.C b/gcc/testsuite/g++.old-deja/g++.law/static-mem2.C
new file mode 100644
index 00000000000..3a4489e618f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/static-mem2.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed static-mem
+
+class desc;
+
+class a_desc {
+    public:
+
+    static desc the_desc;
+
+    virtual desc *get_desc();
+};
+
+class desc : public a_desc {
+    public:
+
+    static desc the_desc;
+
+    desc(int);
+
+    desc *get_desc();
+};
+
+
+desc desc::the_desc(1);
+
+desc a_desc::the_desc(0);
diff --git a/gcc/testsuite/g++.old-deja/g++.law/static-mem3.C b/gcc/testsuite/g++.old-deja/g++.law/static-mem3.C
new file mode 100644
index 00000000000..39e4fc2d454
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/static-mem3.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed static-mem
+// static-mem file
+// Message-Id: <9406021639.AA00789@oz.NeXT.COM>
+// From: Sumana Srinivasan <Sumana_Srinivasan@next.com>
+// Date: Thu,  2 Jun 94 09:39:09 -0700
+// Subject: static members function pointers
+
+class CRTFooBar;
+
+class CRTFoo {
+public:
+        static const CRTFooBar & defaultFooBar( );
+
+        CRTFoo( const CRTFoo & );
+        CRTFoo( );
+        CRTFoo( const char *,
+                const CRTFooBar &tp = CRTFoo::defaultFooBar(),
+                int = 0 );
+        CRTFoo &setFoo( double,
+                const CRTFooBar & = CRTFoo::defaultFooBar() );
+
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/static-mem4.C b/gcc/testsuite/g++.old-deja/g++.law/static-mem4.C
new file mode 100644
index 00000000000..4e026478e55
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/static-mem4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed static-mem
+struct test {
+  void test_member() {
+    static test& ds = *this;    // FIX: static test* ds = this;
+  }
+};
+
+
+main()
+{
+  test t;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/static-mem5.C b/gcc/testsuite/g++.old-deja/g++.law/static-mem5.C
new file mode 100644
index 00000000000..2ce0df16f3e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/static-mem5.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed static-mem
+// static-mem file
+// From: bunch@tazboy.jpl.nasa.gov (Walt Bunch)
+// Date:     Thu, 23 Jun 94 14:58:35 UNI
+// Subject:  bug report
+// Message-ID: <9406232258.AA03897@tazboy.JPL.NASA.GOV>
+
+
+class A
+{
+public:
+  static void F (int i) {}
+  static void A::G (int i) {}
+};
+
+main ()
+{
+  A::F (17);
+  A::G (42);
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/template1.C b/gcc/testsuite/g++.old-deja/g++.law/template1.C
new file mode 100644
index 00000000000..809e5090c88
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/template1.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed templates
+
+class String {
+        char s[100];
+};
+
+template <class Element>
+class Art {
+public:
+        Element *data;
+        Art() { data=new Element[100]; }
+};
+
+template <class Key,class Value>
+class Assoc {
+public:
+        struct KeyValue {
+                Key key;
+                Value value;
+                int filled;
+        };
+
+        Art<KeyValue> data;
+        int fill;
+};
+
+main() {
+        Assoc<String,String> table;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/template2.C b/gcc/testsuite/g++.old-deja/g++.law/template2.C
new file mode 100644
index 00000000000..7e5e108a728
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/template2.C
@@ -0,0 +1,16 @@
+// GROUPS passed templates
+extern "C" void printf (char *, ...);
+
+template<class T> T max(T a, T b) { return a > b ? a : b; }
+
+int max(int, int);
+
+main()
+{
+  int j;
+
+  j = max(1,2);
+  j = max (1, 'c');
+  printf ("PASS\n");
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/template3.C b/gcc/testsuite/g++.old-deja/g++.law/template3.C
new file mode 100644
index 00000000000..7523824864e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/template3.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed templates
+template< class R, class T1 = R, class T2 = T1 >
+struct plus
+  {
+  R operator()( const T1& x, const T2& y ) const
+    {
+    return x + y;
+    }
+  };
+
+int
+main()
+  {
+  plus< int > p;
+  return 0;
+  }
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps1.C b/gcc/testsuite/g++.old-deja/g++.law/temps1.C
new file mode 100644
index 00000000000..aa3e8e83bbe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps1.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed temps
+// temps file
+// Date: Mon, 07 Sep 1992 13:12:28 EDT
+// From: richard@ttt.kth.se 
+struct foo
+{
+  char *s;
+  foo(char *x) { s=x; }
+};
+
+struct cookie
+{
+  foo * v;
+  cookie ( foo * x) { v=x; }
+};
+
+cookie cat(&foo("apabepa"));// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps2.C b/gcc/testsuite/g++.old-deja/g++.law/temps2.C
new file mode 100644
index 00000000000..d9684814368
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps2.C
@@ -0,0 +1,54 @@
+// GROUPS passed temps
+// temps file
+// Message-Id: <9212181914.AA05066@sparc1.cnm.us.es>
+// From: juando@cnm.us.es (Juan Domingo Martin Gomez)
+// Subject: Temporaries destroyed too soon
+// Date: Fri, 18 Dec 92 20:14:45 +0100
+
+#include <stdio.h>
+
+int status = 0;
+int fail = 0;
+
+class Foo
+{
+public:
+    Foo();
+    ~Foo();
+
+    Foo &method();
+};
+
+Foo f1()
+{
+    return Foo();
+}
+
+Foo::Foo()
+{
+}
+
+Foo::~Foo()
+{
+    if (status == 2)
+      fail = 0;
+    else
+      fail = 1;
+}
+
+Foo &Foo::method()
+{
+    status++;
+    return *this;
+}
+
+main()
+{
+    // f1() returns a temporary object. The member function
+    // method() returns a reference to the same object.
+    f1().method().method();
+    if (fail)
+      printf ("FAIL\n");
+    else
+      printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps3.C b/gcc/testsuite/g++.old-deja/g++.law/temps3.C
new file mode 100644
index 00000000000..7b092844c5c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps3.C
@@ -0,0 +1,28 @@
+// GROUPS passed temps
+// temps file
+// Message-Id: <9308231535.AA19432@geant.cenatls.cena.dgac.fr>
+// From: chatty@geant.cenatls.cena.dgac.fr (Stephane CHATTY)
+// Subject: g++ 2.4.5 does not destroy temporaries
+// Date: Mon, 23 Aug 93 17:35:34 +0200
+
+#include <stdio.h>
+
+class A {
+public:
+        int a;
+        A (int i) : a (i) { ;}
+        A (const A& aa) : a (aa.a) { ;}
+        ~A () { printf ("PASS\n");; }
+};
+
+A
+foo ()
+{
+        return A (10);
+}
+
+main ()
+{
+        int x = foo ().a;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps4.C b/gcc/testsuite/g++.old-deja/g++.law/temps4.C
new file mode 100644
index 00000000000..2abf56d8214
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps4.C
@@ -0,0 +1,38 @@
+// Special g++ Options: -felide-constructors
+// GROUPS passed temps
+// temps file
+// Message-Id: <9311102043.AA22871@ses.com>
+// From: jamshid@ses.com (Jamshid Afshar)
+// Subject: elide-constructors (aka return value optimization)
+// Date: Wed, 10 Nov 93 14:43:54 CST
+
+#include <stdio.h>
+
+class X {
+    int i;
+  public:
+    X();
+    X(const X&);
+    X(int);
+    ~X();
+};
+
+int did_it = 0;
+
+X::X() { ; }
+X::X(const X&) { did_it = 1; }
+X::X(int) { ; }
+X::~X() { ; }
+
+X foo() {
+    X x(1);
+    return x;
+}
+
+main() {
+    X x = foo();
+    if (did_it)
+	printf ("FAIL\n");
+    else
+	printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps5.C b/gcc/testsuite/g++.old-deja/g++.law/temps5.C
new file mode 100644
index 00000000000..7c591a409e9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps5.C
@@ -0,0 +1,41 @@
+// GROUPS passed temps
+// temps file
+// Message-Id: <9311171029.AA00592@mencon>
+// From: gfm@mencon.mencon.oz.au (Graham Menhennitt)
+// Subject: gcc 2.5.3 - bug deleting object that is still referred to
+// Date: Wed, 17 Nov 93 21:29:23 EST
+
+#include        <stdio.h>
+
+class C {
+public:
+        C(int i) : val(i) { ; }
+        C(const C& c) : val(c.val) { ; }
+        ~C(void) { val = 999; }
+        C& operator = (const C& c) { val = c.val; return *this; }
+
+        C& inc(int i) { val += i; return *this; }
+
+        int val;
+};
+
+C
+f(void)
+{
+        return C(3);
+}
+
+C
+f(int i)
+{
+        return f().inc(i);
+}
+
+int
+main(void)
+{
+	if (f (2).val != 5)
+		printf ("FAIL\n");
+	else
+		printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps6.C b/gcc/testsuite/g++.old-deja/g++.law/temps6.C
new file mode 100644
index 00000000000..e228ce8ea75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps6.C
@@ -0,0 +1,24 @@
+// GROUPS passed temps
+// Date: Tue, 22 Mar 94 12:46:28 +0100
+// From: dak@pool.informatik.rwth-aachen.de
+// Message-Id: <9403221146.AA07815@messua>
+// Subject: Bad code for pointer to member use as reference in g++ 2.5.8
+
+#include <stdio.h>
+struct str {
+  int i;
+} xxx = {0};
+
+int& test(str *arg1, int str::*arg2)
+{
+  return (arg1->*arg2);
+}
+
+main()
+{
+  test(&xxx, &str::i) = 5;
+  if (xxx.i == 0)
+    printf ("FAIL\n");
+  else
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/temps7.C b/gcc/testsuite/g++.old-deja/g++.law/temps7.C
new file mode 100644
index 00000000000..ed1af55ce22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/temps7.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// GROUPS passed temps
+// excess errors test - XFAIL *-*-*
+
+template <class B >
+class A {
+public:
+  class C {};
+};
+
+template class A<int>::C;
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/typeck1.C b/gcc/testsuite/g++.old-deja/g++.law/typeck1.C
new file mode 100644
index 00000000000..2fabfe9db83
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/typeck1.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed typeck
+// typeck file
+// From: vern@daffy.ee.lbl.gov (Vern Paxson)
+// Date:     24 Sep 1992 23:11:22 GMT
+// Subject:  2.2.2 type-checking error (?) when comparing pointers
+// Message-ID: <26475@dog.ee.lbl.gov>
+
+
+        class a { };
+        class foo : a { };
+        class bar : a { };
+
+        test( const foo* f, const bar* b )
+                {
+                return f == b;// ERROR - 
+                }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/typeck2.C b/gcc/testsuite/g++.old-deja/g++.law/typeck2.C
new file mode 100644
index 00000000000..485a9291866
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/typeck2.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed typeck
+// typeck file
+// From: Jutta Degener <jutta@cs.tu-berlin.de>
+// Date:     Wed, 9 Jun 1993 17:58:35 +0200 (MET DST)
+// Subject:  2.4.3: Type of new <typedef'ed array>
+// Message-ID: <199306091558.AA19075@mail.cs.tu-berlin.de>
+
+  typedef int arr[10];
+  main()
+  {
+        int * p = new int[10];
+        int * q = new arr;              /* g++ complains, but shouldn't     */
+        int (* r)[10] = new arr;        /* g++ doesn't complain, but should */// ERROR - 
+  }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/typeck3.C b/gcc/testsuite/g++.old-deja/g++.law/typeck3.C
new file mode 100644
index 00000000000..76c36843fd6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/typeck3.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed typeck
+// typeck file
+// From: Dror Caspi <dror@fibronics.co.il>
+// Date:     Wed, 9 Jun 1993 17:43:48 +0300
+// Subject:  function typedefs in classes
+// Message-ID: <199306091443.AA03735@zorba.fibronics.co.il>
+
+class a
+{
+ public:
+   typedef void (X)();
+
+   X x;   // Member function of type X
+};
+
+class b
+{
+ public:
+   typedef void (X)();   //!!!!!! g++ says : syntax error before `;'
+
+   X x;   // Member function of type X
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/typeck4.C b/gcc/testsuite/g++.old-deja/g++.law/typeck4.C
new file mode 100644
index 00000000000..9b510c05725
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/typeck4.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed typeck
+class A {
+  public:
+    const int &operator[]( int i );
+  private:
+    int k;
+};
+
+const int& A::operator[]( int i )
+{
+    return k;
+}
+
+
+void ff( A &anA )
+{
+    int &ani = anA[0];// ERROR - 
+
+    ani = 7;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/union1.C b/gcc/testsuite/g++.old-deja/g++.law/union1.C
new file mode 100644
index 00000000000..5ab9c905583
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/union1.C
@@ -0,0 +1,30 @@
+// Build don't link: 
+// GROUPS passed unions
+// excess errors test - XFAIL *-*-*
+// anon-union file
+// From: "Terry R. Coley" <terry@wag.caltech.edu>
+// Date:     Tue, 25 Aug 1992 17:33:29 -0700
+// Subject:  possible bug in gcc/g++
+// Message-ID: <199208260033.AA19417@brahms.wag.caltech.edu>
+
+typedef enum { BADBINOP = 0, PLUS, MINUS, MULT, DIV, POWR } binoptype;
+typedef enum { BADUNOP = 0, NEG = POWR+1, SIN, COS, TAN } unoptype;
+
+typedef struct {
+  char *s;
+  union {
+    binoptype bop;
+    unoptype uop;
+  };
+}
+op_to_charp;
+
+op_to_charp BINOPS[] = { {"+", PLUS},
+                         {"-", MINUS},
+                         {"*", MULT},
+                         {"/", DIV},
+                         {"^", POWR} };
+
+main() {
+  int dummy;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/union2.C b/gcc/testsuite/g++.old-deja/g++.law/union2.C
new file mode 100644
index 00000000000..9f812d762e8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/union2.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed unions
+// anon-union file
+// From: gerlek@dat.cse.ogi.edu (Michael Gerlek)
+// Date:     Tue, 8 Dec 92 12:56 PST
+// Subject:  private anonymous unions have public members? (gcc-2.3.1)
+// Message-ID: <m0mzByL-0000hoC@dat.cse.ogi.edu>
+
+class A {
+public:
+  int x;
+private:
+  int y;
+  union {
+    int z;
+  };
+};
+
+void f() {
+  A a;
+
+  a.x = 0;
+  a.y = 1;// ERROR - .*
+  a.z = 2;// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/union3.C b/gcc/testsuite/g++.old-deja/g++.law/union3.C
new file mode 100644
index 00000000000..62e894727df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/union3.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed unions
+// anon-union file
+// From: dcb@us-es.sel.de (David Binderman 3841)
+// Date:     Tue, 30 Mar 93 09:06:15 +0200
+// Subject:  Page 183 of the ARM
+// Message-ID: <9303300706.AA17079@slsvitt>
+
+static union {
+        char*   uC;
+private:
+        int     uI;// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/union4.C b/gcc/testsuite/g++.old-deja/g++.law/union4.C
new file mode 100644
index 00000000000..2178697f8ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/union4.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// GROUPS passed unions
+// anon-union file
+// From: hossein@veritas.com (Hossein Raassi)
+// Date:     Wed, 15 Dec 93 13:52 PST
+// Subject:  Internal Error
+// Message-ID: <m0pA49A-0000LdC@piano.veritas.com>
+
+static union {
+        struct SS {
+                int ss;
+        };
+};// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/unsorted1.C b/gcc/testsuite/g++.old-deja/g++.law/unsorted1.C
new file mode 100644
index 00000000000..eae69e8e94e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/unsorted1.C
@@ -0,0 +1,31 @@
+// Build don't link: 
+// Special g++ Options: -O
+// GROUPS passed unsorted
+// unsorted.2 file
+// From: skipnyc!skipsun!skip@fsg.com (Skip Gilbrech)
+// Date:     Wed, 10 Jun 92 6:55:18 EDT
+// Subject:  Problem with derived class access adjustment and -O
+// Message-ID: <9206101055.AA20593@skipsun.UUCP>
+
+
+class A {
+  public:
+    virtual void func() = 0;
+};
+
+class B : public A {
+  public:
+    void func() {}
+};
+
+class C : private B {
+  public:
+    B::func;
+};
+
+class D {
+    C c;
+  public:
+    void func() { c.func(); }
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/unsorted2.C b/gcc/testsuite/g++.old-deja/g++.law/unsorted2.C
new file mode 100644
index 00000000000..3b81431233d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/unsorted2.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed unsorted
+// code-gen file
+// From: klaus@steinitz.mathematik.uni-dortmund.de
+// Date:     Mon, 15 Nov 1993 16:51:11 +0100
+// Message-ID: <9311151551.AA17761@steinitz.mathematik.uni-dortmund.de>
+
+template <int A,int B>
+class X
+{
+};
+
+template <int A,int B,int C>
+X<A,C> f(X<A,B>,X<B,C>)
+{
+  X<A,C> result;
+  return result;
+}
+
+main()
+{
+  X<1,3> x;
+  X<1,2> y;
+  X<2,3> z;
+  x=f(y,z);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/vbase1.C b/gcc/testsuite/g++.old-deja/g++.law/vbase1.C
new file mode 100644
index 00000000000..a68c3b143b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/vbase1.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS passed vbase
+// vbase file
+// From: pino@hubble.eecs.berkeley.edu (Jose Luis Pino)
+// Date:     28 Jul 1994 05:17:39 GMT
+// Subject:  g++ 2.6 bug: virtual base class & protected methods
+// Message-ID: <317f1j$o9c@agate.berkeley.edu>
+
+
+#include <iostream.h>
+
+class a {
+protected:
+	virtual void foo() { cout << "Class A\n";}
+};
+
+class b : public virtual a {};
+
+class c : public b {
+public:
+	void bar() { b::foo();}
+};
+
+main() {
+	c test;
+	test.bar();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/virtual1.C b/gcc/testsuite/g++.old-deja/g++.law/virtual1.C
new file mode 100644
index 00000000000..8192273f0a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/virtual1.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// Special g++ Options: -Woverloaded-virtual
+// GROUPS passed virtual-warnings
+// copy file
+// From: gfm@mencon.mencon.oz.au (Graham Menhennitt)
+// Date:     Thu, 29 Apr 93 20:53:07 EST
+// Subject:  4 bugs in g++ 2.3.3
+// Message-ID: <9304291053.AA00090@mencon>
+
+        struct A {
+                virtual ~A(void);
+        };
+
+        struct B {
+                friend class A;
+                virtual void f(void);
+        };
+
+        struct C : public A {
+                virtual void f(void);
+        };
diff --git a/gcc/testsuite/g++.old-deja/g++.law/virtual2.C b/gcc/testsuite/g++.old-deja/g++.law/virtual2.C
new file mode 100644
index 00000000000..fa9bb69a4a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/virtual2.C
@@ -0,0 +1,31 @@
+// GROUPS passed virtual-functions
+// Not in g++ bugs snapshot
+// From: grande@isi.edu (Jim Grande)
+// Subject: g++ 2.3.3 (HPPA) virt class definition dumps core
+// Date: 5 Mar 1993 22:51:14 -0500
+// Message-ID: <23611@venera.isi.edu>
+
+#include <stdio.h>
+
+class doubleclass
+{
+	public:
+		double	d;
+		doubleclass(double x = 0)	{ d = x; };
+};
+
+class test
+{
+	doubleclass doublec;
+};
+
+class vderived : virtual public test
+{
+};
+
+int main()
+{
+	vderived v;
+
+	printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/virtual3.C b/gcc/testsuite/g++.old-deja/g++.law/virtual3.C
new file mode 100644
index 00000000000..d141f87ecb1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/virtual3.C
@@ -0,0 +1,47 @@
+// GROUPS passed virtual-functions
+// virtual file
+// From: allan@ramjet.multinet.DE (Allan Brighton)
+// Subject: pos. bug in gcc-2.5.2 on hp
+// Date: 4 Nov 1993 22:57:36 -0500
+// Message-ID: <9311041820.AA05942@ramjet.multinet.DE>
+
+#include <iostream.h>
+#include <strstream.h>
+
+
+class BugStream : public ostrstream {
+public:
+    BugStream() {}
+    BugStream& eval();
+};
+
+
+static struct Eval_ { } eval;
+BugStream& operator<<(ostream& os, Eval_);
+
+BugStream& BugStream::eval()
+{
+   // make sure str is null terminated
+   *this << ends;
+   
+   // eval the command and set the status
+   char* s = str();
+   cerr << s << endl;
+   
+   // reset the stream for the next command    
+   clear(0);
+   rdbuf()->freeze(0);
+   seekp(0);
+   
+   return *this;
+}
+
+BugStream& operator<<(ostream& os, Eval_)
+{
+    return ((BugStream&)os).eval();
+}
+
+main() {
+    BugStream bs;
+    bs << "PASS" << eval;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/virtual4.C b/gcc/testsuite/g++.old-deja/g++.law/virtual4.C
new file mode 100644
index 00000000000..f6310d35fa1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/virtual4.C
@@ -0,0 +1,31 @@
+// GROUPS passed virtual-functions
+#include <stdio.h>
+#include <stdlib.h>
+
+int aset = 0;
+class A
+{
+  public:
+    void Set() { SetProp(); }
+    virtual void SetProp() { aset++;}
+};
+
+class B:public A
+{
+  public:
+    void SetProp() { if (!aset) { printf ("FAIL\n"); exit (0);} aset--;}
+};
+
+main()
+{
+    A a;
+    B b;
+    A *c=new A;
+    A *d=new B;
+
+    a.Set();
+    b.Set();
+    c->Set();
+    d->Set();
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility10.C b/gcc/testsuite/g++.old-deja/g++.law/visibility10.C
new file mode 100644
index 00000000000..14dfa333dea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility10.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed visibility
+
+#include <iostream.h>
+
+class base {
+public:
+  void f1 () { cout << "f1" << endl; };
+  void f2 () { cout << "f2" << endl; };
+};
+
+class deriv : public base {
+  void base :: f1();// ERROR - .*
+};
+
+int main ()
+{
+  deriv d;
+
+  d.f2();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility11.C b/gcc/testsuite/g++.old-deja/g++.law/visibility11.C
new file mode 100644
index 00000000000..9fa31dc3163
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility11.C
@@ -0,0 +1,48 @@
+// Build don't link: 
+// Special g++ Options: -w
+// GROUPS passed visibility
+// visibility file
+// From: Alan Shepherd <a.shepherd@nexor.co.uk>
+// Date:     Tue, 22 Jun 1993 14:53:23 +0100
+// Subject:  bug with MI in gcc-2.4.5
+// Message-ID: <9659.740757203@nexor.co.uk>
+
+class A
+{
+    int a;
+
+protected:
+
+    virtual void State(int b)   { a = b; }
+
+};
+
+class B : public A
+{
+    char* foo;
+
+public:
+
+    B(const char*);
+};
+
+class C : public A
+{
+    char* foo2;
+
+public:
+
+    C(const char*);
+};
+
+class D : public B, public C
+{
+
+protected:
+
+    virtual void State(int a)
+    {
+        B::State(a);
+        C::State(a);
+    }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility12.C b/gcc/testsuite/g++.old-deja/g++.law/visibility12.C
new file mode 100644
index 00000000000..c3a9963f994
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility12.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: Mark Rawling <Mark.Rawling@mel.dit.csiro.au>
+// Date:     Wed, 30 Jun 93 15:28:34 +1000
+// Subject:  member access rule bug
+// Message-ID: <9306300528.AA17185@coda.mel.dit.CSIRO.AU>
+struct a {
+        int aa;
+        };
+
+class b : private a {
+        };
+
+class c : public b {
+        int xx(void) { return (aa); }  // aa should be invisible// ERROR - .*
+        };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility13.C b/gcc/testsuite/g++.old-deja/g++.law/visibility13.C
new file mode 100644
index 00000000000..f1f4684553f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility13.C
@@ -0,0 +1,108 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: dinh@cs.ucla.edu (Dinh Le)
+// Date:     Mon, 12 Jul 93 22:21:06 -0700
+// Subject:  class, template and their scoping problem
+// Message-ID: <9307130521.AA18312@oahu.cs.ucla.edu>
+
+#include <iostream.h>
+#include <assert.h>
+
+//     ---------------   Array.h  &&  Array.cc   ------------------
+
+const int ArraySize = 12;
+
+template <class Type>
+class Array {
+friend class Array_RC;
+public:
+    Array(const Type *ar, int sz) { init(ar,sz); }
+    virtual ~Array() { delete [] ia; }
+    virtual void print(ostream& = cout);
+    virtual Type& operator[](int ix) { return ia[ix]; }
+private:
+    void init(const Type*, int);
+    int size;
+    int *ia;
+};
+
+template <class Type>
+ostream& operator<<( ostream& os, Array<Type>& ar )
+{
+    ar.print(os);
+    return os;
+}
+
+template <class Type>
+void Array<Type>::print(ostream& os)
+{
+    const lineLength = 12;
+
+    os << "( " << size << " )< ";
+    for (int ix = 0; ix < size; ++ix) {
+        if (ix % lineLength == 0 && ix) os << "\n\t";
+        os << ia[ ix ];
+
+        if (ix % lineLength != lineLength-1 &&
+            ix != size-1)
+            os << ", ";
+    }
+    os << " >\n";
+}
+
+template <class Type>
+void Array<Type>::init(const Type *array, int sz)
+{
+    ia = new Type[size = sz];
+
+    for (int ix = 0; ix < size; ++ix)
+        ia[ix] = (array!=0) ? array[ix] : (Type)0;
+}
+
+//     ---------------   Array_RC.h  &&  Array_RC.cc   ----------------
+
+template <class Type>
+class Array_RC : public Array<Type> {// ERROR - previous declaration.*
+public:
+    Array_RC(const Type *ar, int sz);
+    Type& operator[](int ix);
+};
+
+template <class Type>
+Array_RC<Type>::Array_RC(const Type *ar, int sz) : Array<Type>(ar, sz) {}
+
+template <class Type>
+Type &Array_RC<Type>::operator[](int ix) {
+    assert(ix >= 0 && ix < size);// ERROR - member .size.*
+    return ia[ix];// ERROR - member .ia.*
+}
+
+//    -------------------   Test routine   ----------------------
+
+template <class Type>
+void try_array( Array<Type> &iA )
+{
+    cout << "try_array: initial array values:\n";
+    cout << iA << endl;
+}
+
+template <class Type>
+inline void
+try_array( Array_RC<Type> &rc )
+{
+    try_array( ((Array<Type>&)rc) );
+}
+
+main()
+{
+    static int ia[10] = { 12, 7, 14, 9, 128, 17, 6, 3, 27, 5 };
+    Array_RC<int> iA(ia, 10);// ERROR - .struct Array_RC redecl.*
+
+    cout << "template Array_RC class" << endl;
+    try_array(iA);
+
+    return 0;
+}
+
+template class Array_RC<int>;
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility14.C b/gcc/testsuite/g++.old-deja/g++.law/visibility14.C
new file mode 100644
index 00000000000..7f2251bdf4b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility14.C
@@ -0,0 +1,21 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: ajp@eng.cam.ac.uk
+// Date:     Tue, 13 Jul 93 17:15:11 BST
+// Message-ID: <1171.9307131615@ace.eng.cam.ac.uk
+
+class A {
+    static A* list;
+
+  protected:
+    struct AA {
+        AA();
+        ~AA();
+    };
+};
+
+A::AA::~AA()
+{
+    A* d=list;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility15.C b/gcc/testsuite/g++.old-deja/g++.law/visibility15.C
new file mode 100644
index 00000000000..9371eec798c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility15.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: wpsun4!xinforms!johnjo@uunet.uu.net (John D. Johnson)
+// Date:     Wed, 4 Aug 93 13:25:25 MDT
+// Subject:  Access to private 'operator new()'
+// Message-ID: <9308041925.AA09825@xinforms.wpunix
+#include <stdio.h>
+#include <sys/types.h>
+
+class X {
+private:
+  void* operator new(size_t) {// ERROR - .*
+    printf("Inside private new().\n");
+    return NULL;
+  }
+public:
+  X() {}
+};
+
+
+int main(void)
+{
+  X* p = new X;// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility16.C b/gcc/testsuite/g++.old-deja/g++.law/visibility16.C
new file mode 100644
index 00000000000..b5d87ef363d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility16.C
@@ -0,0 +1,35 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: Marie Trapp <Marie.Trapp@analog.com>
+// Date:     Thu, 5 Aug 93 11:55:15 EDT
+// Subject:  access of protected members
+// Message-ID: <9308051553.AA07639@nwd2sun1.analog.com>
+class A {
+  protected:
+    int astuff;
+    A() {
+        astuff = 3;
+    }
+};
+
+class B : public A {
+    int bstuff;
+  public:
+    B( A *p) {
+        bstuff = p->astuff;// ERROR - .*
+    }
+};
+
+class C : public A {
+    int cstuff;
+  public:
+    C() {
+        cstuff = 5;
+    }
+};
+
+main() {
+    C cvar;
+    B bvar(&cvar);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility17.C b/gcc/testsuite/g++.old-deja/g++.law/visibility17.C
new file mode 100644
index 00000000000..ae198b0bc83
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility17.C
@@ -0,0 +1,63 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: Sandeep Shroff <ss@caere.com>
+// Date:     Thu, 05 Aug 1993 17:23:20 -0700
+// Subject:  Access to private constructor.
+// Message-ID: <9308060023.AA10283@neptune.caere.com>
+#include <iostream.h>
+
+class Base
+{
+public:
+  char* getName() {return name_;}
+
+private:
+  Base();
+  Base(char* str);
+
+  char* name_;
+};
+
+class Derived : public Base
+{
+public:
+  Derived(int n, char* str);
+  Derived(int n);
+
+  getNum() {return num_;}
+private:
+  int num_;
+};
+
+Base::Base()
+{ // ERROR - private
+  name_ = strcpy(new char[strlen(" ") + 1], " ");
+}
+
+Base::Base(char* str)
+{ // ERROR - private
+  if(str != NULL)
+    name_ = strcpy(new char[strlen(str) + 1], str);
+}
+
+Derived::Derived(int n, char* str) : Base(str)
+{// ERROR - .*
+  num_ = n;
+}
+
+Derived::Derived(int n) : Base()
+{// ERROR - .*
+  num_ = n;
+}
+
+
+
+int main()
+{
+  // Derived* d = new Derived(10, "test");
+  Derived* d = new Derived(10);
+
+  cerr << d->getNum() << "\t" << d->getName() << endl;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility18.C b/gcc/testsuite/g++.old-deja/g++.law/visibility18.C
new file mode 100644
index 00000000000..a294f13edf9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility18.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: cmwang@iis.sinica.edu.tw (Chien-Min Wang)
+// Date:     Fri, 6 Aug 93 19:42:31 CST
+// Subject:  A bug in g++ 2.4.5
+// Message-ID: <9308061142.AA08533@iiserv>
+struct T1 { int i; };
+
+struct T2 { int j; };
+
+struct T3 : public T1, private T2 {
+} x;
+
+int main ()
+{
+    x.i = 1;
+    x.j = 2;    // error: x.j is private// ERROR - .*
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility19.C b/gcc/testsuite/g++.old-deja/g++.law/visibility19.C
new file mode 100644
index 00000000000..0f22d6568b7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility19.C
@@ -0,0 +1,40 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: mclaugh@tnt.acsys.com (Mark A. McLaughlin)
+// Date:     Wed, 25 Aug 93 14:30:47 MDT
+// Subject:  g++ bug
+// Message-ID: <9308252030.AA02352@tnt.acsys.com>
+class B {
+protected:
+    int i;
+};
+
+class D1 : public B {
+};
+
+class D2 : public B {
+    friend void fr(B*,D1*,D2*);
+    void mem(B*,D1*);
+};
+
+void fr(B* pb, D1* p1, D2* p2)
+{
+    pb->i = 1;  // illegal// ERROR - .*
+    p1->i = 2;  // illegal// ERROR - .*
+    p2->i = 3;  // ok (access through D2)
+}
+
+void D2::mem(B* pb, D1* p1)
+{
+    pb->i = 1;  // illegal// ERROR - .*
+    p1->i = 2;  // illegal// ERROR - .*
+    i = 3;      // ok (access through `this')
+}
+
+void g(B* pb, D1* p1, D2* p2)
+{
+    pb->i = 1;  // illegal// ERROR - .*
+    p1->i = 2;  // illegal// ERROR - .*
+    p2->i = 3;  // illegal// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility20.C b/gcc/testsuite/g++.old-deja/g++.law/visibility20.C
new file mode 100644
index 00000000000..011abef44c9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility20.C
@@ -0,0 +1,36 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: doug@foxtrot.ccmrc.ucsb.edu (Douglas Scott)
+// Date:     Tue, 10 Aug 93 10:06:33 PDT
+// Subject:  G++ 2.4.5 allows access to protected base members
+// Message-ID: <9308101706.AA04485@foxtrot.ccmrc.ucsb.edu>
+
+class Base {
+protected:
+      void protectedBaseFunction() {} // ERROR - protected
+public:
+    Base() {}
+};
+
+
+class Derived : public Base {
+public:
+    Derived() {}
+    void noticeThisFunction(Base *);
+};
+
+
+void
+Derived::noticeThisFunction(Base *b) {
+    b->protectedBaseFunction(); // ARM says this is not allowed// ERROR - .*
+                                // since it is not called on 'this'
+}
+
+main() {
+    Base b;
+    Derived d;
+    d.noticeThisFunction(&b);
+    printf("gpptest run\n");// ERROR - .*
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility21.C b/gcc/testsuite/g++.old-deja/g++.law/visibility21.C
new file mode 100644
index 00000000000..845854029bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility21.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: klamer@mi.el.utwente.nl (Klamer Schutte)
+// Date:     Thu, 12 Aug 93 12:03:09 +0200
+// Subject:  g++ 2.4.5 failed to report a bug
+// Message-ID: <9308121003.AA02294@mi.el.utwente.nl>
+class A {
+protected:
+      void foo(); // ERROR - protected
+};
+
+class B : public A
+{
+        void bar(A &a)
+                {       a.foo(); }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility22.C b/gcc/testsuite/g++.old-deja/g++.law/visibility22.C
new file mode 100644
index 00000000000..4007769a136
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility22.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed visibility
+// excess errors test - XFAIL *-*-*
+// visibility file
+// From: Robert Carden <carden@thoth.ics.uci.edu>
+// Date:     Thu, 12 Aug 1993 13:48:05 -0700
+// Subject:  bug 8/12/93 -- #5
+// Message-ID: <9308121348.aa26256@Paris.ics.uci.edu>
+
+// 5.cc
+#include <stream.h>
+
+class A {
+        int x;
+public:
+        void f(int);
+        void f(float);
+        void g(void *);
+};
+
+class B : private A {
+protected:
+        A::f;
+public:
+        A::g;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility23.C b/gcc/testsuite/g++.old-deja/g++.law/visibility23.C
new file mode 100644
index 00000000000..31cd26c1fc2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility23.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed visibility
+// excess errors test - XFAIL *-*-*
+// visibility file
+// From: Robert Carden <carden@thoth.ics.uci.edu>
+// Date:     Thu, 12 Aug 1993 13:47:11 -0700
+// Subject:  bug 8/12/93 -- #4
+// Message-ID: <9308121347.aa26185@Paris.ics.uci.edu>
+//
+// 4.cc
+//
+#include <stream.h>
+
+class A {
+        int x;
+public:
+        void f(int);
+        void f(float);
+        void g(void *);
+};
+
+
+class B : public A {
+private:
+        A::f;
+        A::g;// ERROR - .* , XFAIL *-*-*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility24.C b/gcc/testsuite/g++.old-deja/g++.law/visibility24.C
new file mode 100644
index 00000000000..b40075fdbe1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility24.C
@@ -0,0 +1,40 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: joe@consolve.com (Joe Shapiro)
+// Date:     Fri, 20 Aug 93 17:18:18 EDT
+// Subject:  Template classes seem to allow users to get at private members
+// Message-ID: <9308202118.AA25599@ghana.consolve>
+/*
+ * private.cc
+ */
+extern "C" void printf(...);
+
+template <class T>
+class A
+{
+public:
+      void Fun() { printf( "Fun fun fun!\n" ); } // ERROR - private
+};
+
+
+template <class T>
+class B: private A<T>
+{
+};
+
+
+class C
+{
+public:
+    C() { _b.Fun(); }// ERROR - .*
+
+private:
+    B<int> _b;
+};
+
+
+main()
+{
+    C c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility25.C b/gcc/testsuite/g++.old-deja/g++.law/visibility25.C
new file mode 100644
index 00000000000..76ca8d8b402
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility25.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: gfm@mencon.mencon.oz.au (Graham Menhennitt)
+// Date:     Wed, 17 Nov 93 21:30:32 EST
+// Subject:  gcc 2.5.3 - can't privately inherit and contain same class
+// Message-ID: <9311171030.AA00604@mencon>
+#include        <iostream.h>
+
+class A {
+public:
+        A(void);
+};
+
+class B : private A {
+public:
+        B(void) : A() {}
+};
+
+class C : public B {
+public:
+        C(void) : B(), a() {}
+
+private:
+        A a;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility26.C b/gcc/testsuite/g++.old-deja/g++.law/visibility26.C
new file mode 100644
index 00000000000..54fc43e2053
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility26.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: jamshid@ses.com (Jamshid Afshar)
+// Date:     Sun, 12 Dec 93 03:09:15 CST
+// Subject:  Missed access declaration error
+// Message-ID: <9312120909.AA22135@ses.com>
+
+class X {
+  public:
+    void f();
+};
+
+class Y : private X {
+  public:
+    void f(int);// ERROR -    because.*
+    X::f;  // g++ 2.5.5 doesn't flag this misuse
+};// ERROR -  cannot adjust.*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility27.C b/gcc/testsuite/g++.old-deja/g++.law/visibility27.C
new file mode 100644
index 00000000000..4092624f712
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility27.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: jbuck@synopsys.com (Joe Buck)
+// Date:     3 Aug 1994 01:52:04 GMT
+// Subject:  2.6.0 bug with protected members and virtual baseclasses
+// Message-ID: <31mt84$lfq@hermes.synopsys.com>
+
+struct R {
+protected:
+        virtual void foo();
+};
+
+struct A : public R {
+};
+
+struct B : virtual public A {
+        void bletch() { foo();}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility28.C b/gcc/testsuite/g++.old-deja/g++.law/visibility28.C
new file mode 100644
index 00000000000..e92c299960f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility28.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+// GROUPS passed visibility
+extern "C" int printf( const char *, ...);
+
+class B {
+public:
+        B() { };
+        virtual ~B() { printf( "B::~B\n"); };
+};
+
+class D : public B {
+public:
+        virtual ~D() { printf( "D::~D\n"); };
+  void operator = ( int i) { this->~B(); }// ERROR - D has no ~B part to it
+};
+
+int
+main()
+{
+        D * pd = new D;
+        B * pb = pd;
+        delete pb;
+        return 0;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility3.C b/gcc/testsuite/g++.old-deja/g++.law/visibility3.C
new file mode 100644
index 00000000000..1e02a4bd9e5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility3.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: kol@world.std.com (Nikolay Yatsenko)
+// Date:     Wed, 27 Jan 1993 16:39:00 -0500
+// Subject:  g++ bug
+// Message-ID: <199301272139.AA25442@world.std.com>
+
+int x;
+
+int main(void)
+{
+  static int s;
+  int x; // ERROR - declared
+  extern int g();
+
+  struct local {
+    int g() { return x; }   // illegal (non-static x); g++ does not give error// ERROR - 
+    int h() { return s; }   // ok, but g++ give error
+  };
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility4.C b/gcc/testsuite/g++.old-deja/g++.law/visibility4.C
new file mode 100644
index 00000000000..5a92c6c0794
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility4.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: dcb@us-es.sel.de (David Binderman 3841)
+// Date:     Tue, 30 Mar 93 15:48:47 +0200
+// Subject:  page 242 of the ARM
+// Message-ID: <9303301348.AA20751@slsvitt>
+
+class A {
+public:
+        int b;
+};
+
+class C : private A {                   // NOTE WELL. private, not public
+public:
+        int d;
+};
+
+extern "C" int printf( const char *, ...);
+
+class E : public C {
+        void f() {
+                printf( "%d\n", b);// ERROR - .*
+        };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility5.C b/gcc/testsuite/g++.old-deja/g++.law/visibility5.C
new file mode 100644
index 00000000000..a68e360026d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility5.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+// GROUPS passed visibility
+
+class a {
+
+private:
+  a (int i);// ERROR - .*
+
+public:
+  a ();
+};
+
+void test ()
+{
+  a *ap = new a;
+  a *ap2 = new a (3);// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility6.C b/gcc/testsuite/g++.old-deja/g++.law/visibility6.C
new file mode 100644
index 00000000000..7e8b7c744f8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility6.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: Rob Hasker <hasker@sparc0a.cs.uiuc.edu>
+// Date:     Sat, 3 Apr 1993 13:19:05 -0600
+// Subject:  no privacy
+// Message-ID: <199304031919.AA20554@sparc17.cs.uiuc.edu
+class Top {
+public:
+    Top() {}
+      void val() {} // ERROR - private base class
+};
+
+class Derived : private Top {
+public:
+    Derived() {}
+};
+
+class Unrelated {
+    Derived derived;
+public:
+    void oops() { derived.val(); }// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility7.C b/gcc/testsuite/g++.old-deja/g++.law/visibility7.C
new file mode 100644
index 00000000000..26d172bcf81
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility7.C
@@ -0,0 +1,71 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: Gordon Joly <G.Joly@cs.ucl.ac.uk>
+// Date:     Wed, 21 Apr 93 09:42:07 +0100
+// Subject:  /*** BUG REPORT : THE MYTH OF PRIVATE INHERITANCE ***/
+// Message-ID: <9304210842.AA01815@life.ai.mit.edu>
+#include <iostream.h>
+
+class A {
+ private:
+  int number;
+ public:
+  A(int i) : number(i)
+    {}
+  virtual ~A()
+    {}
+  virtual void Number(int c)
+    { number = c; } // ERROR - private
+  virtual int Number()
+    { return number; } // ERROR - private
+};
+
+class B : private A {
+ private:
+  int second_number;
+ public:
+  B(int c, int i) : second_number(c), A(i)
+    {}
+  virtual ~B()
+    {}
+
+  virtual void firstNumber(int b)  // renames member function Number(int) of class A
+    { A::Number(b); }
+  virtual int firstNumber()  // renames member function Number() of class A
+    { return A::Number(); }
+};
+
+
+
+
+class C {
+ private:
+  B* bobject;
+ public:
+  C(B* bp) : bobject(bp)
+    {}
+  virtual ~C()
+    {}
+  //
+  // the following two functions access
+  // private member functions of class B
+  // and they should not be able to do so
+  //
+  virtual void setBValue(int i) 
+    { if (bobject) bobject->Number(i); }// ERROR - .*
+  virtual int getBValue()
+    { if (bobject) { return bobject->Number(); } return 0; }// ERROR - .*
+};
+
+
+main()
+{
+  B* bobject = new B(2, 1);
+  C* cobject = new C(bobject);
+  cobject->setBValue(8);
+  cout << cobject->getBValue() << endl;
+  delete bobject;
+  delete cobject;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility8.C b/gcc/testsuite/g++.old-deja/g++.law/visibility8.C
new file mode 100644
index 00000000000..3e5178c6c01
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility8.C
@@ -0,0 +1,26 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// From: roland@jts.com (Roland Knight )
+// Date:     Thu, 29 Apr 1993 16:17:00 -0400
+// Subject:  gcc 2.3.3 bug
+// Message-ID: <m0nof3E-0021ifC@jts.com
+class t1 {
+protected:
+    int a;
+};
+
+
+class t2 : private t1 {
+public:
+    int b;
+};
+
+
+class t3 : public t2 {
+public:
+    int ttt();
+};
+
+
+int t3::ttt() { return a; }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.law/visibility9.C b/gcc/testsuite/g++.old-deja/g++.law/visibility9.C
new file mode 100644
index 00000000000..df98640c90d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/visibility9.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+// GROUPS passed visibility
+// visibility file
+// rom: roland@jts.com (Roland Knight )
+// Date:     Sat, 8 May 1993 17:27:35 -0400
+// Subject:  gcc 2.3.3 protected member access bug
+// Message-ID: <9305082127.AA19577@icepick.jts.com>
+
+class A {
+protected:
+    int a;
+};
+
+class B : public A {
+public:
+    void f1(A* pa);
+};
+
+
+void B::f1(A* pa) {
+    pa->a = 1;    // illegal but allowed by gcc// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/vtable1.C b/gcc/testsuite/g++.old-deja/g++.law/vtable1.C
new file mode 100644
index 00000000000..c788c179054
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/vtable1.C
@@ -0,0 +1,27 @@
+// Build don't link: 
+// GROUPS passed vtable
+// excess errors test - XFAIL *-*-*
+// vtable file
+// From: mrs@cygnus.com (Mike Stump)
+// Date:     Wed, 20 Apr 1994 17:46:11 -0700
+// Subject:  vtable name generation is wrong
+// Message-ID: <199404210046.RAA25652@rtl.cygnus.com>
+
+// prepare_fresh_vtable doesn't build the names of
+// vtables very well.
+
+struct B {
+  virtual void vf() { }
+};
+
+struct Main {
+  virtual void vf() { }
+};
+
+struct Other : public Main, public B {
+  virtual void vf() { }
+};
+
+struct D : public Main, public B, public Other {
+  virtual void vf() { }
+} a;
diff --git a/gcc/testsuite/g++.old-deja/g++.law/vtable2.C b/gcc/testsuite/g++.old-deja/g++.law/vtable2.C
new file mode 100644
index 00000000000..bbc8074de91
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/vtable2.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// Special g++ Options: -fvtable-thunks
+// GROUPS passed vtable
+struct C1
+{
+    virtual ~C1();
+};
+
+struct C2 : public virtual C1
+{
+        virtual ~C2();
+};
+
+struct C3 : public virtual C2
+{
+    virtual ~C3();
+};
+
+C3::~C3() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.law/vtable3.C b/gcc/testsuite/g++.old-deja/g++.law/vtable3.C
new file mode 100644
index 00000000000..5759026331d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.law/vtable3.C
@@ -0,0 +1,24 @@
+// GROUPS passed vtable
+// vtable file
+// From: Pete Bevin <pete@deng.icl.co.uk>
+// Date:     Mon, 28 Nov 1994 19:57:53 +0000 (GMT)
+// Subject:  g++-2.6.2: Virtual inheritance causes incorrect padding
+// Message-ID: <Pine.SOL.3.91.941128194453.7510A-100000@gabriel>
+
+extern "C" void printf (char *, ...);
+
+struct A {
+};
+
+
+struct B : virtual A {
+   public:
+      int b;
+};
+
+
+main()
+{
+    B blist[10];
+    printf ("PASS\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/.cvsignore b/gcc/testsuite/g++.old-deja/g++.mike/.cvsignore
new file mode 100644
index 00000000000..7abff1dbead
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/.cvsignore
@@ -0,0 +1,2 @@
+Makefile
+config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/align1.C b/gcc/testsuite/g++.old-deja/g++.mike/align1.C
new file mode 100644
index 00000000000..e26d398e0a9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/align1.C
@@ -0,0 +1,56 @@
+// Check to make sure we align virtual base classes properly
+
+class eel_base {
+public:
+};
+
+class markable_eel_base : public eel_base {
+private:
+  int mark;
+};
+
+class eel_edge : public markable_eel_base {
+public:
+private:
+  int foo;
+};
+
+class edge : public virtual eel_edge {
+public:
+  edge() {
+    _weight = 0.0;
+  }
+private:
+  double _weight;
+};
+class eel_branch_edge : public virtual edge {
+};
+class branch_edge : public eel_branch_edge {
+};
+
+class eel_interproc_branch_edge : public branch_edge {
+};
+
+class interproc_edge : public virtual edge {
+};
+
+class eel_jump_edge : public virtual edge {
+protected:
+};
+
+class jump_edge : public eel_jump_edge {
+public:
+};
+
+class eel_interproc_jump_edge : public jump_edge {
+protected:
+};
+
+class interproc_jump_edge : public eel_interproc_jump_edge,
+                            public interproc_edge {
+public:
+};
+
+main () {
+  void *vp = new interproc_jump_edge();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/align2.C b/gcc/testsuite/g++.old-deja/g++.mike/align2.C
new file mode 100644
index 00000000000..36791fed803
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/align2.C
@@ -0,0 +1,16 @@
+class Foo {
+};
+
+class Bar : virtual Foo {
+public:
+  int b;
+} x;
+
+main()
+{
+  // printf("Foo offset %d\n", (int)(Foo*)&x - (int)&x);
+  // printf("b offset %d\n", (int)&x.b - (int)&x);
+  // printf("sizeof is %d\n", sizeof(Bar));
+  // This core dumps on a SPARC is alignment is wrong.
+  Bar blist[10];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ambig1.C b/gcc/testsuite/g++.old-deja/g++.mike/ambig1.C
new file mode 100644
index 00000000000..5f67b743109
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ambig1.C
@@ -0,0 +1,32 @@
+extern "C" int printf(const char *, ...);
+
+struct VB {
+  virtual void f() {
+    printf("VB\n");
+  }
+};
+
+class M : public virtual VB {
+public:
+  int i;
+  void f() {
+    printf("M(%d)\n", i);
+  }
+};
+
+class lM : public M {
+};
+
+class rM : public M {
+};
+
+class D : public lM, rM {
+} d;				// ERROR - ambiguous function
+
+main() {
+  ((lM*)&d)->i = 1;
+  ((rM*)&d)->i = 2;
+  ((rM*)&d)->f();
+  ((lM*)&d)->f();
+  ((VB*)&d)->f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/asm1.C b/gcc/testsuite/g++.old-deja/g++.mike/asm1.C
new file mode 100644
index 00000000000..f6c4fe5feff
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/asm1.C
@@ -0,0 +1,9 @@
+// Build don't link:
+// Special g++ Options: 
+
+struct A {
+  static void foo() asm("_my_routine");
+};
+
+void A::foo() {
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/asm2.C b/gcc/testsuite/g++.old-deja/g++.mike/asm2.C
new file mode 100644
index 00000000000..59771d6c6a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/asm2.C
@@ -0,0 +1,27 @@
+// Compile with -S, there should be no references to
+// LTRAMP in the output.
+
+extern "C"
+{
+  int printf (char *, ...);
+}
+
+void
+sub2 (void (*func) ())
+{
+  (*func) ();
+}
+
+int
+main(void)
+{
+  extern void sub (void);
+
+  sub2 (sub);
+}
+
+void
+sub (void)
+{
+  printf ("hello world\n");
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/bool1.C b/gcc/testsuite/g++.old-deja/g++.mike/bool1.C
new file mode 100644
index 00000000000..c8ff0e8416a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/bool1.C
@@ -0,0 +1,16 @@
+// bool test case
+
+// Build don't link:
+
+void foo(int i) {
+  foo (true);
+}
+
+struct C {
+  void foo(int i) {
+    foo(true);
+  }
+  void bar(bool b) {
+    bar(0);
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/bool2.C b/gcc/testsuite/g++.old-deja/g++.mike/bool2.C
new file mode 100644
index 00000000000..ce2a1f86024
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/bool2.C
@@ -0,0 +1,57 @@
+// Special g++ Options:
+class A {
+public:
+  operator bool () {
+    return true;
+  }
+} a;
+class A1 {
+public:
+  operator int () {
+    return true;
+  }
+} a1;
+class A2 {
+public:
+  operator char * () {
+    return "";
+  }
+} a2;
+class A3 {
+public:
+  operator unsigned long long int () {
+    return true;
+  }
+} a3;
+class A4 {
+public:
+  operator char * () {
+    return "";
+  }
+  operator unsigned long long int () {
+    return true;
+  }
+} a4;
+class A5 {
+public:
+  operator double () {
+    return 256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0
+      *256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0
+	*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0
+	  *256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0*256.0e0;
+  }
+} a5;
+int i = true;
+bool b = true;
+bool c = (bool)(void (A::*)())0;
+bool d = 256;
+main() {
+  if (!d) return 1;
+  if (!a) return 1;
+  if (!(bool)a) return 1;
+  //  if (!(long long)a) return 1;
+  if (!a1) return 1;
+  if (!a2) return 1;
+  if (!a3) return 1;
+  if (!a5) return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/bool4.C b/gcc/testsuite/g++.old-deja/g++.mike/bool4.C
new file mode 100644
index 00000000000..96e4a6c2a52
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/bool4.C
@@ -0,0 +1,3 @@
+// Build don't link:
+
+void foo(bool arg = (1==0)) {}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/conv1.C b/gcc/testsuite/g++.old-deja/g++.mike/conv1.C
new file mode 100644
index 00000000000..b67ecbb0e6f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/conv1.C
@@ -0,0 +1,10 @@
+enum E { C };
+
+E foo() {
+  return C;
+}
+
+main() {
+  if (foo() != C)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/debug1.C b/gcc/testsuite/g++.old-deja/g++.mike/debug1.C
new file mode 100644
index 00000000000..9f7bc39a3ba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/debug1.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// Special g++ Options: -g -O -fkeep-inline-functions
+
+class c {
+public:
+  ~c () { };
+};
+
+int
+foo (const c& lhs)
+{
+  c str (lhs);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast1.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast1.C
new file mode 100644
index 00000000000..31b332bd918
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast1.C
@@ -0,0 +1,22 @@
+// Special g++ Options: -fexceptions -w
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe powerpc-*-eabi
+
+#include <typeinfo>
+
+struct B {
+  virtual f() { }
+};
+
+struct D {
+  virtual f() { }
+};
+
+main() {
+  B b;
+  try {
+    (void)dynamic_cast<D&>(b);
+  } catch (bad_cast) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast2.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast2.C
new file mode 100644
index 00000000000..e6b10d70f8d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast2.C
@@ -0,0 +1,25 @@
+// Special g++ Options: -fexceptions -w
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe powerpc-*-eabi
+
+// Ensure reference handling works.
+
+#include <typeinfo>
+
+struct B {
+  virtual f() { }
+} ob;
+
+struct D : public B {
+  virtual f() { }
+} od;
+
+main() {
+  B *b=&ob;
+  try {
+    void *vp = &dynamic_cast<D&>(*b);
+    return 1;
+  } catch (bad_cast) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast3.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast3.C
new file mode 100644
index 00000000000..ee775d043f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast3.C
@@ -0,0 +1,19 @@
+// Special g++ Options: -fexceptions -w
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+// Ensure that the return type of dynamic_cast is the real type.
+
+struct B {
+  virtual f() { }
+};
+
+struct D : public B {
+  virtual f() { }
+  int i;
+} od;
+
+main() {
+  B *b=&od;
+  if (dynamic_cast<D*>(b)->i)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast4.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast4.C
new file mode 100644
index 00000000000..43cb6ef5292
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast4.C
@@ -0,0 +1,4 @@
+int main() {
+  int* d;
+  dynamic_cast<void*>(d);	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast5.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast5.C
new file mode 100644
index 00000000000..f46d81e4935
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast5.C
@@ -0,0 +1,71 @@
+#include <stddef.h>
+
+void *p;
+int fail;
+
+class HeapTracked {
+public:
+    virtual ~HeapTracked() = 0;
+    void *operator new(size_t size);
+    void operator delete(void *ptr);
+    static bool isObjectAllocation(const HeapTracked *ptr);
+};
+
+HeapTracked::~HeapTracked(){}
+void * HeapTracked::operator new(size_t size)
+{
+    void * memPtr = ::operator new(size);
+    p = memPtr;
+    return memPtr;
+}
+
+void HeapTracked::operator delete(void *ptr)
+{
+    if (p != ptr)
+      fail = 1;
+    ::operator delete(ptr);
+}
+
+bool HeapTracked::isObjectAllocation(const HeapTracked *ptr)
+{
+    if (p != const_cast<void*>(dynamic_cast<const void*>(ptr)))
+      fail = 1;
+    return false;
+}
+
+class Mumble1: public virtual HeapTracked {
+    double d;
+public:
+    virtual ~Mumble1(){}
+};
+
+class Mumble2: public virtual HeapTracked {
+    double d;
+public:
+    virtual ~Mumble2(){}
+};
+
+class Foo: virtual public HeapTracked,
+           virtual public Mumble1,
+           virtual public Mumble2 {
+public:
+    ~Foo(){}
+};
+
+int main()
+{
+    Foo *pf = new Foo;
+    pf->isObjectAllocation(pf);
+
+    Mumble1 *pm1 = pf;
+    pm1->isObjectAllocation(pm1);
+
+    Mumble2 *pm2 = pf;
+    pm2->isObjectAllocation(pm2);
+
+    // delete pf;
+    // delete pm1;
+    delete pm2;
+
+    return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast6.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast6.C
new file mode 100644
index 00000000000..546561dda50
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast6.C
@@ -0,0 +1,12 @@
+#include <typeinfo>
+
+class A {
+public:
+  virtual void j () {}
+};
+
+class B : public A { };
+     
+void x (A& a) {
+  const B& b1 = dynamic_cast<B&>((const A&)a);	// ERROR - opps
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast7.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast7.C
new file mode 100644
index 00000000000..1373d0f5f6e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast7.C
@@ -0,0 +1,28 @@
+// Special g++ Options: -fexceptions
+
+#include <typeinfo>
+#include <stdexcept>
+
+class A {
+public:
+  virtual void j () {}
+};
+
+class B : public A { };
+     
+void x (A& a) {
+  // These should all work.
+  const B& b2 = dynamic_cast<B&>(a);
+  const B& b3 = dynamic_cast<const B&>((const A&)a);
+  const B& b4 = dynamic_cast<const B&>(a);
+}
+
+int main() {
+  try {
+    B b;
+    x (b);
+  } catch (exception& e) {
+    // If we get a bad_cast, it is wrong.
+    return 1;
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast8.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast8.C
new file mode 100644
index 00000000000..5addfe07e73
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast8.C
@@ -0,0 +1,18 @@
+#include <typeinfo>
+
+class Base
+{
+public:
+  virtual ~Base() { }
+};
+
+class Derived : public Base { };
+
+int main()
+{
+    const Derived b;
+    const Base*   ap = &b;
+
+    const Derived* p1 = dynamic_cast<const Derived*>(ap);
+    return p1 == 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/dyncast9.C b/gcc/testsuite/g++.old-deja/g++.mike/dyncast9.C
new file mode 100644
index 00000000000..23db8c912bc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/dyncast9.C
@@ -0,0 +1,16 @@
+class S1 { int i; };
+class S2 { int i; };
+class VB {
+public:
+  virtual void foo() { }
+};
+
+class D : public S1, virtual public VB {
+} d;
+
+class E : public S2, public D {
+} e;
+
+int main() {
+  return (char *)&e - (char *)dynamic_cast<E*>((D*)&e);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh1.C b/gcc/testsuite/g++.old-deja/g++.mike/eh1.C
new file mode 100644
index 00000000000..faa48eedbee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh1.C
@@ -0,0 +1,37 @@
+// Build don't link:
+// Special g++ Options: -fexceptions -O -S
+
+extern "C" void printf (char *, ...);
+extern "C" int atoi (const char *);
+
+struct Exception
+ {
+     int v;
+     Exception(int i) { v = i; };
+ };
+
+ inc(int &i)
+ {
+     try {
+         if (i == 0)
+             throw Exception(i);
+         else
+             i++;
+     }
+     catch (Exception v) {
+         i = v.v;
+     }
+ }
+
+main (int argc, const char *argv[])
+{
+  if (argc != 2)
+    {
+      printf ("usage: a.out <num>\n");
+      exit (1);
+    }
+  int count = atoi (argv[1]);
+  inc (count);
+  printf ("success\n");
+  exit (0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh10.C b/gcc/testsuite/g++.old-deja/g++.mike/eh10.C
new file mode 100644
index 00000000000..a6ada1fedb7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh10.C
@@ -0,0 +1,28 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+void foo() {
+  int i;
+  i = 42;
+  throw i;
+}
+
+void ee(int *);
+
+bar() {
+  int i = 2;
+  ee(&i);
+}
+
+void ee(int *) { }
+
+main() {
+  try {
+    foo();
+    return 3;
+  } catch (int& i) {
+    bar();
+    return i != 42;
+  }
+  return 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh11.C b/gcc/testsuite/g++.old-deja/g++.mike/eh11.C
new file mode 100644
index 00000000000..781521f8fee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh11.C
@@ -0,0 +1,15 @@
+// Special g++ Options: -fexceptions
+// Build don't link:
+
+struct A {
+  ~A();
+};
+
+int main(int argc, char** argv) {
+  A a;
+  return 0;
+}
+
+
+A::~A() {
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh12.C b/gcc/testsuite/g++.old-deja/g++.mike/eh12.C
new file mode 100644
index 00000000000..1a42e52c82c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh12.C
@@ -0,0 +1,14 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class MyError { };
+
+int main (int argc, char **argv) {
+  try {
+    throw MyError();
+  }
+  catch (MyError x) {
+  }
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh13.C b/gcc/testsuite/g++.old-deja/g++.mike/eh13.C
new file mode 100644
index 00000000000..841202f349c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh13.C
@@ -0,0 +1,6 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sh-*-* arm-*-pe**-*
+
+#include <string>
+
+main() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh14.C b/gcc/testsuite/g++.old-deja/g++.mike/eh14.C
new file mode 100644
index 00000000000..e7c321397a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh14.C
@@ -0,0 +1,25 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class arghh {
+public:
+  int n;
+  arghh (int v) { n = v; }
+};
+
+int main () {
+  try {
+    throw arghh (11);
+  }
+  catch (arghh& a) {
+    if (a.n != 11)
+      return 1;
+  }
+  try {
+    throw arghh (22);
+  }
+  catch (arghh& a) {
+    if (a.n != 22)
+      return 2;
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh15.C b/gcc/testsuite/g++.old-deja/g++.mike/eh15.C
new file mode 100644
index 00000000000..9ed673fc87d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh15.C
@@ -0,0 +1,6 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+
+struct A {
+  A() throw (int);
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh16.C b/gcc/testsuite/g++.old-deja/g++.mike/eh16.C
new file mode 100644
index 00000000000..2a986d54466
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh16.C
@@ -0,0 +1,26 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int err = 1;
+
+struct A {
+  ~A() {
+    --err;
+  }
+};
+
+struct B {
+  A a;
+  B() {
+    throw 1;
+  }
+};
+
+main() {
+  try {
+    B b;
+  } catch (...) {
+    return err;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh17.C b/gcc/testsuite/g++.old-deja/g++.mike/eh17.C
new file mode 100644
index 00000000000..482ea0434f9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh17.C
@@ -0,0 +1,25 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int err = 1;
+
+struct A {
+  ~A() {
+    --err;
+  }
+};
+
+struct B : public A {
+  B() {
+    throw 1;
+  }
+};
+
+main() {
+  try {
+    B b;
+  } catch (...) {
+    return err;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh18.C b/gcc/testsuite/g++.old-deja/g++.mike/eh18.C
new file mode 100644
index 00000000000..cf98bce4902
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh18.C
@@ -0,0 +1,63 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class VB {
+public:
+  int n;
+  VB (int v) { n = v; }
+  VB (const VB& o) {
+    n = o.n;
+//    printf("copying VB from %d to %d\n", &o, this);
+  }
+};
+
+class D : public virtual VB {
+  int j;
+public:
+  D(int i1, int i2) : VB(i2) { j = i1; }
+  VB& vb() { return *(VB*)this; }
+  const VB& vb() const { return *(const VB*)this; }
+};
+
+class pD : private virtual VB {
+  int j;
+public:
+  pD(int i1, int i2) : VB(i2) { j = i1; }
+  VB& vb() { return *(VB*)this; }
+  const VB& vb() const { return *(const VB*)this; }
+};
+
+
+int main () {
+  D d(1943, 4279);
+  pD pd(3621, 9527);
+  VB *vb = &d.vb();
+  VB *pvb = &pd.vb();
+
+  // A catch of a public virtual base.
+  try {
+//    printf("Throwing D at %d (VB at %d)\n", &d, vb);
+    throw d;
+  }
+  catch (VB& vb) {
+//    printf("Catching VB at %d\n", &vb);
+    if (vb.n != 4279)
+      return 1;
+  }
+  catch (...) {
+    return 1;
+  }
+
+  // A catch of a private virtual base.
+  try {
+//    printf("Throwing D at %d (VB at %d)\n", &pd, pvb);
+    throw pd;
+  }
+  catch (VB& vb) {
+//    printf("Catching VB at %d\n", &vb);
+    // This was a private base of the throw object, don't catch it.
+    return 1;
+  }
+  catch (...) {
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh19.C b/gcc/testsuite/g++.old-deja/g++.mike/eh19.C
new file mode 100644
index 00000000000..3d9aee14ece
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh19.C
@@ -0,0 +1,23 @@
+// Special g++ Options: -fexceptions
+// Build don't link:
+
+class test1 {
+public:
+  class fehler{public:fehler(){};};
+  func(int a) {
+    if( a == 0 )
+      throw fehler();
+  }
+};
+
+main() {
+  test1 var;
+
+  try {
+    var.func(1);
+    var.func(0);
+  } catch(test1::fehler())		// ERROR - cannot have function type
+    {
+      ;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh2.C b/gcc/testsuite/g++.old-deja/g++.mike/eh2.C
new file mode 100644
index 00000000000..d808a65d135
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh2.C
@@ -0,0 +1,71 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <stdlib.h>
+#include <iostream.h>
+
+class Vector {
+private:
+  int *p;
+  int sz;
+
+public:
+  // Exception class
+  class Range     {
+  private:
+    int value_i;
+
+  public:
+    Range( int i ) { value_i = i; };
+    int value() { return value_i; };
+  };
+
+  Vector( int s );
+  ~Vector();
+  int  size() { return sz; };
+  int& operator []( int i );
+};
+
+Vector::Vector(int s) {
+  sz = s;
+  p = new int[sz];
+}
+
+Vector::~Vector() {
+  delete [] p;
+}
+
+int&
+Vector::operator [](int i) {
+  if (0<=i && i<sz) {
+    return p[i];
+  } else {
+    throw Range( i );
+  }
+}
+
+void crash(Vector& v ) {
+  v[v.size()+10];  // Triggers range error!
+}
+
+void do_something(Vector& v) {
+  crash( v );
+}
+
+void
+f(Vector& v) {
+  try {
+    do_something( v );
+  } catch (Vector::Range& r) {
+    cout << "Invalid vector range " << r.value()
+      << " caught in f()" << endl;
+    exit(0);
+  }
+}
+
+main() {
+  Vector v(10);
+
+  f( v );
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh20.C b/gcc/testsuite/g++.old-deja/g++.mike/eh20.C
new file mode 100644
index 00000000000..31f3c6f928a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh20.C
@@ -0,0 +1,6 @@
+// Build don't link:
+// Special g++ Options: -fexceptions -Wall
+
+main() {
+  throw 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh21.C b/gcc/testsuite/g++.old-deja/g++.mike/eh21.C
new file mode 100644
index 00000000000..261e6ea5c6e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh21.C
@@ -0,0 +1,14 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int main () {
+  try {
+    try {
+      throw 1;
+    } catch ( char * ) {
+    }
+  } catch ( int ) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh23.C b/gcc/testsuite/g++.old-deja/g++.mike/eh23.C
new file mode 100644
index 00000000000..17a9669388f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh23.C
@@ -0,0 +1,46 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <exception>
+
+struct double_fault { };
+int fault_now;
+
+class E {
+public:
+  E() { }
+  E(const E&) {
+    if (fault_now)
+      throw double_fault();
+  }
+};
+
+void foo() {
+  try {
+    throw E();
+  } catch (...) {
+    fault_now = 1;
+    throw;
+  }
+}
+
+void bar() {
+  try {
+    foo();
+  } catch (E e) {	// double fault here
+  }
+}
+
+void my_terminate() {
+  exit (0);		// double faults should call terminate
+}
+
+main() {
+  set_terminate (my_terminate);
+  try {
+    bar();
+  } catch (...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh24.C b/gcc/testsuite/g++.old-deja/g++.mike/eh24.C
new file mode 100644
index 00000000000..c9dd382f469
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh24.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int fail = 0;
+
+struct A {
+  int ok;
+  A() {
+    ok = 1;
+  }
+  ~A() {
+    if (! ok)
+      fail = 1;
+    ok = 0;
+  }
+};
+
+main() {
+  try {
+    try {
+      A  a;
+      throw 1.0;
+    } catch (double i) {
+      A a1;
+      throw 1;    // make sure both a1 and a2 are not destroyed when we throw!
+    } catch (int i) {
+      A a2;
+      throw 1.0;
+    }
+  } catch (int i) {
+  }
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh25.C b/gcc/testsuite/g++.old-deja/g++.mike/eh25.C
new file mode 100644
index 00000000000..66045b1cf56
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh25.C
@@ -0,0 +1,30 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <exception>
+
+void my_terminate() {
+  exit (0);		// Double faults should call terminate
+}
+
+struct A {
+  A() { }
+  ~A() {
+    set_terminate (my_terminate);
+    throw 1;		// This throws from EH dtor, should call my_terminate
+  }
+};
+
+main() {
+  try {
+    try {
+      throw 1;
+    } catch (int i) {
+      A a;		// A hit on this EH dtor went to the wrong place
+      throw 1;
+    }
+  } catch (...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh26.C b/gcc/testsuite/g++.old-deja/g++.mike/eh26.C
new file mode 100644
index 00000000000..35cafa4286a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh26.C
@@ -0,0 +1,15 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class MyExceptionHandler { };
+
+main() {
+  try {
+    throw MyExceptionHandler();
+  } catch(const MyExceptionHandler& eh) {
+    return 0;
+  } catch(...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh27.C b/gcc/testsuite/g++.old-deja/g++.mike/eh27.C
new file mode 100644
index 00000000000..bd07138c753
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh27.C
@@ -0,0 +1,17 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <typeinfo>
+
+class MyExceptionHandler { };
+
+main() {
+  try {
+    throw MyExceptionHandler();
+  } catch(const MyExceptionHandler& eh) {
+    return 0;
+  } catch(...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh28.C b/gcc/testsuite/g++.old-deja/g++.mike/eh28.C
new file mode 100644
index 00000000000..3f2d0a6d68b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh28.C
@@ -0,0 +1,17 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <typeinfo>
+
+int fail = 1;
+
+class X            { public: virtual void p() { } };
+class Y : public X { public: virtual void p() { fail = 0; } };
+
+main()
+{
+  try          { Y y; throw y; }
+  catch (X& x) { x.p();  }
+  catch (...)  { }
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh29.C b/gcc/testsuite/g++.old-deja/g++.mike/eh29.C
new file mode 100644
index 00000000000..58c1f0b3f82
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh29.C
@@ -0,0 +1,27 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int count;
+
+class A {
+public:
+  A() {
+//    printf("ctor %x\n", (int)this);
+    if (count==3)
+      throw 1;
+    ++count;
+    }
+  ~A() {
+    --count;
+//    printf("dtor %x\n", (int)this);
+  }
+};
+
+main() {
+  try {
+    A a[5];
+  } catch (...) {
+    return count;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh3.C b/gcc/testsuite/g++.old-deja/g++.mike/eh3.C
new file mode 100644
index 00000000000..e8b87bf30f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh3.C
@@ -0,0 +1,21 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class foo {
+public:
+  class error {};
+
+  void cause_error(void) { throw error(); }
+};
+
+int main(void)
+{
+  foo f;
+  try {
+    f.cause_error();
+  }
+  catch (foo::error&) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh30.C b/gcc/testsuite/g++.old-deja/g++.mike/eh30.C
new file mode 100644
index 00000000000..61a30c8ddda
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh30.C
@@ -0,0 +1,5 @@
+// Build don't link:
+// Skip if not native
+// Special g++ Options: -fexceptions -fPIC -S
+
+main() { throw 1; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh31.C b/gcc/testsuite/g++.old-deja/g++.mike/eh31.C
new file mode 100644
index 00000000000..65e683cf8fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh31.C
@@ -0,0 +1,23 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int count;
+
+class Foo {
+public:
+  Foo() { ++count; }
+  Foo(const Foo&) { ++count; }
+  ~Foo() { --count; }
+};
+
+
+main() {
+  try {
+    throw Foo();
+  }
+  catch (Foo& object) {
+    if (count == 1)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh32.C b/gcc/testsuite/g++.old-deja/g++.mike/eh32.C
new file mode 100644
index 00000000000..12d601c883f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh32.C
@@ -0,0 +1,20 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+
+class Base {
+public:
+    virtual ~Base() throw();
+};
+ 
+Base::~Base() throw()
+{
+}
+ 
+class Foo : public Base {
+public:
+    virtual ~Foo() throw();
+};
+ 
+Foo::~Foo() throw()
+{
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh33.C b/gcc/testsuite/g++.old-deja/g++.mike/eh33.C
new file mode 100644
index 00000000000..e3a234e06eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh33.C
@@ -0,0 +1,19 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL hppa*-*-* a29k-*-* sparc64-*-elf sh-*-* z8k-*-* arm-*-pe**-*
+
+void my_unexpected() {
+  throw 42;
+}
+
+foo() throw (int) { throw "Hi"; }
+
+main() {
+  set_unexpected (my_unexpected);
+  try {
+    foo();
+  } catch (int i) {
+    if (i == 42)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh34.C b/gcc/testsuite/g++.old-deja/g++.mike/eh34.C
new file mode 100644
index 00000000000..a1be275af47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh34.C
@@ -0,0 +1,14 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+void my_unexpected() {
+  exit (0);
+}
+
+foo() throw () { throw "Hi"; }
+
+main() {
+  set_unexpected (my_unexpected);
+  foo();
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh35.C b/gcc/testsuite/g++.old-deja/g++.mike/eh35.C
new file mode 100644
index 00000000000..d9bd34c58e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh35.C
@@ -0,0 +1,17 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+main() {
+  try {  
+    throw 'a';
+  } catch (char a) {
+    try {
+      throw 'a';
+    } catch (int i) {
+      return 1;
+    } catch (char c) {
+      return 0;
+    }
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh36.C b/gcc/testsuite/g++.old-deja/g++.mike/eh36.C
new file mode 100644
index 00000000000..fbb639204a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh36.C
@@ -0,0 +1,29 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <typeinfo>
+
+class A {
+  int space;
+};
+class B {
+public:
+  int data;
+  B(int i) : data(i) {
+  }
+};
+class D : public A, public B {
+public:
+  D(int i) : B(i) {
+  }
+} d(42);
+
+main() {
+  try {
+    throw &d;
+  } catch (B* b) {
+    if (b->data == 42)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh37.C b/gcc/testsuite/g++.old-deja/g++.mike/eh37.C
new file mode 100644
index 00000000000..75f6523a3a8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh37.C
@@ -0,0 +1,21 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <typeinfo>
+
+class B {
+public:
+  int data;
+  B(int i) : data(i) {
+  }
+} b(42);
+
+main() {
+  try {
+    throw &b;
+  } catch (B* b) {
+    if (b->data == 42)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh38.C b/gcc/testsuite/g++.old-deja/g++.mike/eh38.C
new file mode 100644
index 00000000000..915ef4c89e4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh38.C
@@ -0,0 +1,28 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <typeinfo>
+
+class B {
+public:
+  int data;
+  B(int i) : data(i) {
+  }
+} b(42);
+
+main() {
+  try {
+    throw &b;
+  } catch (const B* bptr) {
+    if (bptr->data == 42)
+      {
+	try {
+	  throw &b;
+	} catch (void *bptr) {
+	  if (((B*)bptr)->data == 42)
+	    return 0;
+	}
+      }
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh39.C b/gcc/testsuite/g++.old-deja/g++.mike/eh39.C
new file mode 100644
index 00000000000..54d10959a57
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh39.C
@@ -0,0 +1,28 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int fail = 1;
+class B {
+public:
+  B() { throw 1; }
+};
+class D : public B {
+public:
+  D();
+};
+
+D::D() try : B() {
+  fail = 1;
+} catch (...) {
+  fail = 0;
+  throw;
+}
+
+main() {
+  try {
+    D d;
+    fail = 1;
+  } catch (...) {
+  }
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh4.C b/gcc/testsuite/g++.old-deja/g++.mike/eh4.C
new file mode 100644
index 00000000000..5de9b03ffe6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh4.C
@@ -0,0 +1,6 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+
+foo() {
+  throw 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh40.C b/gcc/testsuite/g++.old-deja/g++.mike/eh40.C
new file mode 100644
index 00000000000..16badc2d911
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh40.C
@@ -0,0 +1,29 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int fail = 1;
+class B {
+public:
+  B() { throw 1; }
+};
+class D : public B {
+public:
+  D() try : B() {
+    fail = 1;
+  } catch (char c) {
+    fail = 1;
+    throw;
+  } catch (...) {
+    fail = 0;
+    throw;
+  }
+};
+
+main() {
+  try {
+    D d;
+    fail = 1;
+  } catch (...) {
+  }
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh41.C b/gcc/testsuite/g++.old-deja/g++.mike/eh41.C
new file mode 100644
index 00000000000..4127402d09e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh41.C
@@ -0,0 +1,29 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+int fail = 0;
+
+struct A {
+   A () { a = 'a'; b = 'b'; c = 'c'; }
+   ~ A () {
+      if ( a != 'a' ) fail = 1;
+      if ( b != 'b' ) fail = 1;
+      if ( c != 'c' ) fail = 1;
+   }
+   char a, b, c;
+};
+
+void some_init () { throw 1; }
+
+struct C : A {
+   C () { some_init (); }
+};
+
+int main () {
+  try {
+    C c;
+  } catch (int i) {
+    return 0;
+  }
+  return 1;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh42.C b/gcc/testsuite/g++.old-deja/g++.mike/eh42.C
new file mode 100644
index 00000000000..6da9bd51c96
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh42.C
@@ -0,0 +1,18 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+struct none { int i[50]; };
+
+class my_ex { } a;
+
+none throw_it() {
+  throw 1;
+}
+
+int main() {
+    try {
+      none n = throw_it();
+    } catch (int ex) {
+      return 0;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh43.C b/gcc/testsuite/g++.old-deja/g++.mike/eh43.C
new file mode 100644
index 00000000000..c5fbde939d0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh43.C
@@ -0,0 +1,741 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+
+// testcase to check obstack allocation for cleanups
+
+typedef unsigned char byte;
+typedef unsigned short word16;
+typedef unsigned long word32;
+typedef unsigned char boolean;
+enum {FALSE, TRUE};
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+extern "C" {
+typedef unsigned int size_t;
+extern void *memccpy(void *, const void *, int, size_t);
+extern void *memchr(const void *, int, size_t);
+extern void *memset(void *, int, size_t);
+}
+template <class T> struct SecBlock
+{
+public:
+    SecBlock(unsigned int size)
+        : size(size), ptr((new  T [(  size )]) ) {}
+    ~SecBlock()
+        {(memset(( ptr ), 0, (  size )*sizeof(*( ptr ))), delete [] ( ptr )) ;}
+    operator T *() const
+        {return ptr;}
+    T *operator +(unsigned int offset)
+        {return ptr+offset;}
+    T& operator[](int index)
+        {((void) (( index<size ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",      "misc.h" ,   31 ,  "index<size" ), 0) )) ; return ptr[index];}
+    const T& operator[](int index) const
+        {((void) (( index<size ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",      "misc.h" ,   33 ,  "index<size" ), 0) )) ; return ptr[index];}
+    const unsigned int size;
+    T *const ptr;
+};
+typedef SecBlock<byte> SecByteBlock;
+void xorbuf(byte *buf, const byte *mask, unsigned int count);
+void byteReverse(word16 *out, const word16 *in, unsigned int byteCount);
+void byteReverse(word32 *out, const word32 *in, unsigned int byteCount);
+inline word16 Invert(const word16 value)
+{
+    return (value << 8) | (value >> 8);
+}
+inline word32 Invert(const word32 value)
+{
+    word32 work = ((value & 0xFF00FF00L) >> 8) | ((value & 0x00FF00FFL) << 8);
+    return (work << 16) | (work >> 16);
+}
+template <class T> inline T min (const T t1, const T t2)
+{
+    return (t1 < t2 ? t1 : t2);
+}
+template <class T> inline T max (const T t1, const T t2)
+{
+    return (t1 > t2 ? t1 : t2);
+}
+template <class T> inline void swap (T &a, T &b)
+{
+    T temp = a;
+    a = b;
+    b = temp;
+}
+template <class T> inline T rotl(T x, unsigned int y)
+{
+    return ((x<<y) | (x>>(sizeof(T)*8-y)));
+}
+template <class T> inline T rotr(T x, unsigned int y)
+{
+    return ((x>>y) | (x<<(sizeof(T)*8-y)));
+}
+int BytePrecision(unsigned long);
+int BitPrecision(unsigned long);
+unsigned long Crop(unsigned long, int size);
+enum CipherDir {ENCRYPTION, DECRYPTION};
+class BlockTransformation
+{
+public:
+    virtual ~BlockTransformation() {}
+    virtual void ProcessBlock(byte *inoutBlock) =0;
+    virtual void ProcessBlock(const byte *inBlock, byte *outBlock) =0;
+    virtual unsigned int BlockSize() const =0;
+};
+class StreamCipher
+{
+public:
+    virtual ~StreamCipher() {}
+    virtual byte ProcessByte(byte input) =0;
+    virtual void ProcessString(byte *outString, const byte *inString, unsigned int length);
+    virtual void ProcessString(byte *inoutString, unsigned int length);
+};
+class RandomAccessStreamCipher : public StreamCipher
+{
+public:
+    virtual ~RandomAccessStreamCipher() {}
+    virtual void Seek(unsigned long position) =0;
+};
+class RandomNumberGenerator
+{
+public:
+    virtual ~RandomNumberGenerator() {}
+    virtual byte GetByte() =0;
+    virtual int GetBit();
+    virtual word32 GetLong(word32 min=0, word32 max=0xffffffffL);
+    virtual word16 GetShort(word16 min=0, word16 max=0xffff)
+        {return (word16)GetLong(min, max);}
+    virtual void GetBlock(byte *output, unsigned int size);
+};
+template <class T> void Shuffle(RandomNumberGenerator &rng, T *array, unsigned int size)
+{
+    while (--size)
+        swap(array[size], array[(unsigned int)rng.GetLong(0, size)]);
+}
+class HashModule
+{
+public:
+    virtual ~HashModule() {}
+    virtual void Update(const byte *input, unsigned int length) =0;
+    virtual void Final(byte *digest) =0;
+    virtual int DigestSize() const =0;
+    virtual void CalculateDigest(byte *digest, const byte *input, int length)
+        {Update(input, length); Final(digest);}
+};
+class BufferedTransformation
+{
+public:
+    virtual ~BufferedTransformation() {}
+    virtual unsigned long MaxRetrieveable() =0;
+    virtual void TransferTo(BufferedTransformation &target);
+    virtual boolean Attachable() {return FALSE;}
+    virtual void Detach(BufferedTransformation *) {}
+    virtual void Attach(BufferedTransformation *) {}
+    virtual void Close() {InputFinished();}
+    virtual void Put(byte inByte) =0;
+    virtual void Put(const byte *inString, unsigned int length) =0;
+    virtual void InputFinished() {}
+    void PutShort(word16 value, boolean highFirst=TRUE);
+    void PutLong(word32 value, boolean highFirst=TRUE);
+    virtual int Get(byte &outByte) =0;
+    virtual unsigned int Get(byte *outString, unsigned int getMax) =0;
+    int GetShort(word16 &value, boolean highFirst=TRUE);
+    int GetLong(word32 &value, boolean highFirst=TRUE);
+    unsigned int Skip(unsigned int skipMax);
+};
+class PK_CryptoSystem
+{
+public:
+    virtual ~PK_CryptoSystem() {};
+    virtual unsigned int MaxPlainTextLength() const =0;
+    virtual unsigned int CipherTextLength() const =0;
+};
+class PK_Encryptor : public PK_CryptoSystem
+{
+public:
+    virtual void Encrypt(RandomNumberGenerator &rng, const byte *plainText, unsigned int plainTextLength, byte *cipherText) =0;
+};
+class PK_Decryptor : public PK_CryptoSystem
+{
+public:
+    virtual unsigned int Decrypt(const byte *cipherText, byte *plainText) =0;
+};
+class PK_SignatureSystem
+{
+public:
+    virtual ~PK_SignatureSystem() {};
+    virtual unsigned int MaxMessageLength() const =0;
+    virtual unsigned int SignatureLength() const =0;
+};
+class PK_Signer : public PK_SignatureSystem
+{
+public:
+    virtual void Sign(RandomNumberGenerator &rng, const byte *message, unsigned int messageLen, byte *signature) =0;
+};
+class PK_Verifier : public PK_SignatureSystem
+{
+public:
+    virtual boolean Verify(const byte *message, unsigned int messageLen, const byte *signature) =0;
+};
+class ByteQueueNode;
+class ByteQueue : public BufferedTransformation
+{
+public:
+    ByteQueue();
+    ~ByteQueue();
+    unsigned long CurrentSize() const;
+    unsigned long MaxRetrieveable()
+        {return CurrentSize();}
+    void Put(byte inByte);
+    void Put(const byte *inString, unsigned int length);
+    int Get(byte &outByte);
+    unsigned int Get(byte *outString, unsigned int getMax);
+private:
+    ByteQueueNode *head, *tail;
+};
+enum ASNTag {INTEGER=0x02, BIT_STRING=0x03, SEQUENCE=0x10};
+enum ASNIdFlag {CONSTRUCTED = 0x20};
+unsigned int DERLengthEncode(unsigned int length, byte *output);
+unsigned int DERLengthEncode(unsigned int length, BufferedTransformation &);
+class BERDecodeErr {};
+boolean BERLengthDecode(BufferedTransformation &, unsigned int &);
+class BERSequenceDecoder : public BufferedTransformation
+{
+public:
+    BERSequenceDecoder(BufferedTransformation &inQueue);
+    ~BERSequenceDecoder();
+    void Put(byte inByte) {}
+    void Put(const byte *, unsigned int) {}
+    unsigned long MaxRetrieveable()
+        {return inQueue.MaxRetrieveable();}
+    int Get(byte &outByte)
+        {return inQueue.Get(outByte);}
+    unsigned int Get(byte *outString, unsigned int getMax)
+        {return inQueue.Get(outString, getMax);}
+private:
+    BufferedTransformation &inQueue;
+    boolean definiteLength;
+    unsigned int length;
+};
+class DERSequenceEncoder : public ByteQueue
+{
+public:
+    DERSequenceEncoder(BufferedTransformation &outQueue);
+    ~DERSequenceEncoder();
+private:
+    BufferedTransformation &outQueue;
+};
+extern "C" {
+}
+extern "C" {
+extern void *memmove(void *, const void *, size_t);
+extern char *strcpy(char *, const char *);
+extern char *strncpy(char *, const char *, size_t);
+extern char *strcat(char *, const char *);
+extern char *strncat(char *, const char *, size_t);
+extern int strcmp(const char *, const char *);
+extern int strcoll(const char *, const char *);
+extern int strncmp(const char *, const char *, size_t);
+extern size_t strxfrm(char *, const char *, size_t);
+extern void * __hide_memchr (const void *, int, size_t);
+extern char * __hide_strchr (const char *, int);
+extern size_t strcspn(const char *, const char *);
+extern char * __hide_strpbrk (const char *, const char *);
+extern char * __hide_strrchr (const char *, int);
+extern size_t strspn(const char *, const char *);
+extern char * __hide_strstr (const char *, const char *);
+extern char *strtok(char *, const char *);
+extern void *memset(void *, int, size_t);
+extern char *strerror(int);
+extern void *memccpy(void *, const void *, int, size_t);
+extern char *strdup(const char *);
+extern char *strsignal(int);
+extern int ffs(const int);
+extern int strcasecmp(const char *, const char *);
+extern int strncasecmp(const char *, const char *, size_t);
+}
+typedef int ptrdiff_t;
+extern "C" const char *strchr (const char *, int);
+inline char *
+strchr (char *s, int c)
+{
+  return (char*) strchr ((const char *) s, c);
+}
+extern "C" const char *strpbrk (const char *, const char *);
+inline char *
+strpbrk (char *s1, const char *s2)
+{
+  return (char *) strpbrk ((const char *) s1, s2);
+}
+extern "C" const char *strrchr (const char *, int);
+inline char *
+strrchr (char *s, int c)
+{
+  return (char *) strrchr ((const char *) s, c);
+}
+extern "C" const char *strstr (const char *, const char *);
+inline char *
+strstr (char *s1, const char *s2)
+{
+  return (char *) strstr ((const char *) s1, s2);
+}
+extern "C" void *memchr (const void *, int, size_t);
+inline void *
+memchr (void *s, int c, size_t n)
+{
+  return (void *) memchr ((const void *) s, c, n);
+}
+typedef word16 unit;
+typedef short signedunit;
+typedef unit *unitptr;
+extern short global_precision;
+boolean mp_addc
+        (register unitptr r1,const unit * r2,register boolean carry);
+boolean mp_subb
+        (register unitptr r1,const unit * r2,register boolean borrow);
+boolean mp_rotate_left(register unitptr r1,register boolean carry);
+void mp_shift_right_bits(register unitptr r1,register short bits);
+short mp_compare(const unit * r1,const unit * r2);
+boolean mp_inc(register unitptr r);
+boolean mp_dec(register unitptr r);
+void mp_neg(register unitptr r);
+void mp_init(register unitptr r, word16 value);
+short significance(const unit * r);
+int mp_udiv(register unitptr remainder,register unitptr quotient,
+        const unit * dividend,const unit * divisor);
+int mp_recip(register unitptr quotient,const unit * divisor);
+int mp_div(register unitptr remainder,register unitptr quotient,
+        unit * dividend, unit * divisor);
+word16 mp_shortdiv(register unitptr quotient,
+        const unit * dividend,register word16 divisor);
+int mp_mod(register unitptr remainder,
+        const unit * dividend,const unit * divisor);
+word16 mp_shortmod(register unitptr dividend,register word16 divisor);
+int mp_mult(register unitptr prod,
+        const unit * multiplicand,const unit * multiplier);
+int countbits(const unit * r);
+int stage_peasant_modulus(const unit * n);
+int stage_merritt_modulus(const unit * n);
+int stage_upton_modulus(const unit * n);
+int stage_smith_modulus(const unit * n);
+int peasant_modmult(register unitptr prod,
+        const unit * multiplicand,const unit * multiplier);
+int merritt_modmult(register unitptr prod,
+        const unit * multiplicand,const unit * multiplier);
+int upton_modmult(register unitptr prod,
+        const unit * multiplicand,const unit * multiplier);
+int smith_modmult(register unitptr prod,
+        const unit * multiplicand,const unit * multiplier);
+void peasant_burn();
+void merritt_burn();
+void upton_burn();
+void smith_burn();
+int mp_modexp(register unitptr expout,const unit * expin,
+        const unit * exponent,const unit * modulus);
+int mp_modexp_crt(unitptr expout, const unit * expin,
+        const unit * p, const unit * q, const unit * ep, const unit * eq, const unit * u);
+word16 fetch_word16(byte *buf);
+byte *put_word16(word16 w, byte *buf);
+word32 fetch_word32(byte *buf);
+byte *put_word32(word32 w, byte *buf);
+int string_length(const char *s);
+int str2reg(unit * reg,const char* digitstr);
+int reg2str(char * s,const unit * n,short radix);
+void mp_display(char * s,unitptr r);
+word16 checksum(register byte * buf, register word16 count);
+void cbc_xor(register unitptr dst, register unitptr src, word16 bytecount);
+void hiloswap(byte * r1,short numbytes);
+short mpi2reg(register unitptr r, register byte * buf);
+short reg2mpi(register byte * buf, register unitptr r);
+enum RandomNumberType {ANY, ODD, PRIME, BLUMINT};
+class MPIRegister : public SecBlock<unit>
+{
+public:
+    MPIRegister() : SecBlock<unit>((2048 / 16 ) ) {}
+};
+class ostream;
+class bignum
+{
+public:
+    bignum()
+        {}
+    bignum(unsigned long value);
+    bignum(const char *str)
+        {str2reg(reg, str);}
+    enum Signedness{UNSIGNED, SIGNED};
+    bignum(const byte *encodedBignum, unsigned int byteCount, Signedness s=UNSIGNED)
+        {Decode(encodedBignum, byteCount, s);}
+    bignum(const byte *BEREncodedInteger)
+        {BERDecode(BEREncodedInteger);}
+    bignum(BufferedTransformation &bt)
+        {BERDecode(bt);}
+    bignum(RandomNumberGenerator &rng, unsigned int bitcount)
+        {Randomize(rng, bitcount);}
+    bignum(RandomNumberGenerator &rng, const bignum &min, const bignum &max, RandomNumberType rnType=ANY)
+        {Randomize(rng, min, max, rnType);}
+    bignum(const bignum& t)
+        {memcpy(reg, t.reg, (2048 /8) );}
+    unsigned int Encode(byte *output) const;
+    unsigned int Encode(byte *output, unsigned int outputLen) const;
+    void Decode(const byte *input, unsigned int inputLen, Signedness=UNSIGNED);
+    unsigned int DEREncode(byte *output) const;
+    unsigned int DEREncode(BufferedTransformation &bt) const;
+    void BERDecode(const byte *input);
+    void BERDecode(BufferedTransformation &bt);
+    void Randomize(RandomNumberGenerator &rng, unsigned int bitcount);
+    void Randomize(RandomNumberGenerator &rng, const bignum &min, const bignum &max);
+    void Randomize(RandomNumberGenerator &rng, const bignum &min, const bignum &max, RandomNumberType rnType);
+    unsigned int ByteCount() const
+    {
+        return ((countbits( reg )+7)>>3) ;
+    }
+    int BitCount() const
+    {
+        return countbits(reg);
+    }
+    bignum&  operator++()
+    {
+        mp_inc(reg);
+        return *this;
+    }
+    bignum&  operator--()
+    {
+        mp_dec(reg);
+        return *this;
+    }
+    int      operator!() const
+    {
+        return ( ((* ((   reg.ptr   )+( global_precision )-1) ) ==(  0 )) && (significance( reg.ptr )<=1) ) ;
+    }
+    bignum&  operator=(const bignum& t)
+    {
+        memcpy(reg, t.reg, (2048 /8) );
+        return *this;
+    }
+    bignum&  operator+=(const bignum& t)
+    {
+        mp_addc( reg ,  t.reg ,(boolean)0) ;
+        return *this;
+    }
+    bignum&  operator-=(const bignum& t)
+    {
+        mp_subb( reg ,  t.reg ,(boolean)0) ;
+        return *this;
+    }
+    bignum&  operator*=(const bignum& t)
+    {
+        *this = (*this) * t;
+        return *this;
+    }
+    bignum&  operator/=(const bignum& t)
+    {
+        *this = (*this) / t;
+        return *this;
+    }
+    bignum&  operator%=(const bignum& t)
+    {
+        *this = (*this) % t;
+        return *this;
+    }
+    bignum&  operator<<=(unsigned int);
+    bignum&  operator>>=(unsigned int);
+    unsigned MaxBitPrecision() const {return 2048 ;}
+    int operator[](unsigned int n) const;
+    friend bignum operator+(bignum a, const bignum &b)
+    {
+        return (a+=b);
+    }
+    friend bignum operator-(bignum a, const bignum &b)
+    {
+        return (a-=b);
+    }
+    friend bignum operator*(const bignum &a, const bignum &b);
+    friend bignum operator/(const bignum &a, const bignum &b);
+    friend bignum operator%(const bignum &a, const bignum &b);
+    friend bignum operator/(const bignum &a, word16 b);
+    friend word16 operator%(const bignum &a, word16 b);
+    friend bignum operator>>(bignum a, unsigned int n)
+        {return (a>>=n);}
+    friend bignum operator<<(bignum a, unsigned int n)
+        {return (a<<=n);}
+    void Negate() {mp_neg(reg);}
+    friend bignum operator-(bignum a)
+    {
+        a.Negate();
+        return a;
+    }
+    friend int    operator==(const bignum &a, const bignum &b)
+    {
+        return (memcmp(a.reg.ptr, b.reg.ptr, (2048 /8) )==0);
+    }
+    friend int    operator!=(const bignum& a, const bignum& b)
+    {
+        return (memcmp(a.reg.ptr, b.reg.ptr, (2048 /8) )!=0);
+    }
+    friend int    operator>(const bignum& a, const bignum& b)
+    {
+        return (mp_compare(a.reg, b.reg)>0);
+    }
+    friend int    operator>=(const bignum& a, const bignum& b)
+    {
+        return (mp_compare(a.reg, b.reg)>=0);
+    }
+    friend int    operator<(const bignum& a, const bignum& b)
+    {
+        return (mp_compare(a.reg, b.reg)<0);
+    }
+    friend int    operator<=(const bignum& a, const bignum& b)
+    {
+        return (mp_compare(a.reg, b.reg)<=0);
+    }
+    friend bignum a_times_b_mod_c(const bignum &x, const bignum& y, const bignum& m);
+    friend bignum a_exp_b_mod_c(const bignum &x, const bignum& e, const bignum& m);
+    class DivideErr {};
+    friend void Divide(bignum &r, bignum &q,
+                       const bignum &a, const bignum &d,
+                       Signedness s=SIGNED);
+    friend boolean Negative(const bignum &a)
+    {
+        return ((signedunit) (* (   a.reg.ptr   ) )  < 0) ;
+    }
+    friend bignum Abs(bignum a)
+    {
+        (((signedunit) (* (    a.reg.ptr    ) )  < 0)  ? (mp_neg( a.reg.ptr ),TRUE) : FALSE) ;
+        return a;
+    }
+    friend ostream& operator<<(ostream& out, const bignum &a);
+    unit lsUnit()   {return (* ((  reg.ptr  )+( global_precision )-1) ) ;}
+private:
+    MPIRegister reg;
+};
+class RSAPublicKey : public PK_Encryptor, public PK_Decryptor,
+                     public PK_Verifier
+{
+public:
+    RSAPublicKey(const bignum &n, const bignum &e);
+    RSAPublicKey(BufferedTransformation &bt);
+    void DEREncode(BufferedTransformation &bt) const;
+    void Encrypt(RandomNumberGenerator &rng, const byte *plainText, unsigned int plainTextLength, byte *cipherText);
+    unsigned int Decrypt(const byte *cipherText, byte *plainText);
+    boolean Verify(const byte *message, unsigned int messageLen, const byte *signature);
+    unsigned int MaxPlainTextLength() const {return modulusLen-11;}
+    unsigned int CipherTextLength() const {return modulusLen;}
+    unsigned int MaxMessageLength() const {return modulusLen-11;}
+    unsigned int SignatureLength() const {return modulusLen;}
+    const bignum& Exponent() const {return e;}
+    const bignum& Modulus() const {return n;}
+protected:
+    void RawEncrypt(const bignum &in, bignum &out) const;
+private:
+    friend class RSAPrivateKey;
+    RSAPublicKey() {}
+    bignum n;            
+    bignum e;
+    unsigned int modulusLen;
+};
+class RSAPrivateKey : public RSAPublicKey, public PK_Signer
+{
+public:
+    RSAPrivateKey(const bignum &n, const bignum &e, const bignum &d,
+                  const bignum &p, const bignum &q, const bignum &dp, const bignum &dq, const bignum &u);
+    RSAPrivateKey(RandomNumberGenerator &rng, int keybits, bignum eStart=17);
+    RSAPrivateKey(BufferedTransformation &bt);
+    void DEREncode(BufferedTransformation &bt) const;
+    void Encrypt(const byte *plainText, unsigned int plainTextLength, byte *cipherText);
+    unsigned int Decrypt(const byte *cipherText, byte *plainText);
+    void Encrypt(RandomNumberGenerator &, const byte *plainText, unsigned int plainTextLength, byte *cipherText)
+        {Encrypt(plainText, plainTextLength, cipherText);}
+    void Sign(const byte *message, unsigned int messageLen, byte *signature)
+        {Encrypt(message, messageLen, signature);}
+    void Sign(RandomNumberGenerator &, const byte *message, unsigned int messageLen, byte *signature)
+        {Encrypt(message, messageLen, signature);}
+    unsigned int MaxMessageLength() const {return modulusLen-11;}
+    unsigned int SignatureLength() const {return modulusLen;}
+protected:
+    void RawEncrypt(const bignum &in, bignum &out) const;
+private:
+    bignum d;    
+    bignum p;    
+    bignum q;
+    bignum dp;
+    bignum dq;
+    bignum u;
+};
+bignum Gcd(const bignum &a, const bignum &b);
+bignum Inverse(const bignum &a, const bignum &m);
+boolean IsSmallPrime(const bignum &p);
+boolean SmallDivisorsTest(const bignum &p);
+boolean FermatTest(const bignum &p, unsigned int rounds);
+boolean RabinMillerTest(RandomNumberGenerator &rng, const bignum &w, unsigned int rounds);
+inline boolean IsPrime(const bignum &p)
+{
+    return (IsSmallPrime(p) || (SmallDivisorsTest(p) && FermatTest(p, 2)));
+}
+boolean NextPrime(bignum &p, const bignum &max, boolean blumInt=FALSE);
+bignum a_exp_b_mod_pq(const bignum &a, const bignum &ep, const bignum &eq,
+                      const bignum &p, const bignum &q, const bignum &u);
+class PrimeAndGenerator
+{
+public:
+    PrimeAndGenerator(RandomNumberGenerator &rng, unsigned int pbits);
+    PrimeAndGenerator(RandomNumberGenerator &rng, unsigned int pbits, unsigned qbits);
+    const bignum& Prime() const {return p;}
+    const bignum& SubPrime() const {return q;}
+    const bignum& Generator() const {return g;}
+private:
+    bignum p, q, g;
+};
+extern "C" {
+extern void __eprintf (const char *, const char *, unsigned, const char *);
+}
+RSAPublicKey::RSAPublicKey(const bignum &n, const bignum &e)
+    : n(n), e(e), modulusLen(n.ByteCount())
+{
+}
+RSAPublicKey::RSAPublicKey(BufferedTransformation &bt)
+{
+    BERSequenceDecoder seq(bt);
+    n.BERDecode(seq);
+    modulusLen = n.ByteCount();
+    e.BERDecode(seq);
+}
+void RSAPublicKey::DEREncode(BufferedTransformation &bt) const
+{
+    DERSequenceEncoder seq(bt);
+    n.DEREncode(seq);
+    e.DEREncode(seq);
+}
+void RSAPublicKey::Encrypt(RandomNumberGenerator &rng, const byte *input, unsigned int inputLen, byte *output)
+{unsigned int i;
+    ((void) (( inputLen <= MaxPlainTextLength() ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",     "rsa.cpp" ,   30 ,  "inputLen <= MaxPlainTextLength()" ), 0) )) ;
+    SecByteBlock pkcsBlock(modulusLen);
+    pkcsBlock[0] = 0;
+    pkcsBlock[1] = 2;   
+    for (i = 2; i < modulusLen - inputLen - 1; i++)
+    {
+        do
+            pkcsBlock[i] = rng.GetByte();
+        while (pkcsBlock[i] == 0);
+    }
+    pkcsBlock[i++] = 0;      
+    memcpy(pkcsBlock+i, input, inputLen);
+    bignum c;
+    RawEncrypt(bignum(pkcsBlock, modulusLen), c);
+    c.Encode(output, modulusLen);
+}
+unsigned int RSAPublicKey::Decrypt(const byte *input, byte *output)
+{unsigned int i;
+    bignum m;
+    RawEncrypt(bignum(input, modulusLen), m);
+    SecByteBlock pkcsBlock(modulusLen);
+    m.Encode(pkcsBlock, modulusLen);
+    if ((pkcsBlock[0] != 0) || (pkcsBlock[1] != 1))
+        return 0;
+    for (i = 2; i < modulusLen-1; i++)
+        if (pkcsBlock[i] != 0xff)
+            break;
+    if (pkcsBlock[i++] != 0)
+        return 0;
+    unsigned int outputLen = modulusLen - i;
+    if (outputLen > MaxPlainTextLength())
+        return 0;
+    memcpy (output, pkcsBlock+i, outputLen);
+    return outputLen;
+}
+boolean RSAPublicKey::Verify(const byte *message, unsigned int messageLen, const byte *signature)
+{
+    ((void) (( messageLen <= MaxMessageLength() ) ? 0 : (__eprintf ("%s:%u: failed assertion `%s'\n",     "rsa.cpp" ,   83 ,  "messageLen <= MaxMessageLength()" ), 0) )) ;
+    SecByteBlock m(MaxMessageLength());
+    unsigned int mLen = RSAPublicKey::Decrypt(signature, m);
+    return (mLen==messageLen && memcmp(message, m, mLen)==0);
+}
+void RSAPublicKey::RawEncrypt(const bignum &in, bignum &out) const
+{
+    out = a_exp_b_mod_c(in, e, n);
+}
+RSAPrivateKey::RSAPrivateKey(const bignum &nIn, const bignum &eIn, const bignum &dIn,
+                             const bignum &pIn, const bignum &qIn,
+                             const bignum &dpIn, const bignum &dqIn, const bignum &uIn)
+    : RSAPublicKey(nIn, eIn)
+{
+    d=dIn;
+    if (pIn < qIn)
+    {
+        p=pIn;
+        q=qIn;
+        dp=dpIn;
+        dq=dqIn;
+    }
+    else
+    {
+        p=qIn;
+        q=pIn;
+        dp=dqIn;
+        dq=dpIn;
+    }
+    u=uIn;
+}
+RSAPrivateKey::RSAPrivateKey(RandomNumberGenerator &rng, int keybits, bignum eStart)
+{
+    p = bignum(rng, keybits/2, PRIME);
+    const bignum minQ = ((bignum(1) << (keybits-1)) / p) + 1;
+    const bignum maxQ = (bignum(1) << keybits) / p;
+    do
+    {
+        bignum temp(rng, minQ, maxQ, PRIME);
+        if (p>temp && p.BitCount()-(p-temp).BitCount() < 7)
+        {
+            q=p;
+            p=temp;
+            break;
+        }
+        if (p<temp && temp.BitCount()-(temp-p).BitCount() < 7)
+        {
+            q=temp;
+            break;
+        }
+    } while (1);
+    bignum phi = (p-1)*(q-1);
+    for (e = eStart; Gcd(e, phi)!=1; ++e, ++e);
+    d = Inverse(e, phi/Gcd(p-1, q-1));
+    dp = d % (p-1);
+    dq = d % (q-1);
+    u = Inverse(p, q);
+    n = p * q;
+    modulusLen = n.ByteCount();
+}
+RSAPrivateKey::RSAPrivateKey(BufferedTransformation &bt)
+{
+    BERSequenceDecoder seq(bt);
+    bignum version(seq);
+    if (!!version)   
+        throw BERDecodeErr() ;
+    n.BERDecode(seq);
+    modulusLen = n.ByteCount();
+    e.BERDecode(seq);
+    d.BERDecode(seq);
+    p.BERDecode(seq);
+    q.BERDecode(seq);
+    dp.BERDecode(seq);
+    dq.BERDecode(seq);
+    u.BERDecode(seq);
+    if (p>q)     
+    {
+        swap(p, q);
+        swap(dp, dq);
+    }
+}
+void RSAPrivateKey::DEREncode(BufferedTransformation &bt) const
+{
+    DERSequenceEncoder seq(bt);
+    byte version[] = {INTEGER, 1, 0};
+    seq.Put(version, sizeof(version));
+    n.DEREncode(seq);
+    e.DEREncode(seq);
+    d.DEREncode(seq);
+    q.DEREncode(seq);     
+    p.DEREncode(seq);
+    dq.DEREncode(seq);
+    dp.DEREncode(seq);
+    u.DEREncode(seq);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh44.C b/gcc/testsuite/g++.old-deja/g++.mike/eh44.C
new file mode 100644
index 00000000000..e612aeb793b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh44.C
@@ -0,0 +1,36 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+// prms-id: 9159
+
+static unsigned int iCounter = 0;
+static unsigned int iMax;
+int fail = 0;
+
+class ca {
+public:
+  ca(int) {
+    if (iCounter++ == iMax)
+      throw (const char*)"iCounter";
+  }
+  virtual ~ca() {
+  }
+};
+
+class cc {
+public:
+  cc(const ca &rca1, const ca &rca2) {
+  }
+  virtual ~cc() {
+    fail = 1;
+  }
+};
+
+
+int main(int argc, char **argv) {
+  iMax = 1;
+  try {
+    cc sc(ca(1), ca(1));
+  } catch (const char *pMsg) {
+  }
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh45.C b/gcc/testsuite/g++.old-deja/g++.mike/eh45.C
new file mode 100644
index 00000000000..bed0b921d6b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh45.C
@@ -0,0 +1,34 @@
+int i;
+int fail;
+
+class ca {
+public:
+  ca() {
+    if (++i != 1)
+      fail = 1;
+  }
+  virtual ~ca() {
+    if (++i != 4)
+      fail = 4;
+  }
+};
+
+class cb {
+public:
+  cb(const ca &rca) {
+    if (++i != 2)
+      fail = 2;
+  }
+  virtual ~cb() {
+    if (++i != 3)
+      fail = 3;
+  }
+};
+
+void foo(const cb &rcb) {
+}
+
+int main(int argc, char **argv) {
+  foo(cb(ca()));
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh46.C b/gcc/testsuite/g++.old-deja/g++.mike/eh46.C
new file mode 100644
index 00000000000..e0e6553f7c7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh46.C
@@ -0,0 +1,47 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sh-*-* arm-*-pe**-*
+
+int atoi(const char *);
+
+struct ios {
+ virtual ~ios();
+};
+ 
+class fstreambase : virtual public ios {
+};
+
+class ifstream : public fstreambase {
+};
+
+class ofstream : public fstreambase {
+};
+
+extern const short O;
+extern const short D;
+
+const short O=  0;
+const short D= -3;
+
+
+short glc(const char* const * const l,
+	  short& n,short& x,short& y,
+	  ifstream* i,ofstream* o)
+
+{
+  n=atoi(l[1]);
+
+  x=atoi(l[2]);
+  y=atoi(l[3]);
+
+  if((x < 0)||(y <0))
+    {
+     return D;
+    }
+
+  i = new ifstream[n];
+  o = new ofstream[2];
+
+  return O;
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh47.C b/gcc/testsuite/g++.old-deja/g++.mike/eh47.C
new file mode 100644
index 00000000000..ae918c35543
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh47.C
@@ -0,0 +1,22 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <cstdlib>
+
+void myterm() {
+  exit (0);
+}
+
+main() {
+  try {
+    throw "";
+  } catch (...) {
+  }
+  try {
+    set_terminate (myterm);
+    throw;
+  } catch (...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh48.C b/gcc/testsuite/g++.old-deja/g++.mike/eh48.C
new file mode 100644
index 00000000000..5cefacd5f1e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh48.C
@@ -0,0 +1,32 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+#include <exception>
+
+class A {
+public:
+  ~A() {
+    if (uncaught_exception ())
+      exit (0);
+  }
+};
+
+int main() {
+  if (uncaught_exception ())
+    return 1;
+  try {
+    throw "";
+  } catch (...) {
+    if (uncaught_exception ())
+      return 1;
+  }
+  if (uncaught_exception ())
+    return 1;
+  try {
+    A a;
+    throw "";
+  } catch (...) {
+    return 1;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh49.C b/gcc/testsuite/g++.old-deja/g++.mike/eh49.C
new file mode 100644
index 00000000000..3a301cc54ee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh49.C
@@ -0,0 +1,15 @@
+// Special g++ Options: -fexceptions -O9
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+main1() {
+  throw 1;
+}
+
+main() {
+  try {
+    main1();
+  } catch (...) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh5.C b/gcc/testsuite/g++.old-deja/g++.mike/eh5.C
new file mode 100644
index 00000000000..6bc1dc045fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh5.C
@@ -0,0 +1,21 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class foo {
+public:
+  class error {};
+
+  void cause_error(void) { throw "Hello World!"; }
+};
+
+int main(void)
+{
+  foo f;
+  try {
+    f.cause_error();
+  }
+  catch (char cp[]) {
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh50.C b/gcc/testsuite/g++.old-deja/g++.mike/eh50.C
new file mode 100644
index 00000000000..746aaa67b4c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh50.C
@@ -0,0 +1,19 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL hppa*-*-* a29k-*-* sparc64-*-elf sh-*-* z8k-*-* arm-*-pe**-*
+
+void my_unexpected() {
+  throw 42;
+}
+
+template <class T> int foo(T) throw (int) { throw "Hi"; }
+
+main() {
+  set_unexpected (my_unexpected);
+  try {
+    foo(1);
+  } catch (int i) {
+    if (i == 42)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh51.C b/gcc/testsuite/g++.old-deja/g++.mike/eh51.C
new file mode 100644
index 00000000000..55ca0c53f58
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh51.C
@@ -0,0 +1,19 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL hppa*-*-* a29k-*-* sparc64-*-elf sh-*-* z8k-*-* arm-*-pe**-*
+
+void my_unexpected() {
+  throw 42;
+}
+
+template <class T> int foo(T) throw (T) { throw "Hi"; }
+
+main() {
+  set_unexpected (my_unexpected);
+  try {
+    foo(1);
+  } catch (int i) {
+    if (i == 42)
+      return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh52.C b/gcc/testsuite/g++.old-deja/g++.mike/eh52.C
new file mode 100644
index 00000000000..475070caebf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh52.C
@@ -0,0 +1,14 @@
+// Special g++ Options: -fexceptions -O9
+
+int promote_mode (int mode, int *punsignedp)
+{
+  int unsignedp = *punsignedp;
+  *punsignedp = unsignedp;
+  return mode;
+}
+
+int main() {
+  int i;
+  i = promote_mode (42, &i);
+  return i != 42;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh53.C b/gcc/testsuite/g++.old-deja/g++.mike/eh53.C
new file mode 100644
index 00000000000..7d47c6d1461
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh53.C
@@ -0,0 +1,15 @@
+// Special g++ Options: -fexceptions -g
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+class zeroset {
+public:
+  ~zeroset () { }
+};
+
+int main () {
+  zeroset a;
+  try {
+    ;
+  } catch( zeroset ) {
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh54.C b/gcc/testsuite/g++.old-deja/g++.mike/eh54.C
new file mode 100644
index 00000000000..9c2d206f092
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh54.C
@@ -0,0 +1,3 @@
+// Special g++ Options: -fexceptions
+
+int main() { try { 1; } }	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh55.C b/gcc/testsuite/g++.old-deja/g++.mike/eh55.C
new file mode 100644
index 00000000000..dbb56d58c3d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh55.C
@@ -0,0 +1,16 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+void my_terminate_handler() {
+  exit(0);
+}
+
+void throw_an_unexpected_exception() throw() {
+  throw 1;
+}
+
+int main() {
+  set_terminate(my_terminate_handler);
+  throw_an_unexpected_exception();
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh56.C b/gcc/testsuite/g++.old-deja/g++.mike/eh56.C
new file mode 100644
index 00000000000..674a82df450
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh56.C
@@ -0,0 +1,22 @@
+// Special g++ Options: -fexceptions
+
+struct A {
+  A() { }
+  A(const char *) { }
+  A(const A&) { }
+  ~A() { }
+};
+
+struct bmf {
+  bmf (const A n) { }
+  ~bmf (void) { }
+  A name;
+};
+
+void imf (void) {
+  bmf Sabs ("abs");
+}
+
+int main(void) {
+  imf ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh57.C b/gcc/testsuite/g++.old-deja/g++.mike/eh57.C
new file mode 100644
index 00000000000..545a85fdfa9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh57.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// Special g++ Options: -fno-exceptions
+
+class Calendar_Time {
+public:
+  ~Calendar_Time ();
+  int operator <= (const Calendar_Time& t) const;
+};
+
+class Temporal_Model_Interval {
+public:
+  Calendar_Time start_time ();
+};
+
+int intersects_p (Temporal_Model_Interval* i1, Temporal_Model_Interval* i2) {
+  return ((i1->start_time() <= i2->start_time())
+	  || (i1->start_time() <= i2->start_time()));
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh58.C b/gcc/testsuite/g++.old-deja/g++.mike/eh58.C
new file mode 100644
index 00000000000..967e74ab12d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh58.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+
+struct C {
+    bool mem;
+    ~C();
+};
+
+C genTemp();
+  
+int foo_notok(int arg) {
+    switch (arg) {
+    case 0:
+        return genTemp().mem;
+    default:
+        return 3;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh6.C b/gcc/testsuite/g++.old-deja/g++.mike/eh6.C
new file mode 100644
index 00000000000..f5409867a23
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh6.C
@@ -0,0 +1,19 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+extern "C" int printf(const char *, ...);
+
+main1() {
+  throw 1;
+}
+
+
+main() {
+  try {
+    main1();
+  } catch (...) {
+    printf("Unwind works!\n");
+    return 0;
+  }
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh7.C b/gcc/testsuite/g++.old-deja/g++.mike/eh7.C
new file mode 100644
index 00000000000..3e2c75a67f2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh7.C
@@ -0,0 +1,7 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+main() {
+  if (0)
+    throw 1 | 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh8.C b/gcc/testsuite/g++.old-deja/g++.mike/eh8.C
new file mode 100644
index 00000000000..a9f7a902f2c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh8.C
@@ -0,0 +1,20 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+
+extern "C" int printf(const char *, ...);
+
+int i;
+
+main() {
+  try {
+    try {
+      throw i;
+    } catch (char *) {
+      return 1;
+    }
+    return 1;
+  } catch (int i) {
+    return 0;
+  }    
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/eh9.C b/gcc/testsuite/g++.old-deja/g++.mike/eh9.C
new file mode 100644
index 00000000000..febd1dc4b96
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/eh9.C
@@ -0,0 +1,4 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe*
+
+main() throw () { }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/enum1.C b/gcc/testsuite/g++.old-deja/g++.mike/enum1.C
new file mode 100644
index 00000000000..89e8542b779
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/enum1.C
@@ -0,0 +1,11 @@
+// Build don't link:
+// Warn if a enum cannot fit into a small bit-field.
+
+enum TypeKind { ATK, BTK, CTK, DTK } ;
+
+struct Type {
+  enum TypeKind kind : 1;		// WARNING - 
+  void setBTK();
+};
+
+void Type::setBTK() { kind = DTK; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/err1.C b/gcc/testsuite/g++.old-deja/g++.mike/err1.C
new file mode 100644
index 00000000000..8748c7860b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/err1.C
@@ -0,0 +1,8 @@
+// Build don't link:
+
+struct gorf {
+  int stuff;
+  void snarf();
+};
+
+template <class T> void gorf::snarf() { return; }  // ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/err2.C b/gcc/testsuite/g++.old-deja/g++.mike/err2.C
new file mode 100644
index 00000000000..e7f0be2a987
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/err2.C
@@ -0,0 +1,6 @@
+class foo {
+public:
+  apply(foo *(foo::*memptr)()) {
+    this->*memptr();		// ERROR - wrong
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/err3.C b/gcc/testsuite/g++.old-deja/g++.mike/err3.C
new file mode 100644
index 00000000000..b42a4a908d8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/err3.C
@@ -0,0 +1,9 @@
+class cb {
+};
+
+class cc {
+public:
+  cc()
+    : cb() {		// ERROR - 
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/explicit1.C b/gcc/testsuite/g++.old-deja/g++.mike/explicit1.C
new file mode 100644
index 00000000000..28213ba377d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/explicit1.C
@@ -0,0 +1,15 @@
+struct A1 {
+  explicit A1(int) { }
+} a1(1);
+
+struct A {
+  explicit A(int);
+} a(1);
+
+A::A(int) {
+}
+
+void foo(A a) {
+  foo(a);
+  foo(1);		// ERROR - not allowed
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/explicit2.C b/gcc/testsuite/g++.old-deja/g++.mike/explicit2.C
new file mode 100644
index 00000000000..a2077bffc2f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/explicit2.C
@@ -0,0 +1,24 @@
+// Build don't link:
+
+class string {
+public:
+  string(const char*) { } 
+  explicit string(int size) { }
+}; 
+
+void foo(string) { }
+
+string bar() {
+  foo("hello");		// ok
+  foo(string(2));	// ok
+  foo(2);		// ERROR - no implicit conversion from int to string
+  string x = 2;		// ERROR - no implicit conversion from int to string
+  string y(2);		// ok
+  foo((string)2);	// ok
+  return 2;		// ERROR - no implicit conversion from int to string
+}
+
+class A : string {
+public:
+  A() : string(2) { }	// ok
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/for1.C b/gcc/testsuite/g++.old-deja/g++.mike/for1.C
new file mode 100644
index 00000000000..e46213035bf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/for1.C
@@ -0,0 +1,3 @@
+int main() {
+  for( {int i = 0; int j = 0;} i < 10; ++i ) ;		// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/for2.C b/gcc/testsuite/g++.old-deja/g++.mike/for2.C
new file mode 100644
index 00000000000..fd01804d86b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/for2.C
@@ -0,0 +1,19 @@
+// Build don't link:
+
+void foo() {
+  for (class C {};;)
+    ;
+  C c;		// ERROR - 
+}
+
+void bar() {
+  for (enum E {num};;)
+    ;
+  E e;		// ERROR - 
+}
+
+void bee () {
+  int i = 0;
+  for (int fun() = 0; i != 2; ++i) {	// ERROR - 
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/fresco1.C b/gcc/testsuite/g++.old-deja/g++.mike/fresco1.C
new file mode 100644
index 00000000000..16fa1dbcbe9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/fresco1.C
@@ -0,0 +1,13 @@
+// Build don't link:
+
+// This is a Fresco found bug.
+
+class WhoCares {};
+
+typedef float Coord;
+
+class BugDemo : public WhoCares {
+public:
+  typedef Coord Matrix[4][4];
+  virtual void vf1(BugDemo::Matrix m) = 0;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/hog1.C b/gcc/testsuite/g++.old-deja/g++.mike/hog1.C
new file mode 100644
index 00000000000..8627100f2de
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/hog1.C
@@ -0,0 +1,187 @@
+class dummy                             { public: void operator++(void) {}
+                     };
+class dummy_000 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_001 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_002 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_003 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_004 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_005 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_006 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_007 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_008 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_009 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_010 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_011 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_012 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_013 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_014 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_015 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_016 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_017 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_018 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_019 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_020 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_021 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_022 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_023 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_024 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_025 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_026 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_027 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_028 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_029 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_030 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_031 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_032 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_033 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_034 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_035 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_036 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_037 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_038 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_039 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_040 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_041 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_042 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_043 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_044 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_045 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_046 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_047 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_048 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+class dummy_049 : private virtual dummy { public: void operator++(void) {
+dummy::operator++(); } };
+
+class super :
+  private dummy_000, private dummy_001, private dummy_002, private
+dummy_003, private dummy_004,
+  private dummy_005, private dummy_006, private dummy_007, private
+dummy_008, private dummy_009,
+  private dummy_010, private dummy_011, private dummy_012, private
+dummy_013, private dummy_014,
+  private dummy_015, private dummy_016, private dummy_017, private
+dummy_018, private dummy_019,
+  private dummy_020, private dummy_021, private dummy_022, private
+dummy_023, private dummy_024,
+  private dummy_025, private dummy_026, private dummy_027, private
+dummy_028, private dummy_029,
+  private dummy_030, private dummy_031, private dummy_032, private
+dummy_033, private dummy_034,
+  private dummy_035, private dummy_036, private dummy_037, private
+dummy_038, private dummy_039,
+  private dummy_040, private dummy_041, private dummy_042, private
+dummy_043, private dummy_044,
+  private dummy_045, private dummy_046, private dummy_047, private
+dummy_048, private dummy_049
+{
+public:
+  void operator++(void);
+};
+
+void super::operator++(void)
+{
+  dummy_000::operator++();
+  dummy_001::operator++();
+  dummy_002::operator++();
+  dummy_003::operator++();
+  dummy_004::operator++();
+  dummy_005::operator++();
+  dummy_006::operator++();
+  dummy_007::operator++();
+  dummy_008::operator++();
+  dummy_009::operator++();
+  dummy_010::operator++();
+  dummy_011::operator++();
+  dummy_012::operator++();
+  dummy_013::operator++();
+  dummy_014::operator++();
+  dummy_015::operator++();
+  dummy_016::operator++();
+  dummy_017::operator++();
+  dummy_018::operator++();
+  dummy_019::operator++();
+  dummy_020::operator++();
+  dummy_021::operator++();
+  dummy_022::operator++();
+  dummy_023::operator++();
+  dummy_024::operator++();
+  dummy_025::operator++();
+  dummy_026::operator++();
+  dummy_027::operator++();
+  dummy_028::operator++();
+  dummy_029::operator++();
+  dummy_030::operator++();
+  dummy_031::operator++();
+  dummy_032::operator++();
+  dummy_033::operator++();
+  dummy_034::operator++();
+  dummy_035::operator++();
+  dummy_036::operator++();
+  dummy_037::operator++();
+  dummy_038::operator++();
+  dummy_039::operator++();
+  dummy_040::operator++();
+  dummy_041::operator++();
+  dummy_042::operator++();
+  dummy_043::operator++();
+  dummy_044::operator++();
+  dummy_045::operator++();
+  dummy_046::operator++();
+  dummy_047::operator++();
+  dummy_048::operator++();
+  dummy_049::operator++();
+}
+
+
+int main(void)
+{
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/init1.C b/gcc/testsuite/g++.old-deja/g++.mike/init1.C
new file mode 100644
index 00000000000..8d591865d10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/init1.C
@@ -0,0 +1,25 @@
+int count;
+
+extern "C" void _exit(int);
+
+struct C {
+  ~C() { if (count != 1) _exit(1); }
+} c;
+
+class A {
+public:
+  ~A () { ++count; }
+};
+
+void f() {
+  static A a;
+}
+
+void g() {
+  // Since this isn't constructed, we can't destruct it.
+  static A a;
+}
+
+int main () {
+  f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/init2.C b/gcc/testsuite/g++.old-deja/g++.mike/init2.C
new file mode 100644
index 00000000000..343d76f88cc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/init2.C
@@ -0,0 +1,9 @@
+// Build don't link:
+
+struct Foo {
+  Foo (int);
+};
+
+int bar (Foo);
+
+int x = bar (3);
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/leak1.C b/gcc/testsuite/g++.old-deja/g++.mike/leak1.C
new file mode 100644
index 00000000000..849322f128c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/leak1.C
@@ -0,0 +1,38 @@
+int count = 0;
+
+class T {
+  int i;
+public:
+  T() {
+    i = 1;
+    ++count;
+  }
+  T(const T& o) {
+    i = o.i;
+    ++count;
+  }
+  T operator +(const T& o) {
+    T r;
+    r.i = this->i + o.i;
+    return r;
+  }
+  operator int () {
+    return i;
+  }
+  ~T() {
+    --count;
+  }
+} s, b;
+
+void bar() {
+  static int j = int(s+b);
+  int i = int(s+b);
+}
+
+int i = int(s+b);
+
+main() {
+  bar();
+  bar();
+  return count != 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/mangle1.C b/gcc/testsuite/g++.old-deja/g++.mike/mangle1.C
new file mode 100644
index 00000000000..ac7d6cf92fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/mangle1.C
@@ -0,0 +1,27 @@
+// Build don't link:
+// Special g++ Options: 
+
+// Make sure the typedef name is used in name mangling, not some random
+// anonymous name
+
+struct foo {
+  typedef enum { red } color;
+  void bar(color r) {
+  }
+} f;
+
+#ifdef sparc
+void f1() asm("bar__3fooQ23foo3$_0");
+void f1() {
+}
+void f2() asm("_bar__3fooQ23foo3$_0");
+void f2() {
+}
+void f3() asm("__bar__3fooQ23foo3$_0");
+void f3() {
+}
+#endif
+
+main() {
+  f.bar(foo::red);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/mangle2.C b/gcc/testsuite/g++.old-deja/g++.mike/mangle2.C
new file mode 100644
index 00000000000..174cacc6f3b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/mangle2.C
@@ -0,0 +1,17 @@
+// Build don't link:
+// Special g++ Options: 
+
+typedef struct {
+} color;
+
+void foo(color) {
+}
+
+#ifdef sparc
+void f1() asm("foo__FG3$_0");
+void f1() { }
+void f2() asm("_foo__FG3$_0");
+void f2() { }
+void f3() asm("__foo__FG3$_0");
+void f3() { }
+#endif
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/mangle3.C b/gcc/testsuite/g++.old-deja/g++.mike/mangle3.C
new file mode 100644
index 00000000000..77b92eca166
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/mangle3.C
@@ -0,0 +1,14 @@
+struct ZZ {
+  int p;
+};
+
+
+template <int ZZ::* ptr>
+struct YY {
+  ZZ qq;
+  YY() { }
+};
+
+int main() {
+  YY<&ZZ::p> ww;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/memoize1.C b/gcc/testsuite/g++.old-deja/g++.mike/memoize1.C
new file mode 100644
index 00000000000..9b7aadc5081
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/memoize1.C
@@ -0,0 +1,4 @@
+// Build don't link:
+// Special g++ Options: -fsave-memoized
+
+#include <iostream.h>
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/mi1.C b/gcc/testsuite/g++.old-deja/g++.mike/mi1.C
new file mode 100644
index 00000000000..0f5880dc145
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/mi1.C
@@ -0,0 +1,44 @@
+// Special g++ Options: -w
+
+class A {
+public:
+  virtual ~A(){};
+  virtual int type(void) {
+    return -1;
+  }
+};
+
+class B : public A {
+public:
+  virtual ~B(){};
+};
+
+
+class C0 : public B, public virtual A {
+public:
+  virtual int type(void) {
+    return 0;
+  }
+};
+
+class C1 : public C0
+{
+public:
+  virtual int type(void) {
+    return 1;
+  }
+};
+
+class C2 : public C0 {
+public:
+  virtual int type(void) {
+    return 2;
+  }
+};
+
+main() {
+  C1 *one = new C1;
+  
+  if (one->type() != 1)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/mi2.C b/gcc/testsuite/g++.old-deja/g++.mike/mi2.C
new file mode 100644
index 00000000000..f3c01e383e5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/mi2.C
@@ -0,0 +1,46 @@
+class A {
+  char a;
+public:
+  A(char x) : a(x) { }
+  virtual ~A() { }
+};
+
+class B : virtual public A {
+  char b;
+public:
+  B(char x) : A('b'), b(x) { }
+  ~B() { }
+};
+
+class C : virtual public A {
+  char c;
+public:
+  C(char x) : A('c'), c(x) { }
+  ~C() { }
+};
+
+class D : virtual public A, public B, public C {
+  char d;
+public:
+  D(char x) : A('d'), B('d'), C('d'), d(x) { }
+  ~D() { }
+};
+
+class E : virtual public A, public B, public C {
+  char e;
+public:
+  E(char x) : A('e'), B('e'), C('e'), e(x) { }
+  ~E() { }
+};
+
+class F : virtual public A, public D, public E {
+  char f;
+public:
+  F(char x) : A('f'), D('f'), E('f'), f(x) { }
+  ~F() { }
+};
+
+int main() {
+  F f('x');
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc1.C b/gcc/testsuite/g++.old-deja/g++.mike/misc1.C
new file mode 100644
index 00000000000..1703b546318
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc1.C
@@ -0,0 +1,53 @@
+// GROUPS passed construct-destruct
+/* g++ constructs j 13 times, and destructs it once. */
+
+extern "C" {
+  int printf(...);
+  void exit(int);
+}
+
+void foo() {
+}
+
+class C {
+  int val;
+ public:
+  static int count;
+  C(int ii) {
+    val = ii;
+    ++count;
+    printf("up\n");
+  }
+  ~C() {
+    --count;
+    printf("down\n");
+  }
+  operator ++() {
+    return ++val;
+  }
+  operator int() {
+    return val;
+  }
+};
+
+int C::count = 0;
+
+void bar() {
+  for (int ii=0; ii<13; ++ii)
+    for (C j=1; j<9; ++j)
+      foo();
+}
+
+main() {
+  bar();
+  if (C::count)
+    {
+      printf("FAIL\n");
+      exit(1);
+    }
+  else
+    {
+      printf("PASS\n");
+    }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc11.C b/gcc/testsuite/g++.old-deja/g++.mike/misc11.C
new file mode 100644
index 00000000000..642fd2e474a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc11.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed pt coredump
+template<class T> class A;
+void f () { A<int> *a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc12.C b/gcc/testsuite/g++.old-deja/g++.mike/misc12.C
new file mode 100644
index 00000000000..b342bb5f6c9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc12.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// GROUPS passed
+struct A { virtual void f(); }; 
+struct B { virtual void f() ; };
+struct C : virtual A , virtual B { virtual void f(); };
+
+/* This used to get an error because the DECL_CONTEXT was blown away. */
+void g(A *ptr) { ptr->f(); }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc13.C b/gcc/testsuite/g++.old-deja/g++.mike/misc13.C
new file mode 100644
index 00000000000..299af822a22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc13.C
@@ -0,0 +1,53 @@
+// GROUPS passed vtable
+extern "C" printf(...);
+enum { vf_request, vf_event } want;
+
+int errs = 0;
+
+class ivResource {
+public:
+  virtual ~ivResource () { }
+};
+
+class ivHandler   : public ivResource   {
+public:
+  virtual void event() { }
+};
+
+class ivGlyph   : public ivResource   {
+public:
+  virtual ~ivGlyph  () { }
+  virtual void request () {
+    if (want!=vf_request)
+      ++errs;
+  }
+};
+
+class ItemView : public ivGlyph, public ivHandler {
+public:
+  virtual void event () {
+    if (want!=vf_event)
+      ++errs;
+  }
+} a;
+
+ivGlyph *bar() {
+  return &a;
+}
+
+ivHandler *bar2() {
+  return &a;
+}
+
+main() {
+  want=vf_request;
+  bar()->request();
+  want=vf_event;
+  bar2()->event();
+  if (errs) {
+    printf("FAIL\n");
+    return 1;
+  }
+  printf("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc14.C b/gcc/testsuite/g++.old-deja/g++.mike/misc14.C
new file mode 100644
index 00000000000..9ceeff1bf9e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc14.C
@@ -0,0 +1,27 @@
+// GROUPS passed
+extern "C" printf(...);
+extern "C" void exit(int);
+
+class A {
+public:
+  virtual ~A() {
+    printf("FAIL\n");
+    exit (1);
+  }
+};
+
+class B : public A {
+public:
+  virtual ~B() {
+    printf("PASS\n");
+    exit (0);
+  }
+};
+
+main() {
+  B b;
+  A *ap = &b;
+  ap->~A();  // This should call the destructor virtually.
+  printf("FAIL\n");
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc2.C b/gcc/testsuite/g++.old-deja/g++.mike/misc2.C
new file mode 100644
index 00000000000..d916651e164
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc2.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// Special g++ Options: -ansi -pedantic
+// GROUPS passed
+/* -ansi -pedantic-errors should catch this. */
+
+class C {
+ public:
+  extern inline int A() {// ERROR - .*
+	return 1;
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc3.C b/gcc/testsuite/g++.old-deja/g++.mike/misc3.C
new file mode 100644
index 00000000000..5ac7a3b4884
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc3.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS uncaught
+int a;// ERROR - .*
+int a;// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc5.C b/gcc/testsuite/g++.old-deja/g++.mike/misc5.C
new file mode 100644
index 00000000000..bd3e85cee48
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc5.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS uncaught
+// Cfront bug A.3 (See Language System Release Notes for the
+// SPARCompiler C++ version 3.0)
+
+struct S1 {
+  static int S1;		// ERROR - uses same name 9.3
+};
+struct S2 {
+  union { int ii; float S2; };	// ERROR - uses same name 9.3 , XFAIL *-*-*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc6.C b/gcc/testsuite/g++.old-deja/g++.mike/misc6.C
new file mode 100644
index 00000000000..e3697527dc9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc6.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS uncaught
+// Cfront bug A.4 (See Language System Release Notes for the
+// SPARCompiler C++ version 3.0)
+
+struct assign {
+  assign& operator = (const assign&);
+};
+union U {
+  assign a;	// ERROR - member of union cannot have op= 9.4// ERROR - .*
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc7.C b/gcc/testsuite/g++.old-deja/g++.mike/misc7.C
new file mode 100644
index 00000000000..e613ad9e6ba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc7.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+// GROUPS passed MI
+struct S1 { };
+
+struct S2 : S1 { };
+struct S3 : S1 { };
+
+struct S4 : S3, S2 { };
+
+struct S1 *p1;
+struct S4 *p4;
+
+void foobar ()
+{
+  p1 = p4;		// ERROR - this is illegal// ERROR - .*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc8.C b/gcc/testsuite/g++.old-deja/g++.mike/misc8.C
new file mode 100644
index 00000000000..4cea2133422
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc8.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed vtable
+class T { public: virtual ~T() {} };
+template<class P> class X : public virtual T {};
+main() { X<int> x; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/misc9.C b/gcc/testsuite/g++.old-deja/g++.mike/misc9.C
new file mode 100644
index 00000000000..ec02d1e63c1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/misc9.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+// Special g++ Options: -Wall -pedantic
+// GROUPS passed qualifiers
+class bee {
+ public:
+  int bee::bar;		// WARNING - there is an extra bee:: here
+};
+
+class foo {
+ public:
+  int bee::bar;		// ERROR - you cannot do this
+    int me();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net1.C b/gcc/testsuite/g++.old-deja/g++.mike/net1.C
new file mode 100644
index 00000000000..9b2bbb835ff
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net1.C
@@ -0,0 +1,19 @@
+// Build don't link:
+// Here is a net bug
+
+class ivAllocation {
+public:
+  ivAllocation();
+  int x_;
+};
+
+class TBScrollBoxInfo {
+public:
+  ivAllocation allocation_;
+};
+
+TBScrollBoxInfo* items_;
+
+inline TBScrollBoxInfo item() {
+  return items_[0];
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net10.C b/gcc/testsuite/g++.old-deja/g++.mike/net10.C
new file mode 100644
index 00000000000..6ebcb014b53
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net10.C
@@ -0,0 +1,15 @@
+// Build don't link:
+// Special g++ Options: -pedantic-errors
+
+const ci=10, *pc = &ci, *const cpc = pc, **ppc;
+int i, *p, *const cp = &i;
+
+main()
+{
+  i = ci;
+  *cp = ci;
+  pc++;
+  pc = cpc;
+  pc = p;
+  ppc = &pc;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net11.C b/gcc/testsuite/g++.old-deja/g++.mike/net11.C
new file mode 100644
index 00000000000..2030796a126
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net11.C
@@ -0,0 +1,16 @@
+// Build don't link:
+// Special g++ Options: -pedantic-errors
+
+struct Foo {
+  char *p;
+  const char *q;
+  void m() const;
+};
+
+void other(char &x);
+
+void
+Foo::m() const
+{
+    other(*p);		// this is legal
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net12.C b/gcc/testsuite/g++.old-deja/g++.mike/net12.C
new file mode 100644
index 00000000000..b5fbf64ddec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net12.C
@@ -0,0 +1,16 @@
+// Build don't link:
+// Special g++ Options: -pedantic-errors
+
+struct Foo {
+  char *p;
+  const char *q;
+  void m() const;
+};
+
+void other(char &x);	// ERROR - reference below
+
+void
+Foo::m() const
+{
+    other(*q);		// ERROR - this is bad
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net13.C b/gcc/testsuite/g++.old-deja/g++.mike/net13.C
new file mode 100644
index 00000000000..d56e87270e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net13.C
@@ -0,0 +1,14 @@
+// Build don't link:
+
+// make sure extern "C" friends work.
+
+extern "C" { void func(); }
+
+struct crash {
+  int i;
+  friend void func();
+} a;
+
+void func() {
+  a.i = 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net14.C b/gcc/testsuite/g++.old-deja/g++.mike/net14.C
new file mode 100644
index 00000000000..4f32fdd52ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net14.C
@@ -0,0 +1,7 @@
+// Build don't link:
+// this probably does not have correct debugging info generated.
+
+typedef struct Thing {
+                Thing();
+        int     x;
+} Thing;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net15.C b/gcc/testsuite/g++.old-deja/g++.mike/net15.C
new file mode 100644
index 00000000000..dfe4dc5e085
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net15.C
@@ -0,0 +1,46 @@
+// InterViews (ibuild) requires this to work.
+
+extern "C" void exit(int);
+
+void *old;
+
+class c1
+{
+  int i;
+public:
+  c1 () {}
+};
+
+class c2
+{
+  int j;
+public:
+  c2 () {}
+};
+
+class c3 : public c1, public c2
+{
+public:
+  c3 ()
+    {
+      old = this;
+      // printf("new object c3 at %x\n", (int)this); }
+    }
+};
+
+c2* f ()
+{
+  c2* n = new c3 ();
+  // printf ("new object c3 casted to c2 at %x\n", (int)n);
+  return n;
+}
+
+int main ()
+{
+  c3* o = (c3*)f ();
+  // printf("new object c3, upcasted from c2 at %x\n", (int)o);
+  // if old and o are not the same, fail the test case.
+  if (old != o)
+    exit(1);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net16.C b/gcc/testsuite/g++.old-deja/g++.mike/net16.C
new file mode 100644
index 00000000000..5da97a8607f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net16.C
@@ -0,0 +1,7 @@
+// On an i386, this core dumps because the reg-stack.c code is wrong, and
+// pops an fp register that it thinks is not used, but it is.
+
+extern "C" int printf (const char*, ...);
+struct S { ~S () { } };
+double f (S) { return 5; } 
+int main() { S s; double dist = f (s); printf ("%g\n", dist); return 0; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net17.C b/gcc/testsuite/g++.old-deja/g++.mike/net17.C
new file mode 100644
index 00000000000..f80eeb39613
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net17.C
@@ -0,0 +1,58 @@
+// example from the ARM page 292 and 293
+
+extern "C" int printf(const char *, ...);
+extern "C" void exit(int);
+
+int i = 0;
+
+class A {
+public:
+  A() {
+    printf("Doing A\n");
+    if (++i != 1)
+      exit(1);
+  }
+};
+
+class B {
+public:
+  B() {
+    printf("Doing B\n");
+    if (++i != 2)
+      exit(1);
+  }
+};
+
+class C : public virtual A, public virtual B {
+public:
+  C() {
+    printf("Doing C\n");
+    if (++i != 3)
+      exit(1);
+  }
+};
+
+class D : public virtual B, public virtual A {
+public:
+  D() {
+    printf("Doing D\n");
+    if (++i != 4)
+      exit(1);
+  }
+};
+
+class E : public C, public D {
+public:
+  E() {
+    printf("Doing E\n");
+    if (++i != 5)
+      exit(1);
+  }
+} e;
+
+
+main() {
+  if (++i != 6)
+    exit(1);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net18.C b/gcc/testsuite/g++.old-deja/g++.mike/net18.C
new file mode 100644
index 00000000000..81e38d370e3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net18.C
@@ -0,0 +1,21 @@
+// Build don't link:
+
+class ClassA {
+public:
+  typedef ClassA& (*PMFV)(const char*);
+  static PMFV setMapper(PMFV);
+  static PMFV _mapper;
+};
+
+class ClassB {
+public:
+  typedef ClassB& (*PMFV)(const char*);
+};
+
+ClassA::PMFV ClassA::setMapper(ClassA::PMFV newFunc)
+{
+  PMFV oldFunc = _mapper;
+  _mapper = newFunc;
+
+  return oldFunc;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net19.C b/gcc/testsuite/g++.old-deja/g++.mike/net19.C
new file mode 100644
index 00000000000..68c47533a68
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net19.C
@@ -0,0 +1,20 @@
+// Test to make sure &<incomplete record type> works in c++
+// Build don't link:
+
+struct FILE {
+    int _flags;          
+};
+
+extern struct _fake_filebuf __std_filebuf_2;
+
+class Value {
+  int  width;                    
+public:
+  Value();                       
+  friend Value    operator&(    __const  Value&,        __const  Value&);
+};
+
+FILE* Foo ()
+{
+        return ((FILE*)&__std_filebuf_2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net2.C b/gcc/testsuite/g++.old-deja/g++.mike/net2.C
new file mode 100644
index 00000000000..ffc14ef2115
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net2.C
@@ -0,0 +1,13 @@
+// Build don't link:
+// Here is another program from the net.
+
+class B;
+
+class A {
+  private:
+    A(B *);			// ERROR - 
+  public:
+    A(long);			// ERROR - 
+};
+
+A a(0); // ERROR - should be ambigious
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net20.C b/gcc/testsuite/g++.old-deja/g++.mike/net20.C
new file mode 100644
index 00000000000..916ba434b37
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net20.C
@@ -0,0 +1,11 @@
+// Build don't link:
+// A pointer to member function test case.
+
+struct X
+{
+};
+
+void (X::* fee ())()
+{
+ lab: goto lab;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net21.C b/gcc/testsuite/g++.old-deja/g++.mike/net21.C
new file mode 100644
index 00000000000..02e40b0b935
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net21.C
@@ -0,0 +1,59 @@
+// Make sure we can initialize complex (MI ambiguous) vtables.
+
+extern "C" int printf(const char *, ...);
+
+struct a
+{
+    virtual void f() = 0;
+};
+
+struct b
+{
+    virtual void g() { };
+};
+
+struct c: public a, public b
+{
+    virtual void f();
+    virtual void g();
+};
+
+void c::f()
+{
+    printf("c::f()\n");
+}
+
+void c::g()
+{
+    printf("c::g()\n");
+}
+
+struct e: public b
+{
+};
+
+struct h
+{
+};
+
+struct d: public c, public e, public h
+{
+    virtual void f();
+    virtual void g();
+};
+void d::f()
+{
+    printf("d::f()\n");
+}
+
+void d::g()
+{
+    printf("d::g()\n");
+}
+
+int main(int argc, char* argv[])
+{
+    a* tmp = new d;
+    tmp->f();
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net22.C b/gcc/testsuite/g++.old-deja/g++.mike/net22.C
new file mode 100644
index 00000000000..088a0fea4d8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net22.C
@@ -0,0 +1,13 @@
+class Parent {
+public:
+  Parent() {}
+  Parent( char *s ) {}
+};
+
+class Child : public Parent {
+};				// ERROR - called
+
+main() {
+  Child c( "String initializer" );	// ERROR - bad
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net23.C b/gcc/testsuite/g++.old-deja/g++.mike/net23.C
new file mode 100644
index 00000000000..2fe7d4c8c01
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net23.C
@@ -0,0 +1,15 @@
+// Build don't link:
+
+class environment {
+public:
+  int get_font() ;
+};
+
+typedef int (environment::*INT_FUNCP)();
+
+void myfoo(INT_FUNCP a);
+
+void init_env_requests()
+{
+  myfoo(&environment::get_font);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net24.C b/gcc/testsuite/g++.old-deja/g++.mike/net24.C
new file mode 100644
index 00000000000..682fb08b17a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net24.C
@@ -0,0 +1,3 @@
+// Build don't link:
+
+    char HexDigit(unsigned char ch) { return ch < 'f'; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net25.C b/gcc/testsuite/g++.old-deja/g++.mike/net25.C
new file mode 100644
index 00000000000..56356779042
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net25.C
@@ -0,0 +1,17 @@
+// Build don't link:
+
+void shake_zero()
+{
+}
+
+void shake_one()
+{
+}
+
+void (*foo)();
+
+int main(int a)
+{
+  foo = a ? shake_zero : shake_one;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net26.C b/gcc/testsuite/g++.old-deja/g++.mike/net26.C
new file mode 100644
index 00000000000..5a00c8e0450
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net26.C
@@ -0,0 +1,27 @@
+// A test case found by InterViews testing...
+
+extern "C" int printf(const char *, ...);
+
+class A {
+public:
+	int foo() { printf("ok nv\n"); }
+	virtual int vfoo() { printf("ok v\n"); }
+};
+
+struct S {
+	int (A::*pfn1)();
+	int (A::*pfn2)();
+	int (A::*pfn3)();
+};
+
+// This failed before.
+S s = { &A::foo, &A::vfoo, &A::foo };
+
+A a;
+
+main() {
+  (a.*s.pfn1)();
+  (a.*s.pfn2)();
+  printf("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net27.C b/gcc/testsuite/g++.old-deja/g++.mike/net27.C
new file mode 100644
index 00000000000..afe975cc44f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net27.C
@@ -0,0 +1,9 @@
+// Build don't link:
+
+class path {
+public:
+        path (const path& r)
+            { "\"";
+	      '\'';
+            }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net28.C b/gcc/testsuite/g++.old-deja/g++.mike/net28.C
new file mode 100644
index 00000000000..3b724820fbd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net28.C
@@ -0,0 +1,28 @@
+// From reinhard@ifki50.informatik.fh-muenchen.de against gcc 2.5.0.
+// shows an InterViews problem on RS6000 and i386.  Doesn't happen on
+// SPARC.
+
+// From fbrowser.c.
+
+// Build don't link:
+
+class test {
+};
+
+
+typedef int ( test    ::*   test2)(int fd);
+
+class    ivFileBrowserImpl_IOCallback
+{
+ public:
+
+ int inputReady(int fd);
+  test    * _obj;
+  test2   _input;
+}; 
+
+
+int    ivFileBrowserImpl_IOCallback  ::inputReady(int fd)
+{
+        return (_obj->*_input)(fd);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net29.C b/gcc/testsuite/g++.old-deja/g++.mike/net29.C
new file mode 100644
index 00000000000..6635241eb89
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net29.C
@@ -0,0 +1,27 @@
+// This is a test case for the recent libg++ make check problem.
+// Build don't link:
+
+class SubString {
+public:
+  SubString();
+  SubString(const SubString& x);
+};
+
+class String {
+public:
+  String();
+  String(const SubString&  x);
+};
+
+int operator!=(const String& x, const SubString&  y);
+int operator!=(const String& x, const String& y);
+
+int operator!=(const SubString& x, const String& y);
+int operator!=(const SubString& x, const SubString&  y);
+
+void comparetest()
+{  
+  String x;
+  SubString s;
+  x != s;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net3.C b/gcc/testsuite/g++.old-deja/g++.mike/net3.C
new file mode 100644
index 00000000000..e6dbdcbe786
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net3.C
@@ -0,0 +1,16 @@
+// Build don't link:
+// Here is another program from the net.
+
+class BOOL {
+ public:
+  int val;
+  
+  BOOL(int i =0);
+  operator int();
+};
+
+BOOL& foo()
+{
+  static BOOL status;
+  return status;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net30.C b/gcc/testsuite/g++.old-deja/g++.mike/net30.C
new file mode 100644
index 00000000000..52f7b28fe24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net30.C
@@ -0,0 +1,18 @@
+// Build don't link:
+
+class X {
+public:
+  void x(void);
+};
+
+class Y : public X {
+};
+
+class Z : private Y {
+public:
+  void y(void);
+};
+
+void Z::y(void) {
+  x();  // should be OK
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net31.C b/gcc/testsuite/g++.old-deja/g++.mike/net31.C
new file mode 100644
index 00000000000..3ecf81c7349
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net31.C
@@ -0,0 +1,68 @@
+// Build don't link:
+
+class foo_a {
+  protected:
+        double func(int xi) {return 0.0;}
+  public:
+        foo_a() {}
+};
+
+class foo_b {
+  public:
+        foo_b(int);
+        foo_b();
+        ~foo_b();
+        foo_b(const foo_b&);
+        inline double& operator()(int);
+        foo_b& operator=(foo_b&);
+        void bar_a(int);
+};
+
+foo_b& operator*(foo_b&, foo_b&);
+foo_b& operator*(double, foo_b&);
+
+template <class TP>
+class foo_c {
+        typedef double (TP::* Tmatf)(int);
+        int m;
+        Tmatf* a;
+        void foo_cinst (int mm);
+  public:
+        foo_c(int mm);
+        foo_c() {m = 0; a = 0;}
+        ~foo_c() {delete a;}
+        double (TP::*& operator()(int i))(int) {return a[i];}
+        foo_b& bug_func(int);
+};
+
+template <class TP>
+foo_b& foo_c<TP>::bug_func(int x) {
+        static foo_b retval(m);
+        retval.bar_a(m);
+        for (register int i = 0; i < m; i++)
+	  retval(i) = (*(operator()(i)))(x);		// ERROR - 
+        return retval;
+}
+
+template <class TP>
+class foo_d {
+  protected:
+        foo_c<TP> bar_b;
+  public:
+        foo_d() {}
+        virtual ~foo_d() {}
+        virtual void setfoo_c();
+};
+
+class foo_e : public foo_a, public foo_d<foo_a> {
+  public:
+        foo_e();
+        ~foo_e() {}
+        void setfoo_c();
+};
+
+void foo_e::setfoo_c() {
+        bar_b(0) = func;				// ERROR - 
+}
+
+template class foo_c<foo_a>;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net32.C b/gcc/testsuite/g++.old-deja/g++.mike/net32.C
new file mode 100644
index 00000000000..4ac8a94816f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net32.C
@@ -0,0 +1,10 @@
+// Build don't link:
+
+class Co_obj {
+public:
+   Co_obj() {}
+ };
+class Linear_list_node : virtual public Co_obj { };
+class M1 : public Linear_list_node { };
+class M2 : public Linear_list_node { };
+class New_node : public M1, public M2 { };
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net34.C b/gcc/testsuite/g++.old-deja/g++.mike/net34.C
new file mode 100644
index 00000000000..06d196c890a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net34.C
@@ -0,0 +1,36 @@
+#include <iostream.h>
+
+class foo {
+public:
+        foo(int i) {k = i;}
+protected:
+        int k;
+};
+
+class bar_1 : public foo {
+public:
+        bar_1(int i) : foo(i) {}
+        int get_k() {return k;}
+};
+
+class bar_2 : public foo {
+public:
+    bar_2(int i) : foo(i) {};
+        int get_k() {return k;}
+};
+
+class multiple : public bar_1, public bar_2 {
+public:
+        multiple(int i1, int i2) : bar_1(i1), bar_2(i2) {}
+        void print() {
+                cout << "bar_1::k -> " << bar_1::k << "\n";
+                cout << "bar_2::k -> " << bar_2::k << "\n";
+                cout << "bar_1::get_k() -> " << bar_1::get_k() << "\n";
+                cout << "bar_2::get_k() -> " << bar_2::get_k() << "\n";
+        }
+};
+
+main() {
+        multiple m(1,2);
+        m.print();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net35.C b/gcc/testsuite/g++.old-deja/g++.mike/net35.C
new file mode 100644
index 00000000000..332bf429f3e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net35.C
@@ -0,0 +1,27 @@
+extern "C" int printf(const char *, ...);
+
+class A {
+ public:
+   char *x;
+};
+
+class B1:public virtual A { };
+
+class B2:public virtual A { };
+
+class C:public B1, public B2 {
+public:
+  C() { }
+};
+
+int main() {
+  C c;
+  printf("&c.x = %x\n", &c.x);
+  printf("&c.B1::x = %x\n", &c.B1::x);
+  printf("&c.B2::x = %x\n", &c.B2::x);
+  printf("&c.A::x = %x\n", &c.A::x);
+  if (&c.x != &c.B1::x
+      || &c.x != &c.B2::x
+      || &c.x != &c.A::x)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net36.C b/gcc/testsuite/g++.old-deja/g++.mike/net36.C
new file mode 100644
index 00000000000..ca86796c422
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net36.C
@@ -0,0 +1,19 @@
+// Build don't link:
+
+class X;
+
+class A {
+public:
+  void handlerFn(X*);
+};
+
+typedef void (A::*handler) (X*);
+
+class B {
+public:
+  void setHandler(handler);	// ERROR - fn ref in err msg 
+};
+
+void f(B* b) {
+  b->setHandler(A::handlerFn);	// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net37.C b/gcc/testsuite/g++.old-deja/g++.mike/net37.C
new file mode 100644
index 00000000000..1ce7834a5e2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net37.C
@@ -0,0 +1,39 @@
+class B {
+public:
+    int bi;
+    void bProc ( void ) { bi = 39; }
+  };
+
+class D : public B {
+public:
+    int di;
+    void dProc (void ){ di = 42; }
+  };
+
+typedef void (B::*BPROC)(void);
+typedef void (D::*DPROC)(void);
+
+union AFX_PMSG {
+public:
+
+  AFX_PMSG () {};
+  AFX_PMSG ( BPROC bpr ) { bfn = bpr ; }
+
+  operator BPROC() { return bfn; }
+
+  BPROC bfn;
+  DPROC dfn;
+};
+
+
+int main(int argc, char *argv[]) {
+  B b;
+  D d;
+
+  BPROC    bpr = &B::bProc;
+  AFX_PMSG pmsg(bpr);
+
+  BPROC ppr = pmsg;
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net38.C b/gcc/testsuite/g++.old-deja/g++.mike/net38.C
new file mode 100644
index 00000000000..5732d594f71
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net38.C
@@ -0,0 +1,28 @@
+struct A {
+  virtual int a ()       { return 0; }
+};
+
+struct B {
+  virtual int b ()       { return 0; }
+  virtual int b2 ()      { return 0; }
+};
+
+struct C : public A, public B {
+  virtual int a ()       { return 1; }
+  virtual int b ()       { return 2; }
+  virtual int b2 ()      { return 3; }
+};
+
+int (C::*vmpb) () = &C::b;
+int (C::*vmpb2) () = &C::b2;
+int (C::*vmpa) () = &C::a;
+
+main () {
+  C c;
+  if ((c.*vmpa)() != 1)
+    return 1;
+  if ((c.*vmpb)() != 2)
+    return 1;
+  if ((c.*vmpb2)() != 3)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net39.C b/gcc/testsuite/g++.old-deja/g++.mike/net39.C
new file mode 100644
index 00000000000..00ad1c6bc02
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net39.C
@@ -0,0 +1,30 @@
+void *vp;
+
+class silly {
+public:
+  virtual int b() { return 1; }
+};
+class solly : silly {
+public:
+  virtual int b() { return 2; }
+};
+class thing {
+public:
+  virtual int a() { return 3; }
+};
+class thong : public solly, public thing {
+public:
+  virtual int a() {
+    if (this != vp) return 4;
+    else return 0;
+  }
+};
+
+typedef int(thing::*ping)();
+ping qq = &thing::a;
+
+int main() {
+  thong b;
+  vp = &b;
+  return (b.*qq)();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net4.C b/gcc/testsuite/g++.old-deja/g++.mike/net4.C
new file mode 100644
index 00000000000..4cf8e7a1387
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net4.C
@@ -0,0 +1,32 @@
+// Message-Id: <m0lLuUK-0000fRC@nix.appli.se>
+// Date: Wed, 4 Mar 92 12:50 MET
+// From: niklas@appli.se (Niklas Hallqvist)
+// To: eichin@cygnus.com, tiemann@cygnus.com
+// Cc: gcc2@cygnus.com
+// Subject: nested type handling
+// 
+// The last couple of days I've been struggling with nested types in the
+// C++ compiler.  Frankly, it's a mess!  Was it impossible to put the stuff
+// into the parser instead of the lexer?  Well, anyway, to get the following
+// code to compile:
+// 
+// struct O {
+//   struct M {
+//     struct I
+//       {};
+//   };
+// };
+// O::M::I s;
+// 
+// a patch enclosed below is needed.  I'm not sure if it causes any
+// unanticipated side-effects, but it seem to work well for me.
+
+// Build don't link:
+
+struct O {
+  struct M {
+    struct I
+      {};
+  };
+};
+O::M::I s;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net40.C b/gcc/testsuite/g++.old-deja/g++.mike/net40.C
new file mode 100644
index 00000000000..10e16e685b7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net40.C
@@ -0,0 +1,18 @@
+#include <stddef.h>
+extern "C" void abort();
+
+class toto {
+public:
+  void * operator new (size_t t) {
+    abort();
+  }
+  void operator delete (void*p, size_t t) {
+    abort();
+  }
+};
+
+int main() {
+  toto * p;
+  p = new toto[5];
+  delete [] p;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net41.C b/gcc/testsuite/g++.old-deja/g++.mike/net41.C
new file mode 100644
index 00000000000..6f02d3ce0f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net41.C
@@ -0,0 +1,3 @@
+main() {
+  int i = ~ false;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net42.C b/gcc/testsuite/g++.old-deja/g++.mike/net42.C
new file mode 100644
index 00000000000..178a0bbf5ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net42.C
@@ -0,0 +1,25 @@
+// Build don't link:
+
+typedef void (*__sighandler_t)(int);
+
+struct sigaction {
+  __sighandler_t sa_handler;
+};
+
+struct task_struct {
+  struct sigaction sigaction[32];
+};
+
+void
+get_stat() {
+  struct task_struct ** p = 0;
+  unsigned long bit = 1;
+  unsigned long sigignore = 0;
+  int i = 0;
+  switch((unsigned long) (*p)->sigaction[i].sa_handler)
+    {
+    case 1:
+      sigignore |= bit;
+      break;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net43.C b/gcc/testsuite/g++.old-deja/g++.mike/net43.C
new file mode 100644
index 00000000000..c2c789325d6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net43.C
@@ -0,0 +1,11 @@
+// Build don't link:
+
+class foo {
+ public:
+   friend int operator ^(const foo&, const foo&);
+};
+
+main ()
+{
+   int (*funptr) (const foo &, const foo &)  = operator ^;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net44.C b/gcc/testsuite/g++.old-deja/g++.mike/net44.C
new file mode 100644
index 00000000000..5b6a0ad4bfe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net44.C
@@ -0,0 +1,11 @@
+// Make sure we don't dump core
+
+enum request { q, w, e};		// ERROR - 
+
+class request {				// ERROR - 
+public:
+  int a;
+  request( int b) {
+    a = b;
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net45.C b/gcc/testsuite/g++.old-deja/g++.mike/net45.C
new file mode 100644
index 00000000000..6f9dc3a391b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net45.C
@@ -0,0 +1,20 @@
+// Build don't link:
+
+template <class T1, class T2>
+struct pair {
+    T1 first;
+    T2 second;
+    pair(const T1& a, const T2& b) : first(a), second(b) {}
+};
+
+struct myint {
+  myint() {
+  }
+  myint(const myint& mi) {
+  }
+  operator=(const myint& mi) {
+  }
+};
+
+extern pair<const myint, myint> a;
+pair<const myint, myint> b(a);
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net46.C b/gcc/testsuite/g++.old-deja/g++.mike/net46.C
new file mode 100644
index 00000000000..1813a43814f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net46.C
@@ -0,0 +1,15 @@
+#include <iostream.h>
+#include <stddef.h>
+
+int fail = 1;
+
+static void *operator new(size_t size) {
+  --fail;
+  return (void*) 0;
+}
+
+main() {
+  cout << "";
+  new int;
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net47.C b/gcc/testsuite/g++.old-deja/g++.mike/net47.C
new file mode 100644
index 00000000000..431ff22f1a0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net47.C
@@ -0,0 +1,8 @@
+// Build don't link:
+// Special g++ Options: -w
+
+class foo {};
+class bar : foo {
+public:
+  bar () : () {}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net48.C b/gcc/testsuite/g++.old-deja/g++.mike/net48.C
new file mode 100644
index 00000000000..a2d674383b6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net48.C
@@ -0,0 +1,14 @@
+// Build don't link:
+
+char *a="aê";
+
+class A
+{
+public:
+	A()
+	{
+		char *b="aê";
+	}
+};
+
+char *c="aê";
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net5.C b/gcc/testsuite/g++.old-deja/g++.mike/net5.C
new file mode 100644
index 00000000000..e9144320479
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net5.C
@@ -0,0 +1,7 @@
+// Build don't link:
+// Special g++ Options:
+
+volatile void abort();
+volatile void oink() {
+  abort() ;
+}				// gets bogus error - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net6.C b/gcc/testsuite/g++.old-deja/g++.mike/net6.C
new file mode 100644
index 00000000000..6a3aef1d919
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net6.C
@@ -0,0 +1,5 @@
+// Build don't link:
+// Special g++ Options:
+
+struct X {};
+X x = X();		// gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net7.C b/gcc/testsuite/g++.old-deja/g++.mike/net7.C
new file mode 100644
index 00000000000..14655028ea7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net7.C
@@ -0,0 +1,7 @@
+// Build don't link:
+// Special g++ Options:
+
+// This should compile.
+
+int foo (signed char *);
+int foo (char *);
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net8.C b/gcc/testsuite/g++.old-deja/g++.mike/net8.C
new file mode 100644
index 00000000000..62b4fedb569
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net8.C
@@ -0,0 +1,32 @@
+// Build don't link:
+// Special g++ Options: -pedantic-errors
+
+class Base {
+public:
+  int foo;
+};
+
+class Derived : public Base {
+public:
+  int bar;
+};
+
+void func(Base&);		// ERROR - 
+
+void func2(const Derived& d) {
+  func(d);			// ERROR - this is bad
+}
+
+void
+foo (int& a)
+{				// ERROR - 
+}
+
+main ()
+{
+  int b;
+  const int*const a = &b;
+  *a = 10;				// ERROR - it's const
+  foo (*a);				// ERROR - it's const
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/net9.C b/gcc/testsuite/g++.old-deja/g++.mike/net9.C
new file mode 100644
index 00000000000..927184a211a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/net9.C
@@ -0,0 +1,15 @@
+// Build don't link:
+// Special g++ Options: -pedantic-errors
+
+const ci=10, *pc = &ci, *const cpc = pc, **ppc;
+int i, *p, *const cp = &i;
+
+main()
+{
+  ci = 1;	// ERROR - bad
+  ci++;		// ERROR - bad
+  *pc = 2;	// ERROR - bad
+  cp = &ci;	// ERROR - bad
+  cpc++;	// ERROR - bad
+  p = pc;	// ERROR - bad
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns1.C b/gcc/testsuite/g++.old-deja/g++.mike/ns1.C
new file mode 100644
index 00000000000..83fdf29f559
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns1.C
@@ -0,0 +1,11 @@
+namespace Foo { // WARNING - namespaces mostly broken
+  bar() {
+    return 0;
+  }
+}
+
+using namespace Foo; // ERROR - using not implemented
+
+main() {
+  bar();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns10.C b/gcc/testsuite/g++.old-deja/g++.mike/ns10.C
new file mode 100644
index 00000000000..587b9291b55
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns10.C
@@ -0,0 +1,10 @@
+// excess errors test - XFAIL *-*-*
+namespace Foo {
+  bar() {
+    return 0;
+  }
+}
+
+main() {
+  return Foo::bar();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns11.C b/gcc/testsuite/g++.old-deja/g++.mike/ns11.C
new file mode 100644
index 00000000000..f0243ca41c5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns11.C
@@ -0,0 +1,19 @@
+// excess errors test - XFAIL *-*-*
+class Foo {
+};
+
+namespace A {
+  namespace Foo {
+    bar() {
+      return 0;
+    }
+  }
+
+  mymain() {
+    return Foo::bar();
+  }
+}
+
+main() {
+  return A::mymain();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns12.C b/gcc/testsuite/g++.old-deja/g++.mike/ns12.C
new file mode 100644
index 00000000000..65682c20afc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns12.C
@@ -0,0 +1,14 @@
+namespace { 	// WARNING - namespaces mostly broken
+  int i = 10;
+  enum fish { one = 1, two = 2, red = 3, blue = 4 };
+}
+extern "C" void printf (const char *, ...);
+int main(void)
+{
+  if (i != 10) {
+    return 1;
+  }
+  if (one != 1) {
+    return 2;
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns13.C b/gcc/testsuite/g++.old-deja/g++.mike/ns13.C
new file mode 100644
index 00000000000..d0eb3cd5244
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns13.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// excess errors test - XFAIL *-*-*
+
+namespace N {
+  struct C {
+    C();
+  };
+}
+
+namespace M {
+  struct C {
+    C();
+  };
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns14.C b/gcc/testsuite/g++.old-deja/g++.mike/ns14.C
new file mode 100644
index 00000000000..62ac4566359
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns14.C
@@ -0,0 +1,12 @@
+// Build don't link:
+// excess errors test - XFAIL *-*-*
+
+namespace Jazz {
+  int horn( int h ) { return 1; }
+}
+
+using Jazz::horn;
+
+namespace Jazz {
+  int horn ( char c ) { return 0; }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns2.C b/gcc/testsuite/g++.old-deja/g++.mike/ns2.C
new file mode 100644
index 00000000000..d8112f82a9e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns2.C
@@ -0,0 +1,9 @@
+namespace N { // WARNING - namespaces mostly broken
+  int i;
+};
+
+using namespace N; // ERROR - using not implemented
+
+main() {
+  return i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns3.C b/gcc/testsuite/g++.old-deja/g++.mike/ns3.C
new file mode 100644
index 00000000000..609eb36877d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns3.C
@@ -0,0 +1,4 @@
+int i;		// ERROR - XFAIL *-*-*
+
+namespace i {	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns4.C b/gcc/testsuite/g++.old-deja/g++.mike/ns4.C
new file mode 100644
index 00000000000..a7dbdd63018
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns4.C
@@ -0,0 +1,6 @@
+// Build don't link:
+
+namespace i {	// WARNING - namespaces mostly broken
+}
+namespace i {
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns5.C b/gcc/testsuite/g++.old-deja/g++.mike/ns5.C
new file mode 100644
index 00000000000..01b36231a4a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns5.C
@@ -0,0 +1,5 @@
+namespace A {	// WARNING - namespaces mostly broken
+  int i = 1;
+}
+
+int j = i;		// ERROR - XFAIL *-*-*
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns6.C b/gcc/testsuite/g++.old-deja/g++.mike/ns6.C
new file mode 100644
index 00000000000..22506c57c62
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns6.C
@@ -0,0 +1,9 @@
+// Build don't link:
+
+namespace A {		// WARNING - namespaces mostly broken
+  int i = 1;
+}
+
+namespace A {
+  int j = i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns7.C b/gcc/testsuite/g++.old-deja/g++.mike/ns7.C
new file mode 100644
index 00000000000..0d0698c5f94
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns7.C
@@ -0,0 +1,9 @@
+// Build don't link:
+
+namespace A {	// WARNING - namespaces mostly broken
+  int i = 1;
+}
+
+namespace B {
+  int j = i;	// ERROR - XFAIL *-*-*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns8.C b/gcc/testsuite/g++.old-deja/g++.mike/ns8.C
new file mode 100644
index 00000000000..4073eb82ce8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns8.C
@@ -0,0 +1,9 @@
+// Build don't link:
+
+namespace A {	// WARNING - namespaces mostly broken
+  int i = 1;
+}
+
+namespace A {
+  int j = i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ns9.C b/gcc/testsuite/g++.old-deja/g++.mike/ns9.C
new file mode 100644
index 00000000000..b88ae278e39
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ns9.C
@@ -0,0 +1,12 @@
+// excess errors test - XFAIL *-*-*
+namespace Foo {
+  bar() {
+    return 0;
+  }
+}
+
+using Foo::bar;
+
+main() {
+  return bar();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/offset1.C b/gcc/testsuite/g++.old-deja/g++.mike/offset1.C
new file mode 100644
index 00000000000..6a259d8967a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/offset1.C
@@ -0,0 +1,38 @@
+extern "C" int printf(const char *, ...);
+void *vp;
+int fail = 0;
+
+class Foo {
+public:
+   virtual void setName() {
+     printf("Foo at %x\n", this);
+     if (vp != (void*)this)
+       fail = 1;
+   }
+};
+
+class Bar : public Foo {
+public:
+  virtual void init(int argc, char **argv) {
+    printf("Bar's Foo at %x\n", (Foo*)this);
+    vp = (void*)(Foo*)this;
+    setName();
+  }
+};
+
+class Barf : virtual public Bar {
+public:
+  virtual void init(int argc, char **argv) { Bar::init(argc, argv); }
+};
+
+class Baz : virtual public Bar, virtual public Barf {
+public:
+  virtual void init(int argc, char **argv) { Barf::init(argc, argv); }
+};
+
+Bar *theBar = new Baz();
+
+int main(int argc, char **argv) {
+   theBar->init(argc, argv);
+   return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/opr-as1.C b/gcc/testsuite/g++.old-deja/g++.mike/opr-as1.C
new file mode 100644
index 00000000000..38795b5ba24
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/opr-as1.C
@@ -0,0 +1,11 @@
+// Shows a problem with the default op= not being an implementation...
+
+class C {
+  int i;
+};
+
+C a, b;
+
+main() {
+  a = b;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/opr-dot1.C b/gcc/testsuite/g++.old-deja/g++.mike/opr-dot1.C
new file mode 100644
index 00000000000..e709057c33a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/opr-dot1.C
@@ -0,0 +1,22 @@
+// Build don't link:
+
+typedef struct base1 {
+  int x;
+} base1_t;
+
+typedef struct base2 {
+  int x;
+} base2_t;
+
+class derived1 : public base1 {
+};
+
+class derived2 : public derived1, public base2 {
+};
+
+struct test {
+  derived2& fails;
+  test1() {
+    fails.base1::x = 5;
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10148.C b/gcc/testsuite/g++.old-deja/g++.mike/p10148.C
new file mode 100644
index 00000000000..36309763fde
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10148.C
@@ -0,0 +1,33 @@
+// prms-id: 10148
+
+int fail = 1;
+void ok() { fail = 0; }
+
+class TC {
+  int s_;
+};
+
+class TIRD {
+ public:
+  void (*itc)();
+  TIRD() { itc = ok; }
+};
+
+class TCCB : public TC, public TIRD {
+};
+
+class TCRCB : public TCCB {
+public:
+  virtual void eat ();
+};
+
+void TCRCB::eat () {
+ void *vp = (TIRD*)this->itc;
+ this->itc();
+}
+
+main() {
+  TCRCB a;
+  a.eat();
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10247.C b/gcc/testsuite/g++.old-deja/g++.mike/p10247.C
new file mode 100644
index 00000000000..c69bc90afdf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10247.C
@@ -0,0 +1,6 @@
+// prms-id: 10247
+
+class a {
+public:
+  int operator++(int) { return operator()++ ; }		// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10416.C b/gcc/testsuite/g++.old-deja/g++.mike/p10416.C
new file mode 100644
index 00000000000..aa56b5ffc2a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10416.C
@@ -0,0 +1,9 @@
+// Build don't link:
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe*
+// prms-id: 10416
+
+class not_ok {
+public:
+  void f() throw(int) { }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10511.C b/gcc/testsuite/g++.old-deja/g++.mike/p10511.C
new file mode 100644
index 00000000000..b92b4f7d7fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10511.C
@@ -0,0 +1,15 @@
+// Build don't link:
+// prms-id: 10511
+
+class S {
+public:
+  enum E {a, b, c};
+};
+
+class C {
+public:
+  bool f (S::E()) { }
+  virtual void foo();
+};
+
+void C::foo() { }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10769a.C b/gcc/testsuite/g++.old-deja/g++.mike/p10769a.C
new file mode 100644
index 00000000000..784465ce8ee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10769a.C
@@ -0,0 +1,45 @@
+// Special g++ Options: -Wno-pmf-conversions
+// prms-id: 10769
+
+#define PMF2PF(PMF) ((void (*)())(PMF))
+
+int ok = 0;
+
+class A {
+public:
+  void f1a() { ok += 3; }
+  void f1b() { ok += 5; }
+  void f2a() { ok += 7; }
+  void f2b() { }
+  const static void (*table[2][2])();
+  void main();
+} a;
+
+const void (*A::table[2][2])()
+  = { { PMF2PF(&A::f1a), PMF2PF(&A::f1b) },
+      { PMF2PF(&A::f2a), PMF2PF(&A::f1b) },
+  };
+
+void
+dispatch (A *obj, int i, int j)
+{
+  (*(void (*)(A *))A::table[i][j])(obj);
+}
+
+void A::main() {
+  dispatch (&a, 0, 0);
+  void (A::*mPtr)(A*) = &A::f1a;
+
+  (*(void (*)(A*))PMF2PF(mPtr))(&a);
+  (*(void (*)(A*))PMF2PF(f2a))(&a);
+}
+
+int main() {
+  a.A::main();
+  dispatch (&a, 0, 1);
+  void (A::*mPtr)(A*) = &A::f1b;
+
+  (*(void (*)(A*))PMF2PF(a.*mPtr))(&a);
+  (*(void (*)(A*))PMF2PF(a.f2a))(&a);
+  return ok != 3+3+5+5+7+7;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10769b.C b/gcc/testsuite/g++.old-deja/g++.mike/p10769b.C
new file mode 100644
index 00000000000..91e11fb6ed7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10769b.C
@@ -0,0 +1,25 @@
+// Special g++ Options: 
+// prms-id: 10769
+
+#define PMF2PF(PMF) ((void (*)())(PMF))
+
+class A {
+public:
+  void f1a() { }
+  void main();
+} a;
+
+class B {
+public:
+  void bf1() { }
+} b;
+
+void A::main() {
+  void (B::*mPtrB)(B*);
+  (*(void (*)(A*))PMF2PF(mPtrB))(&b);	// ERROR - 
+}
+
+int main() {
+  void (A::*mPtr)(A*) = &A::f1a;
+  (*(void (*)(A*))PMF2PF(mPtr))(&a);	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10849a.C b/gcc/testsuite/g++.old-deja/g++.mike/p10849a.C
new file mode 100644
index 00000000000..ff94b1f8111
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10849a.C
@@ -0,0 +1,33 @@
+// prms-id: 10849
+
+struct A
+{
+  int comm;
+  A(int i) : comm(i) { }
+};
+
+struct S1 { char c1; };
+
+struct B : public S1, public A
+{
+  B(int i) : A(i) { }
+};
+
+struct C : public A
+{
+  C(int i) : A(i) { }
+};
+
+struct D : public B, public C
+{
+  virtual int g() {
+    int D::*pmd = &C::comm;
+    return (this->*pmd) == 42;
+  }
+  D() : B(41), C(42) { }
+} d;
+
+main() {
+  if (! d.g())
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p10951.C b/gcc/testsuite/g++.old-deja/g++.mike/p10951.C
new file mode 100644
index 00000000000..d53775fecc4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p10951.C
@@ -0,0 +1,21 @@
+// Build don't link:
+// prms-id: 10951
+
+inline int m1(const int& a) {
+  return 1;
+}
+
+template <class T>
+class A {
+public:
+  typedef int st;
+
+  static int m2t() {
+    return m1(1);
+  }
+};
+
+A<int>::st i;
+int m3() {
+  return A<int>::m2t();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11012.C b/gcc/testsuite/g++.old-deja/g++.mike/p11012.C
new file mode 100644
index 00000000000..aca77d42607
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11012.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// Special g++ Options: -Wno-pmf-conversions
+// prms-id: 11012
+
+class Foo {
+public:
+  int f(){}
+};
+
+void foo() {
+  void *p1 = &Foo::f;
+  const void *p2 = &Foo::f;
+  int (*p3)() = &Foo::f;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11110.C b/gcc/testsuite/g++.old-deja/g++.mike/p11110.C
new file mode 100644
index 00000000000..565dfb15855
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11110.C
@@ -0,0 +1,20 @@
+// prms-id: 11110
+
+class data;
+
+class conatiner {
+public:
+  virtual void* first    ();
+  virtual data* contents (void* i);
+};
+
+class user {
+public:
+  data* data1 () const;
+private:
+  conatiner& _c;
+};
+
+data* user::data1() const {
+  return (_c.contents (_c.first));	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11116.C b/gcc/testsuite/g++.old-deja/g++.mike/p11116.C
new file mode 100644
index 00000000000..9beff46e827
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11116.C
@@ -0,0 +1,22 @@
+// Build don't link:
+// Special g++ Options: -Wno-pmf-conversions
+// prms-id: 11116
+
+class Bar {
+public:
+  int f(int a) { val = a; return val; }
+private:
+  int val;
+};
+
+typedef int (Bar::*BarPtr)(int);
+
+void foo() {
+  int a;
+  int (Bar::*bp)(int) = &Bar::f;
+  Bar bar;
+  int (*p)(void *, int);
+
+  p = (int (*)(void*,int))((void (*)())((bp).__pfn_or_delta2.__pfn));
+  a = (*p)(&bar, 4);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11142.C b/gcc/testsuite/g++.old-deja/g++.mike/p11142.C
new file mode 100644
index 00000000000..a22ca45bbd7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11142.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// Special g++ Options: -fexceptions -O -g
+// prms-id: 11142
+
+class RWxmsg {
+public:
+  RWxmsg();
+  virtual ~RWxmsg();
+};
+
+class RWTHRInternalError : public RWxmsg {
+public:
+  virtual ~RWTHRInternalError() { }
+};
+
+void setCount(int count) {
+  throw RWTHRInternalError();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11144.C b/gcc/testsuite/g++.old-deja/g++.mike/p11144.C
new file mode 100644
index 00000000000..98b9fb04ef9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11144.C
@@ -0,0 +1,17 @@
+// Special g++ Options: -O
+// prms-id: 11144
+
+class Id {
+public:
+  int d_i;
+  Id(int i) : d_i(i) {}
+  int value() {return d_i;}
+} id(1);
+
+Id foo() { return id; }
+
+int main() {
+  const Id &id1 = foo();
+  const Id &id2 = foo();
+  return &id1 == &id2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11482.C b/gcc/testsuite/g++.old-deja/g++.mike/p11482.C
new file mode 100644
index 00000000000..f03a4229eca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11482.C
@@ -0,0 +1,10 @@
+// Build don't link:
+// prms-id: 11482
+
+void *vp;
+
+enum E { bad, ok } e;
+
+void foo() {
+  e = (E)vp;		// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p11667.C b/gcc/testsuite/g++.old-deja/g++.mike/p11667.C
new file mode 100644
index 00000000000..be028b32369
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p11667.C
@@ -0,0 +1,62 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+// prms-id: 11667
+
+extern "C" printf(const char *,...);
+
+template < class T >
+class LIST {
+public:
+
+  LIST() { nitems = 16; items = new T[nitems]; };
+
+  LIST(int u) { nitems = u; items = new T[nitems]; };
+
+  T& operator[](int i) const {
+    return items[i];
+  }
+
+  void grow(int n) {
+    T* newlist = new T[n];
+    T* src = items;
+    T* dst = newlist;
+    int i = nitems;
+
+    try {
+      while (i--) *dst++ = *src++;
+    } catch (...) {
+      delete[]  newlist;
+      throw;
+    }
+
+    if (items) delete[] items;
+    nitems = n;
+    items = newlist;
+  }
+
+private:
+  int nitems;
+  T *items;
+};
+
+int main(int argc, char **argv) {
+  int i;
+  LIST<int> mylist(10);
+
+  printf("Start dumping initial 10 item list\n");
+  for (i = 0; i < 10 ; i++) {
+    mylist[i] = i;
+    printf("%d\n", mylist[i]);
+  }
+
+  printf("Growing list to 20\n");
+  mylist.grow(20);
+
+  printf("Start dumping grown 20 item list\n");
+  for (i = 0; i < 20; i++) {
+    mylist[i] = i;
+    printf("%d\n", mylist[i]);
+  }
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p12306.C b/gcc/testsuite/g++.old-deja/g++.mike/p12306.C
new file mode 100644
index 00000000000..12b4a453b9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p12306.C
@@ -0,0 +1,75 @@
+// prms-id: 12306
+
+void *ptr1, *ptr2;
+int fail = 0;
+
+extern "C" int printf(const char *...);
+
+class RWSlist { };
+
+class RWSlistIterator {
+public:
+  RWSlist *slist;
+  RWSlistIterator(RWSlist& s) { } 
+  void toLast() {
+    if (ptr1 != (RWSlistIterator*)this)
+      fail = 5;
+    if (ptr2 != &(*this).slist)
+      fail = 6;
+
+    if (0) printf("at %x %x\n", (RWSlistIterator*)this, &(*this).slist);
+  }
+};
+
+class RWCollectable {
+};
+
+class RWSlistCollectables : public RWSlist {
+public:	 
+  RWSlistCollectables() { }
+  RWSlistCollectables(RWCollectable* a) { }
+};
+
+class RWIterator { };	  
+
+class RWSlistCollectablesIterator : public RWIterator, public RWSlistIterator {
+public:
+  RWSlistCollectablesIterator(RWSlistCollectables& s) : RWSlistIterator(s) { } 
+};
+
+class Sim_Event_Manager {
+public:
+  RWSlistCollectables scheduled_events_;
+  RWSlistCollectablesIterator last_posted_event_position_;
+  Sim_Event_Manager();
+  void post_event();
+};
+
+Sim_Event_Manager::Sim_Event_Manager ()
+  :last_posted_event_position_(scheduled_events_)
+{
+}
+
+void Sim_Event_Manager::post_event () {
+  ptr1 = (RWSlistIterator*)&last_posted_event_position_;
+  ptr2 = &((RWSlistIterator*)&last_posted_event_position_)->slist;
+  if (0) printf("at %x %x\n", (RWSlistIterator*)&last_posted_event_position_,
+		&((RWSlistIterator*)&last_posted_event_position_)->slist);
+  if (ptr1 != (RWSlistIterator*)&last_posted_event_position_)
+    fail = 1;
+  if (ptr2 != &((RWSlistIterator&)last_posted_event_position_).slist)
+    fail = 2;
+  if (0) printf("at %x ?%x\n", (RWSlistIterator*)&last_posted_event_position_,
+		&((RWSlistIterator&)last_posted_event_position_).slist);
+  if (ptr1 != (RWSlistIterator*)&last_posted_event_position_)
+    fail = 3;
+  if (ptr2 != &((RWSlistIterator&)last_posted_event_position_).slist)
+    fail = 4;
+  last_posted_event_position_.toLast();
+}
+
+int main(int argc, char **argv) {
+  Sim_Event_Manager foo;
+  foo.post_event();
+  return fail;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p12306a.C b/gcc/testsuite/g++.old-deja/g++.mike/p12306a.C
new file mode 100644
index 00000000000..bbcade4f9be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p12306a.C
@@ -0,0 +1,35 @@
+// prms-id: 12306
+// a net report of the same problem as 12306
+
+class a {
+public:
+    int i;
+};
+
+class g : virtual public a {
+};
+
+class b : virtual public a {
+    int j;
+};
+
+class c : public g, public b {
+};
+
+class d {
+public:
+    virtual class b* get() {return 0;}
+};
+
+class f : public d {
+public:
+    virtual class b* get() {return &_c;}
+    c _c;
+};
+
+int main(void) {
+    f D;
+    b* bp=D.get();
+    D._c.i = 42;
+    return &D._c.i != &bp->i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p1248.C b/gcc/testsuite/g++.old-deja/g++.mike/p1248.C
new file mode 100644
index 00000000000..3db677c5b80
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p1248.C
@@ -0,0 +1,28 @@
+// GROUPS passed pure-virt
+extern "C" { void printf(const char *, ...); }
+class Base {
+public:
+  virtual ~Base() =0;
+};
+
+class Deranged : public Base {
+public:
+  int value;
+  virtual ~Deranged();
+};
+
+
+Deranged::~Deranged(){}
+
+void foo() {
+  Deranged d;
+}
+
+main()
+{
+  foo();
+  printf("PASS\n");
+  return 0;
+}
+
+Base::~Base () { }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p1567.C b/gcc/testsuite/g++.old-deja/g++.mike/p1567.C
new file mode 100644
index 00000000000..0cc9a03775e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p1567.C
@@ -0,0 +1,41 @@
+// GROUPS passed vtable
+extern "C" printf (const char *, ...);
+extern "C" void exit(int);
+
+class A {
+public:
+  virtual const char* f1() { return "A::f1"; }
+  virtual const char* f2() { return "A::f2"; }
+  virtual const char* f3() { printf("FAIL\n"); exit(1); return "A::f3"; }
+};
+
+class B {
+public:
+  virtual const char* f2() { return "B::f2"; }
+  virtual const char* f3() { return "B::f3"; }
+};
+
+class C: public A, public B {
+public:
+  const char* f2() { return B::f2(); }
+  const char* f1() { return f2(); }
+  const char* f3() { return A::f3(); }
+};
+
+class D: public A, public B {
+public:
+  const char* f2() { return B::f2(); }
+  const char* f1() { return D :: f2(); }
+  const char* f3() { return A::f3(); }
+};
+
+main() {
+  C* tempC = new C;
+  D* tempD = new D;
+  A* a = tempC;
+  printf("calling f1 on a C gives %s\n", a->f1());
+  a = tempD;
+  printf("calling f1 on a D gives %s\n", a->f1());
+  printf("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p1862.C b/gcc/testsuite/g++.old-deja/g++.mike/p1862.C
new file mode 100644
index 00000000000..1f88a830a26
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p1862.C
@@ -0,0 +1,62 @@
+// GROUPS vtable
+extern "C" printf (const char *, ...);
+
+class A
+{
+public:
+  virtual ~A(){};
+  virtual int type(void)
+  {
+    return -1;
+  }
+};
+
+class B
+{
+public:
+  virtual ~B(){};
+};
+
+
+class C0 : public B, public A
+{
+public:
+  virtual int type(void)
+  {
+    return 0;
+  }
+};
+
+class C1 : public C0
+{
+public:
+  virtual int type(void)
+  {
+    return 1;
+  }
+};
+
+class C2 : public C0
+{
+public:
+  virtual int type(void)
+  {
+    return 2;
+  }
+};
+
+main()
+{
+  C1 *one = new C1;
+  
+  if (one->type() == 1)
+    {
+      printf ("PASS\n");
+      return 0;
+    }
+  else
+    {
+      printf ("FAIL\n");
+      return 1;
+    }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p1989.C b/gcc/testsuite/g++.old-deja/g++.mike/p1989.C
new file mode 100644
index 00000000000..a145b1ecbce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p1989.C
@@ -0,0 +1,494 @@
+// Build don't link:
+// prms-id: 1989
+
+#define TRUE true
+#define FALSE false
+typedef void *Pix;
+
+template<class T>
+struct link {
+    T item;
+    link *next;
+    link *prev;
+
+    link(const T& t): item(t), prev(0), next(0)
+	{ };
+    link(const T& t, link<T> *p, link<T> *n): item(t), prev(p), next(n)
+	{ };
+};
+
+template<class T>
+class List_DL {
+public:
+    List_DL();
+    List_DL(const List_DL&);
+    ~List_DL();
+
+    void append(const T& item);
+    void prepend(const T& item);
+    void insert(const T& item, Pix x, bool before);
+
+    void remove(Pix& x)
+	{ T tmp; remove(x, tmp); }
+    void remove(Pix& x, T& item);
+
+    void clear();
+
+    unsigned length() const
+	{ return count; }
+
+private:
+
+    unsigned count;
+    link<T> *head;
+    link<T> *tail;
+
+public:
+    Pix first() const
+	{ return Pix(head); }
+    Pix last() const
+	{ return Pix(tail); }
+    void next(Pix& x) const
+	{ if (0 != x) x = ((link<T> *) x)->next; }
+    void prev(Pix& x) const
+	{ if (0 != x) x = ((link<T> *) x)->prev; }
+    T& operator()(Pix x) const
+	{ return ((link<T> *) x)->item; }
+};
+
+template<class T>
+List_DL<T>::List_DL():
+count(0),
+head(0)
+{ }
+
+template<class T>
+List_DL<T>::List_DL(const List_DL& other):
+count(0),
+head(0)
+{
+    for (Pix x=other.first(); 0 != x; other.next(x))
+	append(other(x));
+}
+
+template<class T>
+List_DL<T>::~List_DL()
+{
+    clear();
+}
+
+template<class T>
+void
+List_DL<T>::append(const T& item)
+{
+    count++;
+    if (0 == head) {
+	head = new link<T>(item);
+	tail = head;
+    } else {
+	tail->next = new link<T>(item, tail, 0);
+	tail = tail->next;
+    }
+}
+
+template<class T>
+void
+List_DL<T>::prepend(const T& item)
+{
+    count++;
+    if (0 == head) {
+	head = new link<T>(item);
+	tail = head;
+    } else {
+	head = new link<T>(item, 0, head);
+	if (tail == head)
+	    tail = tail->next;
+    }
+}
+
+template<class T>
+void
+List_DL<T>::insert(const T& item, Pix x, bool before = TRUE)
+{
+    link<T> *l = (link<T> *) x;
+
+    if (before) {
+	if (0 == l || l == head) {
+	    prepend(item);
+	} else {
+	    link<T> *n = new link<T>(item, l->prev, l);
+	    l->prev->next = n;
+	    l->prev = n;
+	}
+    } else {
+	if (0 == l || l == tail) {
+	    append(item);
+	} else {
+	    link<T> *n = new link<T>(item, l, l->next);
+	    l->next->prev = n;
+	    l->prev = n;
+	}
+    }
+}
+
+template<class T>
+void
+List_DL<T>::remove(Pix& x, T& item)
+{
+    link<T> *l = (link<T> *) x;
+
+    if (0 == l)
+	return;
+
+    item = l->item;
+    if (1 == count) {
+	delete head;
+	head = 0;
+	tail = 0;
+    } else {
+	// more than one item in the list
+	if (l == head) {
+	    link<T> *old = head;
+	    head = head->next;
+	    head->prev = 0;
+	    delete old;
+	} else if (l == tail) {
+	    link<T> *old = tail;
+	    tail = tail->prev;
+	    tail->next = 0;
+	    delete old;
+	} else {
+	    l->next->prev = l->prev;
+	    l->prev->next = l->next;
+	    delete l;
+	}
+    }
+}
+
+template<class T>
+void
+List_DL<T>::clear()
+{
+    link<T> *l, *succ;
+    for (l=head; 0 != l; l=succ) {
+	succ = l->next;
+	delete l;
+    }
+    head = 0;
+    tail = 0;
+}
+
+template<class T>
+class List_DLS: public List_DL<T> {
+public:
+    List_DLS(): List_DL<T>()
+	{ };
+    List_DLS(const List_DLS& other): List_DL<T>(other)
+	{ };
+
+    bool contains(const T& item) const
+	{ return search(item) != 0 ? TRUE: FALSE; }
+    Pix search(const T&) const;
+};
+
+template<class T>
+Pix
+List_DLS<T>::search(const T& item) const
+{
+    for (Pix x=first(); 0 != x; next(x)) {
+	if (item == operator()(x)) // ERROR - const subversion
+	    return x;
+    }
+    return 0;
+}
+
+template<class T>
+class List_DLSp: public List_DL<T> {
+public:
+    List_DLSp(): List_DL<T>()
+	{ };
+    List_DLSp(const List_DLSp& other): List_DL<T>(other)
+	{ };
+
+    bool contains(const T& item) const
+#ifndef INTERNAL_ERROR
+	;
+#else
+	{ return search(item) != 0 ? TRUE: FALSE; }
+#endif
+    Pix search(const T&) const;
+};
+
+template<class T>
+bool
+List_DLSp<T>::contains(const T& item) const
+{
+    for (Pix x=first(); 0 != x; next(x)) {
+	if (*item == *operator()(x))
+	    return TRUE;
+    }
+    return FALSE;
+}
+
+template<class T>
+class Set {
+public:
+    Set();
+    Set(const Set& other);
+
+    virtual void add(const T& item);
+
+    void remove(const T& item)
+	{ Pix x = search(item); remove(x); }
+    void remove(Pix& x)
+	{ T tmp; remove(x, tmp); }
+    virtual void remove(Pix& x, T& item);
+
+    virtual void clear();
+
+    virtual bool contains(const T&) const;
+    virtual Pix search(const T&) const;
+
+    virtual unsigned length() const;
+
+    virtual Pix first() const;
+    virtual void next(Pix& x) const;
+    virtual T& operator()(Pix x) const;
+};
+
+template<class T>
+Set<T>::Set()
+{ }
+
+template<class T>
+Set<T>::Set(const Set& other)
+{ }
+
+
+template<class T>
+class Set_DL: public List_DLS<T> {
+public:
+    Set_DL();
+    Set_DL(const Set_DL& other);
+
+    void add(const T& item)
+	{ list.append(item); }
+    void remove(Pix& x, T& item)
+	{ list.remove(x, item); }
+
+    void clear()
+	{ list.clear(); }
+
+    bool contains(const T& item) const
+	{ return list.contains(item); }
+    Pix search(const T& item) const
+	{ return list.search(item); }
+
+    unsigned length() const
+	{ return list.length(); }
+
+    Pix first() const
+	{ return list.first(); }
+    void next(Pix& x) const
+	{ list.next(x); }
+    T& operator()(Pix x) const
+	{ return list(x); }
+private:
+    List_DLS<T> list;
+};
+
+template<class T>
+class Set_DLp: public List_DLSp<T> {
+public:
+    Set_DLp();
+    Set_DLp(const Set_DLp& other);
+
+    void add(const T& item)
+	{ list.append(item); }
+    void remove(Pix& x, T& item)
+	{ list.remove(x, item); }
+
+    void clear()
+	{ list.clear(); }
+
+    bool contains(const T& item) const
+	{ return list.contains(item); }
+    Pix search(const T& item) const
+	{ return list.search(item); }
+
+    unsigned length() const
+	{ return list.length(); }
+
+    Pix first() const
+	{ return list.first(); }
+    void next(Pix& x) const
+	{ list.next(x); }
+    T& operator()(Pix x) const
+	{ return list(x); }
+private:
+    List_DLSp<T> list;
+};
+
+template<class T>
+struct vertex {
+    T item;
+    List_DL<vertex<T> *> fanout;
+
+    vertex(): item(), fanout()	// gets bogus error
+      { };
+    vertex(const T& i): item(), fanout() // gets bogus error - XFAIL *-*-*
+      { };
+};
+
+template<class T>
+class Graph {
+public:
+    Graph();
+    Graph(const Graph&);
+    ~Graph();
+
+    void add(const T& from, const T& to);
+    bool contains(const T& from, const T& to) const;
+
+    void clear()
+	{ vertices.clear(); }
+
+    unsigned lengthV() const
+	{ return vertices.length(); }
+
+    Pix firstV() const
+	{ return vertices.first(); }
+    void nextV(Pix& x) const
+	{ vertices.next(x); }
+    T& V(Pix x) const
+	{ return vertices(x).item; }
+
+    Pix firstV1(Pix vx) const;
+    void nextV1(Pix vx, Pix& x) const;
+    T& V1(Pix vx, Pix x) const;
+private:
+    vertex<T> *lookup(const T& from) const;
+    vertex<T> *lookup_new(const T& from);
+
+    List_DLS<vertex<T> > vertices;
+};
+
+template<class T>
+Graph<T>::Graph():
+vertices()
+{ }
+
+template<class T>
+Graph<T>::Graph(const Graph& other):
+vertices()
+{
+    for (Pix vx=firstV(); 0 != vx; nextV(vx)) {
+	for (Pix vx1=firstV1(vx); 0 != vx1; nextV1(vx, vx1)) {
+	    add(V(vx), V1(vx, vx1));
+	}
+    }
+}
+
+template<class T>
+Graph<T>::~Graph()
+{
+    clear();
+}
+
+template<class T>
+void
+Graph<T>::add(const T& from, const T& to)
+{
+    vertex<T> *fromv = lookup_new(from);
+    if (from == to)
+	return;
+    vertex<T> *tov = lookup_new(to);
+    fromv->fanout.append(tov);
+}
+
+template<class T>
+bool
+Graph<T>::contains(const T& from, const T& to) const
+{
+    vertex<T> *fromv = lookup(from);
+    if (0 == fromv)
+	return FALSE;
+
+    for (Pix x=fromv->fanout.first(); 0 != x; fromv->fanout.next(x)) {
+	if (fromv->fanout(x)->item == to)
+	    return TRUE;
+    }
+
+    return FALSE;
+}
+
+template<class T>
+vertex<T> *
+Graph<T>::lookup(const T& from) const
+{
+    for (Pix x=vertices.first(); 0 != x; vertices.next(x)) {
+	if (vertices(x).item == from)
+	    return &vertices(x);
+    }
+    return 0;
+}
+
+template<class T>
+vertex<T> *
+Graph<T>::lookup_new(const T& from)
+{
+    vertex<T> *v = lookup(from);
+    if (0 == v) {
+	vertices.append(from);		// gets bogus error
+	return &vertices(vertices.last());
+    }
+    return v;
+}
+
+template<class T>
+Pix
+Graph<T>::firstV1(Pix vx) const
+{
+    vertex<T> *v = (vertex<T> *) vx;
+    return v->fanout.first();
+}
+
+template<class T>
+void
+Graph<T>::nextV1(Pix vx, Pix& x) const
+{
+    vertex<T> *v = (vertex<T> *) vx;
+    return v->fanout.next(x);  // ERROR - return from void method
+}
+
+template<class T>
+T&
+Graph<T>::V1(Pix vx, Pix x) const
+{
+    vertex<T> *v = (vertex<T> *) vx;
+    static T x1;
+    return x1;
+}
+
+class STRLIdentifier;
+
+extern x(List_DL<STRLIdentifier *>);
+extern x(List_DLS<STRLIdentifier *>);
+
+extern x(Set<STRLIdentifier *>);
+extern x(Set_DL<STRLIdentifier *>);
+extern x(Set_DLp<STRLIdentifier *>);
+
+extern x(Graph<STRLIdentifier *>);
+
+class STRLIdentifier {
+    char buf[10];
+};
+
+extern int operator==(vertex<STRLIdentifier*>&, vertex<STRLIdentifier*>&); // ERROR - const subversion
+extern int operator==(STRLIdentifier&, STRLIdentifier&); // ERROR - fn ref in err msg
+
+extern x(List_DLSp<STRLIdentifier *>);
+
+template class Graph<STRLIdentifier *>;
+template class List_DLS<vertex<STRLIdentifier *> >;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2394.C b/gcc/testsuite/g++.old-deja/g++.mike/p2394.C
new file mode 100644
index 00000000000..ce335c40183
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2394.C
@@ -0,0 +1,36 @@
+// prms-id: 2394
+
+class Foo {
+ public:
+  int x;
+  int y;
+  Foo(int i, int j) { x = i; y = j; }
+} foo(10, 11);
+
+class Wasted { int unsed; };
+
+class Bar : Wasted, public Foo {
+public:
+  Bar() : Foo(12, 13) { }
+} bar;
+
+int
+test0() {
+  int Foo::* pmi = &Foo::y;
+  return (int)(foo.*pmi);
+}
+
+int
+test1() {
+  int Foo::* pmi = &Foo::y;
+  return (int)(bar.*pmi);
+}
+
+int
+main() {
+  if (test0() != 11)
+    return 1;
+  if (test1() != 13)
+    return 2;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2431.C b/gcc/testsuite/g++.old-deja/g++.mike/p2431.C
new file mode 100644
index 00000000000..17a76fa7c18
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2431.C
@@ -0,0 +1,23 @@
+// Build don't link: 
+// GROUPS passed infinite_loop
+class A
+{
+	public:
+      A(A &); // ERROR - candidates are
+};
+
+class B
+{
+	public:
+	operator A ();
+};
+
+class C
+{
+	public :
+	C()
+	{
+		B	b;
+		A a = b;// ERROR - 
+	}
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2573.C b/gcc/testsuite/g++.old-deja/g++.mike/p2573.C
new file mode 100644
index 00000000000..9e3ddeed9de
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2573.C
@@ -0,0 +1,14 @@
+// prms-id: 2573
+
+class X {
+public:
+  int key();
+  virtual int vkey();
+  char *add();
+};
+
+char *X::add() {
+  char *f1 = (char *) &key;	// ERROR - 
+  char *f2 = (char *) &vkey;	// ERROR - 
+  return f1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2736.C b/gcc/testsuite/g++.old-deja/g++.mike/p2736.C
new file mode 100644
index 00000000000..0ef5b3a0001
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2736.C
@@ -0,0 +1,28 @@
+// This is a poor test case, it is meant to ensure that function local
+// statics are destroyed at the right time.  See PR 2736 for details.
+// prms-id: 2736
+
+int count;
+
+struct A {
+  int which;
+  A(int i) :which(i) {
+    // printf("ctor %x\n", this);
+  }
+  ~A() {
+    // printf("dtor %x\n", this);
+    if (++count != which)
+      abort ();
+    }
+};
+
+void
+foo() {
+  static A a(1);
+}
+
+A a(2);
+
+main() {
+  foo();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2746.C b/gcc/testsuite/g++.old-deja/g++.mike/p2746.C
new file mode 100644
index 00000000000..fdc37d137f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2746.C
@@ -0,0 +1,156 @@
+// Build don't link: 
+// GROUPS passed scope pt
+class Link {
+public:
+  Link();
+  Link(Link *);
+private:
+  Link *next_;
+
+friend class IListBase;
+friend class IListIterBase;
+};
+
+inline
+Link::Link() : next_(0)
+{
+}
+
+inline
+Link::Link(Link *next) : next_(next)
+{
+}
+
+class IListBase {
+public:
+  IListBase();
+  IListBase(Link *);
+  void  append(Link *);
+  void insert(Link *);
+  Link *head();
+  int empty();
+  Link *get();
+  void remove(Link *);
+private:
+  Link *head_;
+friend class IListIterBase;
+};
+
+inline
+IListBase::IListBase() : head_(0)
+{
+}
+
+inline
+IListBase::IListBase(Link *head) : head_(head)
+{
+}
+
+inline
+void IListBase::insert(Link *p)
+{
+  p->next_ = head_;
+  head_ = p;
+}
+
+inline
+Link *IListBase::head()
+{
+  return head_;
+}
+
+inline
+int IListBase::empty()
+{
+  return head_ == 0;
+}
+
+inline
+Link *IListBase::get()
+{
+  Link *tem = head_;
+  head_ = head_->next_;
+  return tem;
+}
+  
+template<class T> class IListIter;
+
+template<class T>
+class IList : private IListBase {
+public:
+  IList() { }
+  IList(T *p) : IListBase(p) { }
+  ~IList();
+  void append(T *p) { IListBase::append(p); }
+  void insert(T *p) { IListBase::insert(p); }
+  void remove(T *p) { IListBase::remove(p); }
+  T *head() { return (T *)IListBase::head(); }
+  T *get() { return (T *)IListBase::get(); }
+  IListBase::empty;
+friend class IListIter<T>;
+};
+
+template<class T>
+IList<T>::~IList()
+{
+  while (!empty())
+    delete get();
+}
+
+class IListIterBase {
+public:
+  IListIterBase(const IListBase &);
+  int done();
+  Link *cur();
+  void next();
+private:
+  Link *p_;
+};
+
+inline
+IListIterBase::IListIterBase(const IListBase &list) : p_(list.head_)
+{
+}
+
+inline
+int IListIterBase::done()
+{
+  return p_ == 0;
+}
+
+inline
+Link *IListIterBase::cur()
+{
+  return p_;
+}
+
+inline
+void IListIterBase::next()
+{
+  p_ = p_->next_;
+}
+
+
+template<class T>
+class IListIter : private IListIterBase {
+public:
+  IListIter(const IList<T> &list) : IListIterBase(list) { }
+  T *cur() { return (T *)IListIterBase::cur(); }
+  IListIterBase::next;
+  IListIterBase::done;
+};
+
+
+struct A {
+  IList<Link> list;
+  int x;
+  void foo();
+};
+
+
+void A::foo()
+{
+  for (IListIter<Link> iter(list); !iter.done(); iter.next())
+    ;
+  x = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2793.C b/gcc/testsuite/g++.old-deja/g++.mike/p2793.C
new file mode 100644
index 00000000000..73bf23f7349
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2793.C
@@ -0,0 +1,6 @@
+// Build don't link:
+// prms-id: 2793
+
+void f(char&) {			// ERROR - referenced by error below
+  f('c');			// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2806.C b/gcc/testsuite/g++.old-deja/g++.mike/p2806.C
new file mode 100644
index 00000000000..401b5ecd488
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2806.C
@@ -0,0 +1,20 @@
+// Build don't link: 
+// GROUPS passed
+template<class T>
+class List
+{
+  public:
+    List();
+    void f() const;
+};
+
+template<class T>
+void List<T>::f() const
+{
+}
+
+void func()
+{
+    List<int> list;
+    list.f();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2846.C b/gcc/testsuite/g++.old-deja/g++.mike/p2846.C
new file mode 100644
index 00000000000..953e80037b8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2846.C
@@ -0,0 +1,55 @@
+// prms-id: 2846
+
+extern "C" int printf(const char *, ...);
+extern "C" void exit(int);
+
+class A;
+class B;
+
+class A {
+public:
+
+  A(void){}
+  A(const A&){}
+  A(const B&);
+
+  virtual ~A(void){}
+
+  virtual void print(void) const {
+    printf("A::print\n");
+    printf("FAIL\n");
+    exit(1);
+  }
+  B compute(void) const;
+};
+
+class B : private A {
+friend class A;
+public:
+
+  virtual ~B(void){}
+
+  void print(void) const {
+    printf("B::print\n");
+  }
+
+private:
+  B(const A& x, int){}
+};
+
+A::A(const B& s) {
+  s.print();
+}
+
+B A::compute(void) const {
+  B sub(*this, 1);
+  return sub;
+}
+
+main ()
+{
+  A titi;
+  A toto = titi.compute();
+  printf("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2846a.C b/gcc/testsuite/g++.old-deja/g++.mike/p2846a.C
new file mode 100644
index 00000000000..363ed5b0177
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2846a.C
@@ -0,0 +1,34 @@
+// Shows that problem of initializing one object's vtable pointer from
+// another object's vtable pointer when doing a default copy of it
+// and the vtable pointer involved is the main one.
+
+// Correct answer is B::print.
+// g++ prints D::print, which is wrong.  Cfront gets is right.
+
+// prms-id: 2846
+
+extern "C" int printf(const char *, ...);
+extern "C" void exit(int);
+
+class B {
+public:
+  virtual void print(void) const { printf("B::print\n"); }
+};
+
+class D : public B {
+public:
+  void print(void) const { printf("D::print\n"); exit(1); }
+  B compute(void) const;
+};
+
+B D::compute(void) const
+{
+  B sub(*(B*)this);
+  return sub;
+}
+
+main () {
+  D titi;
+  titi.compute().print();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2846b.C b/gcc/testsuite/g++.old-deja/g++.mike/p2846b.C
new file mode 100644
index 00000000000..0fb8217456e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2846b.C
@@ -0,0 +1,52 @@
+// Shows that problem of initializing one object's secondary base from
+// another object via a user defined copy constructor for that base,
+// the pointer for the secondary vtable is not set after implicit
+// copying of the outer class, but rather has the pointer to the main
+// vtable for the secondary base left over from the user defined copy
+// constructor for that base.
+
+// Correct answer is B::beefy.
+// g++ prints A::beefy, which is wrong.  Cfront gets it right.
+
+// prms-id: 2846
+
+extern "C" int printf(const char *, ...);
+extern "C" void exit(int);
+
+class B;
+
+class A {
+ public:
+
+  A(void){}
+  A(const A&){}
+
+  virtual void print(void) const { }
+  B compute(void) const;
+};
+
+class C {
+public:
+  C() { }
+  C(C& o) { }		// with it, things are wrong, without it, they're ok
+  virtual void beefy(void) const { printf("A::beefy\n"); exit(1); }
+};
+
+class B : private A, public C {
+public:
+  B(const A& x, int){}
+  void beefy(void) const { printf("B::beefy\n"); }
+};
+
+B A::compute(void) const
+{
+  B sub(*this, 1);
+  return sub;
+}
+
+main ()
+{
+  A titi;
+  titi.compute().beefy();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2855.C b/gcc/testsuite/g++.old-deja/g++.mike/p2855.C
new file mode 100644
index 00000000000..9c99bd72835
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2855.C
@@ -0,0 +1,21 @@
+// Build don't link:
+// Special g++ Options: -Wcast-qual
+// prms-id: 2855
+
+class Ctest {
+private:
+  char* data;
+public:
+  operator const char *() const;
+};
+
+Ctest::operator const char *() const
+{
+  return data;
+}
+int main()
+{
+  Ctest obj;
+  char* temp = (char *)obj;		// WARNING - 
+  temp[0] = '\0';
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p2960.C b/gcc/testsuite/g++.old-deja/g++.mike/p2960.C
new file mode 100644
index 00000000000..f7c88d9843c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p2960.C
@@ -0,0 +1,30 @@
+// prms-id: 2960
+
+extern "C" int printf(const char *, ...);
+
+class Test0 {
+public:
+  virtual void f0() { }      // works fine if this virtual removed
+};
+
+class Test1 : public Test0 {
+public:
+  void f1() { f2(); }		// generates bus error here
+  virtual void f2() { printf("Test1::f2\n"); }
+};
+
+class Test2 {
+public:
+  virtual void f3() { }
+};
+
+class Test3 : public Test2, public Test1 {    // works fine if Test1 first
+public:
+  virtual ~Test3() { f1(); }                       // calling f2 directly works
+  virtual void f2() { printf("Test3::f2\n"); }
+};
+
+main() {
+    Test3 t3;
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3041.C b/gcc/testsuite/g++.old-deja/g++.mike/p3041.C
new file mode 100644
index 00000000000..c059c0e6cdb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3041.C
@@ -0,0 +1,33 @@
+// prms-id: 3041
+
+class A {
+public:
+  A() { }
+  virtual void a() = 0;
+  static int b(A * p) {
+    p->a();
+    return 1;
+  }
+};
+
+class B : virtual public A {
+public:
+  B() {
+    static int installed = b(this);
+  }
+  void a() { }
+};
+
+class C : virtual public B {
+public:
+  C() {
+    static int installed = b(this);
+  }
+  void a() { }
+};
+
+main()
+{
+  C c;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3060c.C b/gcc/testsuite/g++.old-deja/g++.mike/p3060c.C
new file mode 100644
index 00000000000..e26b8024db6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3060c.C
@@ -0,0 +1,23 @@
+// A new problem with my pointer to member function work.
+// Build don't link:
+// prms-id: 3060
+
+class Foo
+{
+ public:
+  int x;
+  int y;
+  Foo (int i, int j) { x = i; y = j; }
+  operator int ();
+};
+
+int Foo::operator int() { return x; } // WARNING - can't specify return type
+
+Foo foo(10, 11);
+
+int
+main()
+{
+  int Foo::* pmi = &Foo::y;
+  return foo.*pmi;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3060d.C b/gcc/testsuite/g++.old-deja/g++.mike/p3060d.C
new file mode 100644
index 00000000000..2813d66c871
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3060d.C
@@ -0,0 +1,34 @@
+// This is a test case to make sure the explicit cast on a pointer to
+// a member function works ok.
+// prms-id: 3060
+
+extern "C" int printf(const char *, ...);
+
+class Object;
+
+typedef void (Object::*VoidObjMemberFunc)(Object *, ...);
+
+class Object {
+public:
+  int         foo;
+};
+
+class Clipper: public Object {
+public:
+  int         bar;
+  void        Feedback(Object*, void*);
+};
+void Clipper::Feedback(Object *tracker, void *ap) {
+  printf("Doing feedback\n");
+}
+
+void vfunc(VoidObjMemberFunc of, Object *op, void *v1) {
+  (op->*of)(op, v1);
+}
+
+main() {
+  Object      o;
+
+  vfunc((VoidObjMemberFunc)&Clipper::Feedback, &o, 0);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3068.C b/gcc/testsuite/g++.old-deja/g++.mike/p3068.C
new file mode 100644
index 00000000000..52c5cd56de3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3068.C
@@ -0,0 +1,60 @@
+// prms-id: 3068
+
+extern "C" int printf(const char *, ...);
+extern "C" void exit(int);
+ 
+class LB {
+public:
+  virtual int test() { return 0; }
+  virtual ~LB() { }
+protected:
+  LB() { }
+};
+
+class RRB {
+public:
+  virtual ~RRB() { }
+  virtual void test2(int a) { }
+};
+
+class RR : public RRB {
+public:
+    virtual ~RR() { }
+};
+
+class RL {
+public:
+  virtual void real(int a) {
+    printf("RL::real\n");
+  }
+};
+
+
+class R : public RL, public RR {
+public:
+  virtual void test3(int a) { }
+  virtual void test2(int a) { }
+};
+
+class L : public LB {
+};
+
+class C : public L, public R {
+public:
+  C() { }
+  virtual ~C() {
+    printf("C::~C\n");
+    exit(1);
+  }
+  virtual void real(int a) {
+    printf("RL::real\n");
+  }
+};
+
+main() {
+    C& bb = *new C;
+    R& mv = bb;
+    bb.real(0);
+    mv.real(0);
+    return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3070.C b/gcc/testsuite/g++.old-deja/g++.mike/p3070.C
new file mode 100644
index 00000000000..c9278736d2c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3070.C
@@ -0,0 +1,32 @@
+// Build don't link:
+// Caused an Internal Compiler Error.  Works now.
+// prms-id: 3070
+
+class Object {
+public:
+  virtual ~Object() {}
+};
+
+class BaseView {
+protected:
+  virtual void _forwardReceiveUpdate() = 0;
+};
+
+
+class View : public BaseView {
+public:
+  virtual ~View();
+};
+
+class TestViewBaseUpdate {
+protected:
+  virtual void _receiveUpdate();
+};
+
+class TestViewBase : public TestViewBaseUpdate, private View {
+};
+
+class TestView : public Object, public TestViewBase {
+protected:
+  virtual void _receiveUpdate();
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3139.C b/gcc/testsuite/g++.old-deja/g++.mike/p3139.C
new file mode 100644
index 00000000000..9ff9b23cfa5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3139.C
@@ -0,0 +1,25 @@
+// prms-id: 3139
+
+extern "C" int printf(const char *, ...);
+
+class A {
+  public:
+  A() { }
+  virtual int a() = 0;
+};
+
+class B : virtual public A {
+  public:
+  virtual int a() = 0;
+};
+
+class C : public B {
+  public:
+  int a() { return 42; }
+};
+
+main() {
+  B * b = new C;
+  printf("%d.\n", b->a());
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3524a.C b/gcc/testsuite/g++.old-deja/g++.mike/p3524a.C
new file mode 100644
index 00000000000..0995f3530a8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3524a.C
@@ -0,0 +1,25 @@
+// Make sure we can initialize a reference to a templated type, that
+// requires a conversion from a derived type to a base type.
+
+// Build don't link:
+// prms-id: 3524
+
+struct cc2Vector
+{};
+
+template <class T>
+struct ccPair
+{
+    ccPair (const cc2Vector&);
+};
+
+struct ccLine  : cc2Vector
+{
+    double distToPoint  (const ccPair <float> &);
+};
+
+void foo ()
+{
+    ccLine l2;
+    l2.distToPoint (l2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3524b.C b/gcc/testsuite/g++.old-deja/g++.mike/p3524b.C
new file mode 100644
index 00000000000..c645d4cdea4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3524b.C
@@ -0,0 +1,21 @@
+// Make sure we can cast to a templated type, that requires a conversion by
+// constructor, from a derived type to a base type.
+
+// Build don't link:
+// prms-id: 3524
+
+template <class T>
+struct ccPair {
+    ccPair () { }
+};
+
+template <class T>
+struct ccO : ccPair<T> {
+  ccO () { }
+};
+
+void foo ()
+{
+  ccO<float> r;
+  (ccPair<float>)r;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3524c.C b/gcc/testsuite/g++.old-deja/g++.mike/p3524c.C
new file mode 100644
index 00000000000..d901e19a265
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3524c.C
@@ -0,0 +1,15 @@
+// Make sure we can cast to a templated type, that requires a conversion by
+// constructor, from a non-aggregate type.
+
+// Build don't link:
+// prms-id: 3524
+
+template <class T>
+struct ccPair {
+    ccPair (int i) { }
+};
+
+void foo ()
+{
+  (ccPair<float>)1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3538a.C b/gcc/testsuite/g++.old-deja/g++.mike/p3538a.C
new file mode 100644
index 00000000000..ea1a6cc53a7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3538a.C
@@ -0,0 +1,33 @@
+// Build don't link:
+// This tests for the compiler_error in binfo_value.
+// prms-id: 3538
+
+class ccObjectInfo
+{
+public:
+    virtual const ccObjectInfo& repInvariant (int);
+};
+
+template<class T>
+class ccHandle : public  ccObjectInfo
+{
+protected:
+  T* p;
+public:
+  virtual const ccObjectInfo& repInvariant (int);
+};
+
+template <class T>
+const ccObjectInfo& ccHandle<T>::repInvariant (int)
+{ return p->ri(1); }
+
+class ccHandleBase : public ccObjectInfo
+{};
+
+class cc_CircleHdl : public virtual ccHandleBase, public ccObjectInfo
+{
+public:
+  virtual const ccObjectInfo& ri (int);
+};				// WARNING - 
+
+class ccCircleHdl : public ccHandle <cc_CircleHdl> {};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3538b.C b/gcc/testsuite/g++.old-deja/g++.mike/p3538b.C
new file mode 100644
index 00000000000..4dcd60b3d10
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3538b.C
@@ -0,0 +1,35 @@
+// Build don't link:
+// prms-id: 3538
+
+// This tests for an ambiguous conversion of the this pointer (going
+// down to DECL_CONTEXT of a FUNCTION_DECL.
+
+class ccObjectInfo
+{
+public:
+    virtual const ccObjectInfo& repInvariant (int);
+};
+
+template<class T>
+class ccHandle : public  ccObjectInfo
+{
+protected:
+  T* p;
+public:
+  virtual const ccObjectInfo& repInvariant (int);
+};
+
+template <class T>
+const ccObjectInfo& ccHandle<T>::repInvariant (int)
+{ return p->repInvariant(1); }
+
+class ccHandleBase : public ccObjectInfo
+{};
+
+class cc_CircleHdl : public virtual ccHandleBase, public ccObjectInfo
+{
+public:
+  virtual const ccObjectInfo& repInvariant (int);
+};				// WARNING - 
+
+class ccCircleHdl : public ccHandle <cc_CircleHdl> {};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3570.C b/gcc/testsuite/g++.old-deja/g++.mike/p3570.C
new file mode 100644
index 00000000000..abccf793cb6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3570.C
@@ -0,0 +1,29 @@
+// prms-id: 3570
+
+extern "C" int printf(const char *, ...);
+
+struct A {
+   void print() {printf("A");};
+};
+
+struct B :  A {
+   typedef A superB;
+   void print() {superB::print(); printf("B");};
+};
+
+struct C :  B {
+   typedef B superC;
+   void print() {superC::print(); printf("C");};
+};
+
+main ()
+{
+   A a;
+   B b;
+   C c;
+
+   a.print(); printf("\n");
+   b.print(); printf("\n");
+   c.print(); printf("\n");
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3579.C b/gcc/testsuite/g++.old-deja/g++.mike/p3579.C
new file mode 100644
index 00000000000..d960599450f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3579.C
@@ -0,0 +1,39 @@
+// prms-id: 3579
+
+extern "C" int printf(const char *, ...);
+
+int num_x;
+
+class Y {
+public:
+  Y () { printf("Y()            this: %x\n", this); }
+  ~Y () { printf("~Y()           this: %x\n", this); }
+};
+
+class X {
+public:
+  X () {
+    ++num_x;
+    printf("X()            this: %x\n", this);
+    Y y;
+    *this = (X) y;
+  }
+
+  X (const Y & yy) { printf("X(const Y&)    this: %x\n", this); ++num_x; }
+  X & operator = (const X & xx) {
+    printf("X.op=(X&)      this: %x\n", this);
+    return *this;
+  }
+
+  ~X () { printf("~X()           this: %x\n", this); --num_x; }
+};
+
+int main (int, char **) {
+    { X anX; }
+    if (num_x) {
+      printf("FAIL\n");
+      return 1;
+    }
+    printf("PASS\n");
+    return 0;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3708.C b/gcc/testsuite/g++.old-deja/g++.mike/p3708.C
new file mode 100644
index 00000000000..2f5e401e56d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3708.C
@@ -0,0 +1,86 @@
+// prms-id: 3708
+
+extern "C" void printf (char *, ...);
+extern "C" int atoi (char *);
+
+void *ptr;
+
+class A {
+public:
+  A() { printf ("A is constructed.\n"); }
+  virtual xx(int doit) { printf ("A is destructed.\n"); }
+};
+
+class A1 {
+public:
+  A1() { printf ("A1 is constructed.\n"); }
+  virtual xx(int doit) { printf ("A1 is destructed.\n"); }
+};
+
+class B : public virtual A, public A1 {
+public:
+  B() { printf ("B is constructed.\n"); }
+  virtual xx(int doit) {
+    printf ("B is destructed.\n");
+    A1::xx (1);
+    if (doit) A::xx (1);
+  }
+};
+
+int num;
+
+class C : public virtual A, public B {
+public:
+  C() { ++num; printf ("C is constructed.\n");
+      ptr = this;
+      }
+  virtual xx(int doit) {
+    --num;
+    if (ptr != this)
+      printf("FAIL\n%x != %x\n", ptr, this);
+    printf ("C is destructed.\n");
+    B::xx (0);
+    if (doit) A::xx (1);
+  }
+};
+
+void fooA(A *a) {
+  printf ("Casting to A!\n");
+  a->xx (1);
+}
+void fooA1(A1 *a) {
+  printf ("Casting to A1!\n");
+  a->xx (1);
+}
+
+void fooB(B *b) {
+  printf ("Casting to B!\n");
+  b->xx (1);
+}
+
+void fooC(C *c) {
+  printf ("Casting to C!\n");
+  c->xx (1);
+}
+
+int main(int argc, char *argv[]) {
+  printf ("*** Construct C object!\n");
+  C *c = new C();
+
+  int i = 0;
+
+  printf ("*** Try to delete the casting pointer!\n");
+  switch (i)
+    {
+    case 0: fooA1(c);
+      break;
+    case 1: fooA(c);
+      break;
+    case 2: fooB(c);
+      break;
+    case 3: fooC(c);
+      break;
+    }
+
+  return num!=0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3708a.C b/gcc/testsuite/g++.old-deja/g++.mike/p3708a.C
new file mode 100644
index 00000000000..1fecb16be36
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3708a.C
@@ -0,0 +1,86 @@
+// prms-id: 3708
+
+extern "C" void printf (char *, ...);
+extern "C" int atoi (char *);
+
+void *ptr;
+
+class A {
+public:
+  A() { printf ("A is constructed.\n"); }
+  virtual xx(int doit) { printf ("A is destructed.\n"); }
+};
+
+class A1 {
+public:
+  A1() { printf ("A1 is constructed.\n"); }
+  virtual xx(int doit) { printf ("A1 is destructed.\n"); }
+};
+
+class B :  public A1, public virtual A {
+public:
+  B() { printf ("B is constructed.\n"); }
+  virtual xx(int doit) {
+    printf ("B is destructed.\n");
+    A1::xx (1);
+    if (doit) A::xx (1);
+  }
+};
+
+int num;
+
+class C : public virtual A, public B {
+public:
+  C() { ++num; printf ("C is constructed.\n");
+      ptr = this;
+      }
+  virtual xx(int doit) {
+    --num;
+    if (ptr != this)
+      printf("FAIL\n%x != %x\n", ptr, this);
+    printf ("C is destructed.\n");
+    B::xx (0);
+    if (doit) A::xx (1);
+  }
+};
+
+void fooA(A *a) {
+  printf ("Casting to A!\n");
+  a->xx (1);
+}
+void fooA1(A1 *a) {
+  printf ("Casting to A1!\n");
+  a->xx (1);
+}
+
+void fooB(B *b) {
+  printf ("Casting to B!\n");
+  b->xx (1);
+}
+
+void fooC(C *c) {
+  printf ("Casting to C!\n");
+  c->xx (1);
+}
+
+int main(int argc, char *argv[]) {
+  printf ("*** Construct C object!\n");
+  C *c = new C();
+
+  int i = 0;
+
+  printf ("*** Try to delete the casting pointer!\n");
+  switch (i)
+    {
+    case 0: fooA1(c);
+      break;
+    case 1: fooA(c);
+      break;
+    case 2: fooB(c);
+      break;
+    case 3: fooC(c);
+      break;
+    }
+
+  return num!=0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3708b.C b/gcc/testsuite/g++.old-deja/g++.mike/p3708b.C
new file mode 100644
index 00000000000..dddb77c2e51
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3708b.C
@@ -0,0 +1,85 @@
+// prms-id: 3708
+
+extern "C" void printf (char *, ...);
+extern "C" void exit(int);
+
+void *ptr;
+
+class A {
+public:
+  A() { printf ("A is constructed.\n"); }
+  virtual xx(int doit) { printf ("A is destructed.\n"); }
+};
+
+class A1 {
+public:
+  A1() { printf ("A1 is constructed.\n"); }
+  virtual xx(int doit) { printf ("A1 is destructed.\n"); }
+};
+
+class B : public virtual A, public A1 {
+public:
+  B() { printf ("B is constructed.\n"); }
+  virtual xx(int doit) {
+    printf ("B is destructed.\n");
+    A1::xx (1);
+    if (doit) A::xx (1);
+  }
+};
+
+int num;
+
+class C : public virtual A {
+public:
+  C() { printf ("C is constructed.\n");
+      }
+  virtual xx(int doit) {
+    printf ("C is destructed.\n");
+    if (doit) A::xx (1);
+  }
+};
+
+class D : public C, public B {
+public:
+  D() { ++num; printf ("D is constructed.\n");
+      ptr = this;
+      }
+  virtual xx(int doit) {
+    --num;
+    if (ptr != this) {
+      printf("FAIL\n%x != %x\n", ptr, this);
+      exit(1);
+    }
+    printf ("D is destructed.\n");
+    C::xx (0);
+    B::xx (0);
+  }
+};
+
+void fooA(A *a) {
+  printf ("Casting to A!\n");
+  a->xx (1);
+}
+void fooA1(A1 *a) {
+  printf ("Casting to A1!\n");
+  a->xx (1);
+}
+
+void fooB(B *b) {
+  printf ("Casting to B!\n");
+  b->xx (1);
+}
+
+void fooC(C *c) {
+  printf ("Casting to C!\n");
+  c->xx (1);
+}
+
+int main(int argc, char *argv[]) {
+  printf ("*** Construct D object!\n");
+  D *d = new D();
+
+  printf ("*** Try to delete the casting pointer!\n");
+  fooA1(d);
+  return num!=0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3764.C b/gcc/testsuite/g++.old-deja/g++.mike/p3764.C
new file mode 100644
index 00000000000..d0527555563
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3764.C
@@ -0,0 +1,25 @@
+// Build don't link:
+// prms-id: 3764
+
+class Menu;
+class MenuItem;
+
+class  MenuAction {
+public:
+  virtual void execute (Menu& menu, MenuItem& menuItem)  = 0;
+protected:
+  MenuAction () {}
+}; 
+
+class Test {
+  class MenuCBA : public MenuAction {
+  public:
+    typedef void (Test::* MenuCBA_Member) (Menu& menu, MenuItem& menuItem) ;
+    MenuCBA(Test& instance, MenuCBA_Member member)
+      : _instance(&instance), _member(member) { }
+    void execute(Menu& menu, MenuItem& menuItem);
+  private:
+    MenuCBA_Member _member;
+    Test *_instance;
+  };  
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p3836.C b/gcc/testsuite/g++.old-deja/g++.mike/p3836.C
new file mode 100644
index 00000000000..c62530f6906
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p3836.C
@@ -0,0 +1,14 @@
+// prms-id: 3836
+
+void f(int &i) {	// ERROR - ref line
+  i = 10;
+}
+
+int main()
+{
+  int i=1, j=2;
+  f(i);
+  f((int)j);		// ERROR - passing in to non-const
+  if (j != 2)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4068.C b/gcc/testsuite/g++.old-deja/g++.mike/p4068.C
new file mode 100644
index 00000000000..e2531ed81fe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4068.C
@@ -0,0 +1,22 @@
+// prms-id: 4068
+
+struct A {
+  A();
+  typedef void (A::*F)();
+  void d();
+  void foo() { }
+  F& f() { return f_; }
+  F f_;
+};
+
+A::A() : f_(&A::foo) {
+}
+
+void A::d() {
+  (this->*(f()))();
+}
+
+main() {
+  A a;
+  a.d();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4104.C b/gcc/testsuite/g++.old-deja/g++.mike/p4104.C
new file mode 100644
index 00000000000..7559034779a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4104.C
@@ -0,0 +1,15 @@
+// prms-id: 4104
+
+template <class T>
+void F(T &a, void (*P)(T &temp)) {
+  (*P)(a);
+}
+
+template <class T>
+void G(T &a) {
+}
+
+int main() {
+  int a;
+  F(a, G);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4173.C b/gcc/testsuite/g++.old-deja/g++.mike/p4173.C
new file mode 100644
index 00000000000..a5b11f226d2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4173.C
@@ -0,0 +1,24 @@
+// This error happens because lvalue is not done well in the C++ front-end.
+// NOPs should be lvalues if their arguments are.
+// NON_LVALUE_EXPRs shouldn't be.
+
+// Special g++ Options: -Wall -ansi -pedantic-errors
+// Build don't link:
+// prms-id: 4173
+
+enum TypeKind {
+    RecordTypeKind
+};
+struct Type
+{
+    enum TypeKind kind : 8;
+    unsigned char prefixLen;  
+};
+
+Type a;
+Type b;
+TypeKind c;
+main() {
+  a.kind = b.kind = c;
+  (a.kind = c) = b.kind;	// gets bogus error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p418.C b/gcc/testsuite/g++.old-deja/g++.mike/p418.C
new file mode 100644
index 00000000000..6e868c7ec0d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p418.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// prms-id: 418
+
+class Base {
+public:
+	int foo;
+};
+
+class Derived : public Base {
+public:
+	int bar;
+};
+
+void func(Base&);		// ERROR - referenced by error below
+
+void func2(const Derived& d) {
+	func(d);		// ERROR - should be error because of const
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4238.C b/gcc/testsuite/g++.old-deja/g++.mike/p4238.C
new file mode 100644
index 00000000000..2499a6d4015
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4238.C
@@ -0,0 +1,7 @@
+// This showed a problem with default op=
+// Build don't link:
+// prms-id: 4238
+
+struct sigcontext {
+  int sc_wbuf[31][25];
+};		// gets bogus error - default op= seems broken
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4246.C b/gcc/testsuite/g++.old-deja/g++.mike/p4246.C
new file mode 100644
index 00000000000..1eb6668e969
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4246.C
@@ -0,0 +1,48 @@
+// prms-id: 4246
+
+extern "C" void abort ();
+int num_d;
+
+class A
+{
+ public:
+  A() { }
+  virtual  ~A() { }
+  virtual  id() { }
+};
+
+class B
+{
+ public:
+  B() { }
+  virtual  ~B() { }
+  virtual  id() { }
+};
+
+class C : public A, public B
+{
+ public:
+  C() { }
+  virtual  ~C() { }
+  id() { abort(); }
+};
+
+class D : public C
+{
+ public:
+  D() { ++num_d; }
+  virtual  ~D() { -- num_d; }
+  id() { }
+};
+
+main()
+{
+  D* dp2 = new D;
+  ((B*)dp2)->id();
+  delete (B*) dp2;
+
+  B* bp1 = new D;
+  bp1->id();
+  delete bp1;
+  return num_d != 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4263.C b/gcc/testsuite/g++.old-deja/g++.mike/p4263.C
new file mode 100644
index 00000000000..65d5150c751
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4263.C
@@ -0,0 +1,14 @@
+// prms-id: 4263
+
+enum OT {A_type, B_Type};
+enum AT {A, B};
+
+/* These are not ok. */
+OT t = A;	// ERROR - 
+OT e2 = 1;	// ERROR - 
+OT e3 = 1.1;	// ERROR - 
+
+/* These are ok. */
+int i = A;
+double d = A;
+OT e4 = A_type;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p438.C b/gcc/testsuite/g++.old-deja/g++.mike/p438.C
new file mode 100644
index 00000000000..9afab638abc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p438.C
@@ -0,0 +1,23 @@
+// Build don't link:
+// prms-id: 438
+
+class D;
+
+class C
+{
+   public:
+   void test() const;
+};
+
+class D
+{
+   public:
+   void a(C& b); // ERROR - referenced below
+};
+
+void C::test() const
+{
+   D d;
+
+   d.a(*this);	// ERROR - *this is const, so should get error
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4484.C b/gcc/testsuite/g++.old-deja/g++.mike/p4484.C
new file mode 100644
index 00000000000..64aab160965
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4484.C
@@ -0,0 +1,26 @@
+// Build don't link:
+// prms-id: 4484
+
+class A {
+  char buf[64];
+};
+
+typedef void (A::*pmf)();
+typedef void (A::*pmfc)() const;
+
+pmfc p = (pmfc)(pmf)0;
+
+class B {
+};
+
+class D : public A, public B {
+};
+
+typedef int (B::*bmfp)();
+typedef int (D::*dmfp)();
+
+bmfp foo;
+
+void bar(dmfp a) {
+  bar(foo);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4511.C b/gcc/testsuite/g++.old-deja/g++.mike/p4511.C
new file mode 100644
index 00000000000..a3c83105bb9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4511.C
@@ -0,0 +1,33 @@
+// prms-id: 4511
+
+int bad;
+
+class A {
+public:
+  virtual void dummy (){};
+};
+
+class B {
+public:
+  virtual void f(void) = 0;
+};
+
+class C : public A, public B {
+public:
+  void f(void) { bad=1; };
+};
+
+class D : public C {
+public:
+  void f(void) { };
+};
+
+class E : public D { };
+
+main() {
+  E e;
+  e.f();
+  E * ep = &e;
+  ep->f();
+  return bad;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4619.C b/gcc/testsuite/g++.old-deja/g++.mike/p4619.C
new file mode 100644
index 00000000000..b401d7dda17
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4619.C
@@ -0,0 +1,10 @@
+// Build don't link:
+// prms-id: 4619
+
+main() {
+  int i = 3;
+  int (*p)[10] = new int [20][10];
+  int (*p1)[5][7][13][10] = new int [i][5][7][13][10];
+  delete [] p1;
+  delete [] p;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4623.C b/gcc/testsuite/g++.old-deja/g++.mike/p4623.C
new file mode 100644
index 00000000000..c96388de6d2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4623.C
@@ -0,0 +1,35 @@
+// prms-id: 4623
+
+class base {
+public:
+  int b_data;
+  base( int i=0 ) { b_data = i; }
+  void b_print() { }
+};
+
+class base1: virtual public base {
+public:
+  int b1_data;
+  base1( int i = 0 ) { b1_data = i; b_data++; }
+  void b1_print() { }
+};
+
+class base2: virtual public base {
+public:
+  int b2_data;
+  base2( int i = 0 ) { b2_data = i; b_data++; }
+  void b2_print() { }
+};
+
+class base3: public base {};
+
+class derived: public base3, public base1, public base2 {
+public:
+  int d_data;
+  derived( int i ) { d_data = i; base3::b_data++; }
+  void d_print() { }
+};
+
+main() {
+  derived d(1); d.d_print(); return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4667.C b/gcc/testsuite/g++.old-deja/g++.mike/p4667.C
new file mode 100644
index 00000000000..751a5666103
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4667.C
@@ -0,0 +1,31 @@
+// prms-id: 4667
+
+int counter = 0;
+int a = 0;
+int b = 0;
+int c = 0;
+
+struct A {
+  A() { a = counter++; }
+};
+
+struct B {
+  B() { b = counter++; }
+};
+
+struct C : public virtual B {
+  C() { c = counter++; }
+};
+
+struct D : public virtual A, public virtual C { };
+
+extern "C" int printf(const char*,...);
+int main(void) {
+  D d;
+
+  if (!(a == 0 && b == 1 && c == 2)) {
+    return 1;
+  }
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4671.C b/gcc/testsuite/g++.old-deja/g++.mike/p4671.C
new file mode 100644
index 00000000000..68f3ee16c0c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4671.C
@@ -0,0 +1,16 @@
+// Build don't link:
+// prms-id: 4671
+
+class ccUnwind {
+public:
+  virtual void _c_getInfo() const;
+  virtual ~ccUnwind ();
+};
+class ccTransmittable {
+public:
+  virtual ~ccTransmittable();
+};
+class ccCommand : public ccUnwind, public ccTransmittable {
+};
+class foo : public ccCommand {
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4677.C b/gcc/testsuite/g++.old-deja/g++.mike/p4677.C
new file mode 100644
index 00000000000..463033caec3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4677.C
@@ -0,0 +1,9 @@
+// Build don't link:
+// prms-id: 4677
+
+struct A {
+  A(double d) { }
+};
+
+struct B { B(A) { } } bad = 1;		// ERROR - 
+B good (1);
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4693.C b/gcc/testsuite/g++.old-deja/g++.mike/p4693.C
new file mode 100644
index 00000000000..09e1333933e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4693.C
@@ -0,0 +1,24 @@
+// Build don't link:
+// prms-id: 4693
+
+class a {
+public:
+  virtual ~a();
+};
+
+class b {
+public:
+  virtual void set_var() = 0;
+};
+
+class c : public b, public a { };
+
+class d : public c {
+public:
+  void set_var() { }
+};
+
+main() {
+  d * test;
+  test = new d;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4736a.C b/gcc/testsuite/g++.old-deja/g++.mike/p4736a.C
new file mode 100644
index 00000000000..a6e3aef88e7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4736a.C
@@ -0,0 +1,39 @@
+// prms-id: 4736
+
+int did_fail = 1;
+
+class O {
+public:
+  virtual void of() { }
+};
+
+class A : public O {
+public:
+  virtual void vf() { }
+};
+
+class W {
+public:
+  virtual void vf() { }
+};
+
+class X : public W, public A {
+public:
+  virtual void vf() { }
+};
+
+class Z : public X {
+public:
+  virtual void vf() { did_fail = 0; }
+};
+
+Z sz;
+
+void fail1(W* w) {
+  w->vf();
+}
+
+int main() {
+  fail1 (&sz);
+  return did_fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4736b.C b/gcc/testsuite/g++.old-deja/g++.mike/p4736b.C
new file mode 100644
index 00000000000..19d655c6f09
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4736b.C
@@ -0,0 +1,48 @@
+// prms-id: 4736
+
+class Rep {
+public:
+  virtual int foo() { return 1; }
+};
+
+class Rep_1 : public Rep {
+};
+
+class VBaseMain {
+public:
+  virtual int foo() { return 2; }
+};
+
+class OtherVBase {
+public:
+  virtual int foo() { return 3; }
+};
+
+class Rep_2 : public Rep {
+};
+
+class DVBase : public VBaseMain, public Rep_2, public OtherVBase {
+public:
+  virtual int foo() { return 4; }
+};
+
+class Main : public Rep_1, virtual public DVBase {
+public:
+  virtual int foo() { return 5; }
+};
+
+main() {
+  Main m;
+  if (m.foo() != 5)
+    return 1;
+  if (((Rep*)(Rep_1*)&m)->foo() != 5)
+    return 2;
+  if (((DVBase*)&m)->foo() != 5)
+    return 3;
+  if (((VBaseMain*)(DVBase*)&m)->foo() != 5)
+    return 4;
+  if (((Rep*)(Rep_2*)(DVBase*)&m)->foo() != 5)
+    return 5;
+  if (((OtherVBase*)(DVBase*)&m)->foo() != 5)
+    return 6;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4736c.C b/gcc/testsuite/g++.old-deja/g++.mike/p4736c.C
new file mode 100644
index 00000000000..de5e4b6962c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4736c.C
@@ -0,0 +1,62 @@
+// prms-id: 4736
+
+int did_fail;
+
+class Rep {
+public:
+  virtual ~Rep() { }
+};
+
+class Rep_1 : public Rep {
+};
+
+class VBaseMain {
+public:
+  virtual ~VBaseMain() { }
+};
+
+class OtherVBase {
+public:
+  virtual ~OtherVBase() { }
+};
+
+class Rep_2 : public Rep {
+};
+
+class DVBase : public VBaseMain, public Rep_2, public OtherVBase {
+public:
+  virtual ~DVBase() { }
+};
+
+class Main : public Rep_1, virtual public DVBase {
+public:
+  virtual ~Main() { did_fail = 0; }
+};
+
+main() {
+  Main* m;
+  did_fail = 1;
+  delete new Main;
+  if (did_fail)
+    return 1;
+  did_fail = 1;
+  delete (Rep*)(Rep_1*)new Main;
+  if (did_fail)
+    return 2;
+  did_fail = 1;
+  delete (DVBase*)new Main;
+  if (did_fail)
+    return 3;
+  did_fail = 1;
+  delete (VBaseMain*)(DVBase*)new Main;
+  if (did_fail)
+    return 4;
+  did_fail = 1;
+  delete (Rep*)(Rep_2*)(DVBase*)new Main;
+  if (did_fail)
+    return 5;
+  did_fail = 1;
+  delete (OtherVBase*)(DVBase*)new Main;
+  if (did_fail)
+    return 6;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p4750.C b/gcc/testsuite/g++.old-deja/g++.mike/p4750.C
new file mode 100644
index 00000000000..b404cc05ff4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p4750.C
@@ -0,0 +1,11 @@
+// Build don't link:
+// Skip if not native
+// Special g++ Options: -fpic -pedantic-errors -S
+// prms-id: 4750
+
+extern const int FRAME_VEC_MAX;
+
+const int FRAME_VEC_MAX     = 12;
+int frame_vec_sizes[FRAME_VEC_MAX+1] = {
+        0, 1, 3, 3, 6, 6, 6, 9, 9, 9, 12, 12, 12
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5469.C b/gcc/testsuite/g++.old-deja/g++.mike/p5469.C
new file mode 100644
index 00000000000..3f5029dc3ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5469.C
@@ -0,0 +1,21 @@
+// prms-id: 5469
+
+int count;
+
+class A {
+  A();
+  A(const A&);
+public:
+  A(int) { ++count; }
+  ~A() { --count; }
+  int operator== (const A& r) { return 0; }
+};
+
+main() {
+  {
+    A a (1);
+    if (a == 2 && a == 1)
+      ;
+  }
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5469a.C b/gcc/testsuite/g++.old-deja/g++.mike/p5469a.C
new file mode 100644
index 00000000000..efcd2f4b652
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5469a.C
@@ -0,0 +1,21 @@
+// prms-id: 5469
+
+int count;
+
+class A {
+  A();
+  A(const A&);
+public:
+  A(int) { ++count; }
+  ~A() { --count; }
+  int operator== (const A& r) { return 1; }
+};
+
+main() {
+  {
+    A a (1);
+    if (a == 2 || a == 1)
+      ;
+  }
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5571.C b/gcc/testsuite/g++.old-deja/g++.mike/p5571.C
new file mode 100644
index 00000000000..d9a3a471dd8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5571.C
@@ -0,0 +1,70 @@
+// prms-id: 5571
+
+int err = 0;
+void *vp = 0;
+
+class ParentOne {
+public:
+  ParentOne() {};
+#ifdef MAKE_WORK
+  virtual ~ParentOne() {};
+#endif
+private:
+  char SomeData[101];
+};
+
+class ParentTwo {
+public:
+  ParentTwo() {};
+  virtual ~ParentTwo() {};
+private:
+  int MoreData[12];
+  virtual foo() { return 0; }
+};
+
+struct Child : public ParentOne, public ParentTwo {
+    int ChildsToy;
+    virtual void PrintThis() = 0;
+};
+
+struct Student : public Child {
+  int StudentsBook;
+  void PrintThis() {
+    if (vp == 0)
+      vp = (void *)this;
+    else
+      {
+	if (vp != (void *)this)
+	  ++err;
+      }
+  }
+  void LocalPrintThis() {
+    if (vp == 0)
+      vp = (void *)this;
+    else
+      {
+	if (vp != (void *)this)
+	  ++err;
+      }
+    PrintThis();
+  }
+  void ForcedPrintThis() {
+    if (vp == 0)
+      vp = (void *)this;
+    else
+      {
+	if (vp != (void *)this)
+	  ++err;
+      }
+    Student::PrintThis();
+  }
+};
+
+main() {
+  Student  o;
+  o.LocalPrintThis();
+  o.ForcedPrintThis();
+  Child* pX = &o;
+  pX->PrintThis();
+  return err;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5611.C b/gcc/testsuite/g++.old-deja/g++.mike/p5611.C
new file mode 100644
index 00000000000..557d2cc2baf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5611.C
@@ -0,0 +1,11 @@
+// prms-id: 5611
+
+int main(void)
+{
+  struct B
+    {
+      virtual void b1() { };
+    };
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5673.C b/gcc/testsuite/g++.old-deja/g++.mike/p5673.C
new file mode 100644
index 00000000000..8d29191861e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5673.C
@@ -0,0 +1,20 @@
+// prms-id: 5673
+
+class A {
+public:
+  operator int () {
+    return 7;
+  }
+  ~A();
+};
+
+int foo() {
+  return A();
+}
+
+main() {
+  return foo() != 7;
+}
+
+A::~A() {
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5718.C b/gcc/testsuite/g++.old-deja/g++.mike/p5718.C
new file mode 100644
index 00000000000..8858d389ef7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5718.C
@@ -0,0 +1,37 @@
+// prms-id: 5718
+
+class Base {
+  int i;
+public:
+  Base() { i = 42; };
+};
+
+
+class Mixin {
+  int j;
+public:
+  Mixin() { j = 42; }
+};
+
+
+class Derived : public Base, public Mixin {
+public:
+  Derived() { };
+  Derived & operator=(Mixin & m) { return *this; };
+};
+
+
+void
+testFunct(Derived * arg) {
+  Mixin temp;
+
+  (Mixin &)(*arg) = temp;		// gets bogus error 
+}
+
+
+int
+main(int argc, char *argv[]) {
+  Derived temp;
+
+  testFunct(&temp);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5793.C b/gcc/testsuite/g++.old-deja/g++.mike/p5793.C
new file mode 100644
index 00000000000..53469cdf07a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5793.C
@@ -0,0 +1,21 @@
+// Build don't link:
+// prms-id: 5793
+
+class temp_string {
+ public:
+  temp_string (const int);
+  temp_string (const char * const);
+};
+
+class Range { 
+ public:
+  Range ( const int);
+  operator int () const ;
+};
+
+int operator == (const int, temp_string );
+
+void CheckArrayConstraints(void)    { 
+  if (Range(0L) == 0L)
+    ;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5840.C b/gcc/testsuite/g++.old-deja/g++.mike/p5840.C
new file mode 100644
index 00000000000..46a161beec8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5840.C
@@ -0,0 +1,33 @@
+// prms-id: 5840
+
+class Signal {
+public:
+  int Name(void) { return 1; }
+};
+
+class Derived : public Signal {
+public:
+  int Name(void) { return 2; }
+};
+
+template <class Foo , int (Foo::*Id)(void)>
+class Bar
+{
+public:
+  int value (Foo* a) { return (a->*Id)(); }
+};
+
+template class Bar <Derived, &Signal::Name>;
+template class Bar <Signal, &Signal::Name>;
+template class Bar <Derived, &Derived::Name>;
+
+Derived a;
+
+Bar<Derived, &Signal::Name> dispatcher1;
+Bar<Derived, &Derived::Name> dispatcher2;
+
+main() {
+  int i1 = dispatcher1.value(&a);
+  int i2 = dispatcher2.value(&a);
+  return i1 != 1 || i2 != 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p5958.C b/gcc/testsuite/g++.old-deja/g++.mike/p5958.C
new file mode 100644
index 00000000000..20d45f264d0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p5958.C
@@ -0,0 +1,27 @@
+// Special g++ Options: -ansi
+// prms-id: 5958
+
+class A { };
+
+main() {
+  int i = 1;
+  if (1 not_eq 1)
+    return 1;
+  if (not (1 and 1))
+    return 1;
+  if (not (1 or 1))
+    return 1;
+  if (compl ~0)
+    return 1;
+  if (1 bitand 2)
+    return 1;
+  if (not (1 bitor 2))
+    return 1;
+  if (1 xor 1)
+    return 1;
+  i and_eq 1;
+  i or_eq 2;
+  i xor_eq 4;
+  if (i not_eq 7)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6004.C b/gcc/testsuite/g++.old-deja/g++.mike/p6004.C
new file mode 100644
index 00000000000..b692365b12e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6004.C
@@ -0,0 +1,20 @@
+// Special g++ Options: 
+// prms-id: 6004
+
+class A {
+public:
+  static int foo() asm("_my_routine");
+};
+
+int bar1() asm("foo__1A");
+int bar2() asm("_foo__1A");
+int bar3() asm("__foo__1A");
+int bar1() { return 45; }
+int bar2() { return 44; }
+int bar3() { return 43; }
+
+int A::foo() { return 42; }
+
+main() {
+  return A::foo() - 42;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6058.C b/gcc/testsuite/g++.old-deja/g++.mike/p6058.C
new file mode 100644
index 00000000000..aa78b7ff63d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6058.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// Special g++ Options: -fexceptions -pedantic-errors
+// prms-id: 6058
+
+void bar(struct s1 { } a) { (void)a; }			// ERROR - 
+
+struct s2*fooey()					// ERROR - XFAIL *-*-*
+{
+  try {
+    static_cast<struct s3 { } *>(0);			// ERROR - 
+    const_cast<struct s4 { } *>((s4*)0);		// ERROR - 
+    reinterpret_cast<struct s5 { } *>((s3*)0);		// ERROR - 
+    dynamic_cast<struct s6 { } *>((s6*)0);		// ERROR - 
+    (struct s7 { } *)(int*)0xffedec;			// ERROR - 
+  } catch (struct s8 { } s) {				// ERROR - 
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6149.C b/gcc/testsuite/g++.old-deja/g++.mike/p6149.C
new file mode 100644
index 00000000000..578ee8b643c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6149.C
@@ -0,0 +1,4 @@
+// Build don't link:
+// prms-id: 6149
+
+int a[3 - sizeof(double)];	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6311.C b/gcc/testsuite/g++.old-deja/g++.mike/p6311.C
new file mode 100644
index 00000000000..12d3cfc6169
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6311.C
@@ -0,0 +1,16 @@
+// prms-id: 6311
+
+struct Foo {
+  int member;
+} a = { 42 }, *ptra = &a;
+
+int Foo::*pmd = &Foo::member;
+
+main() {
+  if (pmd == 0)
+    return 1;
+  if (a.*pmd != 42)
+    return 2;
+  if (ptra->*pmd != 42)
+    return 3;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p646.C b/gcc/testsuite/g++.old-deja/g++.mike/p646.C
new file mode 100644
index 00000000000..2644c1b43df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p646.C
@@ -0,0 +1,175 @@
+// GROUPS passed i960
+/*
+  Bug Id: bnr
+  PMRS Id: p0000646
+  Bug is: Urgent Code Generation Problem in gcc-i960 V 1.95
+*/
+
+
+// Special g++ Options: 
+
+extern "C"
+{
+  void printf (char *, ...);
+  void abort ();
+}
+
+struct foo
+{
+  static int si;
+  int i;
+  foo ();
+  foo (const foo&);
+  ~foo ();
+};
+
+int
+foo_parm_returns_i (foo foo_arg)
+{
+  return foo_arg.i;
+}
+
+int foo::si = 0;
+
+foo::foo ()
+{
+  si++;
+  printf ("new foo @ 0x%x; now %d foos\n", this, si);
+}
+
+foo::foo (const foo &other)
+{
+  si++;
+  printf ("another foo @ 0x%x; now %d foos\n", this, si);
+  *this = other;
+}
+
+foo::~foo ()
+{
+  si--;
+  printf ("deleted foo @ 0x%x; now %d foos\n", this, si);
+}
+
+int
+return_1 ()
+{
+  foo f;
+  printf ("returning 1\n");
+  return 1;
+}
+
+int
+return_arg (int arg)
+{
+  foo f;
+  printf ("returning %d\n", arg);
+  return arg;
+}
+
+int
+return_sum (int x, int y)
+{
+  foo f;
+  printf ("returning %d+%d\n", x, y);
+  return x + y;
+}
+
+foo
+return_foo ()
+{
+  foo f;
+  printf ("returning foo\n");
+  return f;
+}
+
+foo
+return_named_foo () return f
+{
+  printf ("returning named foo\n");
+  return f;
+}
+
+foo
+foo_parm_returns_foo (foo f)
+{
+  return f;
+}
+
+void
+abort_because (char *str)
+{
+  printf ("aborting because %s\n", str);
+  abort ();
+}
+
+int
+warn_return_1 ()
+{
+  foo f;
+  printf ("returning 1\n");
+}
+
+int
+warn_return_arg (int arg)
+{
+  foo f;
+  printf ("returning %d\n", arg);
+  arg;
+}
+
+int
+warn_return_sum (int x, int y)
+{
+  foo f;
+  printf ("returning %d+%d\n", x, y);
+  x + y;
+}
+
+foo
+warn_return_foo ()
+{
+  foo f;
+  printf ("returning foo\n");
+}
+
+foo
+nowarn_return_named_foo () return f
+{
+  printf ("returning named foo\n");
+}
+
+foo
+warn_foo_parm_returns_foo (foo f)
+{
+  f;
+}
+
+main ()
+{
+  int ii = return_1 ();
+  if (ii != 1)
+    abort_because ("wrong value returned");
+  int j = return_arg (42);
+  if (j != 42)
+    abort_because ("wrong value returned");
+  int k = return_sum (-69, 69);
+  if (k != 0)
+    abort_because ("wrong value returned");
+  foo f1 = return_named_foo ();
+  if (foo::si != 1)
+    abort_because ("wrong number of foos");
+  f1.i = 5;
+  int l = foo_parm_returns_i (f1);
+  if (l != 5)
+    abort_because ("l != 5");
+  foo f2 = foo_parm_returns_foo (f1);
+  if (foo::si != 2)
+    abort_because ("wrong number of foos");
+  if (f2.i != 5)
+    abort_because ("f2.i != 5");
+  foo f3 = return_foo ();
+  if (foo::si != 3)
+    abort_because ("wrong number of foos");
+  printf("PASS\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6578.C b/gcc/testsuite/g++.old-deja/g++.mike/p6578.C
new file mode 100644
index 00000000000..2b19e86ddfb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6578.C
@@ -0,0 +1,8 @@
+// Build don't link:
+// prms-id: 6578
+
+struct A {
+  operator int ();
+};
+
+int i = A();
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p658.C b/gcc/testsuite/g++.old-deja/g++.mike/p658.C
new file mode 100644
index 00000000000..971619f9214
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p658.C
@@ -0,0 +1,101 @@
+// prms-id: 658
+
+#include <ostream.h>
+#include <bool.h>
+extern "C" void abort();
+
+/* We may not find the libg++ <bool.h>.  */
+#ifndef FALSE
+#define FALSE false
+#endif
+#ifndef TRUE
+#define TRUE true
+#endif
+
+class Object {
+public:
+    Object();
+    Object(const Object&);
+    ~Object();
+
+    void OK() const;
+private:
+    bool _destructed;
+};
+
+class Char: public Object {
+public:
+    Char();
+    Char(char);
+    Char(const Char&);
+    ~Char();
+
+    operator char () const;
+private:
+    char _c;
+};
+
+main()
+{
+    Char r, s;
+
+    r = Char('r');
+    s = Char('s');
+}
+
+//
+// Object stuff
+//
+Object::Object():
+_destructed(FALSE)
+{}
+
+Object::Object(const Object& other):
+_destructed(FALSE)
+{
+    other.OK();
+}
+
+Object::~Object()
+{
+    OK();
+    _destructed = TRUE;
+}
+
+void
+Object::OK() const
+{
+    if (_destructed) {
+	cerr << "FAILURE - reference was made to a destructed object\n";
+	abort();
+    }
+}
+
+//
+// Char stuff
+//
+
+Char::Char():
+Object(),
+_c('a')
+{ }
+
+Char::Char(char c):
+Object(),
+_c(c)
+{ }
+
+Char::Char(const Char& other):
+Object(other),
+_c(other._c)
+{ }
+
+Char::~Char()
+{
+    OK();
+}
+
+Char::operator char () const
+{
+    return _c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6610a.C b/gcc/testsuite/g++.old-deja/g++.mike/p6610a.C
new file mode 100644
index 00000000000..b0b13d47f97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6610a.C
@@ -0,0 +1,13 @@
+// prms-id: 6610
+
+int fail = 1;
+struct B;
+struct A { virtual int f(const B*) = 0; int g(const B*); };
+int A::g(const B* t) { return f(t); }
+struct B : virtual A { B(); int f(const B*); B* B_this; };
+B::B() { if (g(this)) fail = 0; }
+int B::f(const B* t) { return t == this; }
+struct C : B { int f(const B*); int x; };
+int C::f(const B*) { return 0; }
+
+int main() { C c; return fail; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6610b.C b/gcc/testsuite/g++.old-deja/g++.mike/p6610b.C
new file mode 100644
index 00000000000..8ec637eef02
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6610b.C
@@ -0,0 +1,14 @@
+// prms-id: 6610
+
+int fail = 1;
+struct B;
+struct A { virtual int f(const B*) = 0; int g(const B*); };
+int A::g(const B* t) { return f(t); }
+struct B : virtual A { int f(const B*); B* B_this; };
+int B::f(const B* t) { return t == this; }
+struct S1 { };
+struct C : virtual S1, virtual B, virtual A { C(); };
+C::C() { if (g(this)) fail = 0; }
+struct D : virtual B, virtual A, C { };
+
+int main() { D d; return fail; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6611.C b/gcc/testsuite/g++.old-deja/g++.mike/p6611.C
new file mode 100644
index 00000000000..3d972cb8643
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6611.C
@@ -0,0 +1,26 @@
+// prms-id: 6611
+
+class COMPLEX {
+public:
+  COMPLEX(double a, double b=0) { re = a; im = b; }
+  void print() const { }
+private:
+  double re;
+  double im;
+};
+
+int main(void)
+{
+  COMPLEX a[3][3] = {
+    { 1, COMPLEX(2,3), COMPLEX(3,4), },
+    { 1, COMPLEX(2,3), COMPLEX(3,4), },
+    { 1, COMPLEX(2,3), COMPLEX(3,4), },
+  };
+  int i,j;
+
+  for (i = 0; i < 3; i++) {
+    for (j = 0; j < 3; j++) {
+      a[i][j].print();
+    }
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6746.C b/gcc/testsuite/g++.old-deja/g++.mike/p6746.C
new file mode 100644
index 00000000000..764310fc05b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6746.C
@@ -0,0 +1,18 @@
+// Build don't link:
+// prms-id: 6746
+
+class call_trace {
+public:
+  call_trace(char* fcn_name);
+  ~call_trace();
+};
+
+static char * last_tree;
+extern "C" void prt();
+
+char * smt_mark_stree() {
+  char* _my_name = "smt_mark_stree" ; 
+  call_trace _t(_my_name);
+
+  return last_tree = 0 ? (char*)0 : (prt(), (char*)0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6901.C b/gcc/testsuite/g++.old-deja/g++.mike/p6901.C
new file mode 100644
index 00000000000..83292949ca8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6901.C
@@ -0,0 +1,7 @@
+// Build don't link:
+// prms-id: 6901
+
+void green() {
+  for (int i = 0; i < 10; i++) {}
+  for (int i = 0; i < 10; i++) {}
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p6927.C b/gcc/testsuite/g++.old-deja/g++.mike/p6927.C
new file mode 100644
index 00000000000..827ef29b24d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p6927.C
@@ -0,0 +1,16 @@
+// prms-id: 6927
+
+class Object {
+public:
+  Object();
+  int Value;
+};
+
+Object::Object() : Value(-1) { }
+
+Object *pArr = new Object[2];
+
+main() {
+  if (pArr[0].Value != -1 || pArr[1].Value != -1)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p700.C b/gcc/testsuite/g++.old-deja/g++.mike/p700.C
new file mode 100644
index 00000000000..580895e557b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p700.C
@@ -0,0 +1,2387 @@
+// Special g++ Options:
+// prms-id: 700
+
+//# 1 "../../../../libg++/etc/benchmarks/dhrystone.cc"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "../../../../libg++/etc/benchmarks/Int.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Int
+{
+protected:
+  int          rep;
+
+
+
+public:
+               Int ();
+               Int (const int  b);
+               Int (const Int& b);
+              ~Int();
+
+               operator int() const;
+
+  inline virtual  int   val() const;
+
+  inline virtual  void  operator  = (const int);
+  inline virtual  void  operator  = (const Int&);
+
+  inline virtual  void  negate();
+  inline virtual  void  complement();
+  inline virtual  void  operator ++ ();
+  inline virtual  void  operator -- ();
+
+  inline virtual  void  operator += (const Int &  );
+  inline virtual  void  operator -= (const Int &  );
+  inline virtual  void  operator *= (const Int &  );
+  inline virtual  void  operator /= (const Int &  );
+  inline virtual  void  operator %= (const Int &  );
+  inline virtual  void  operator |= (const Int &  );
+  inline virtual  void  operator &= (const Int &  );
+  inline virtual  void  operator ^= (const Int &  );
+  inline virtual  void  operator <<=(const Int &  );
+  inline virtual  void  operator >>=(const Int &  );
+
+
+  inline virtual  void  operator += (const int);
+  inline virtual  void  operator -= (const int);
+  inline virtual  void  operator *= (const int);
+  inline virtual  void  operator /= (const int);
+  inline virtual  void  operator %= (const int);
+  inline virtual  void  operator |= (const int);
+  inline virtual  void  operator &= (const int);
+  inline virtual  void  operator ^= (const int);
+  inline virtual  void  operator <<=(const int);
+  inline virtual  void  operator >>=(const int);
+
+
+};
+
+inline  int  Int::val() const { return rep; }
+inline       Int::operator int() const { return val(); }
+
+inline       Int::Int () :rep(0) {}
+inline       Int::Int (const int  b) :rep(b) {}
+inline       Int::Int (const Int& b) :rep(b.Int::val()) {}
+inline       Int::~Int() {}
+
+inline  void  Int::operator  = (const int  b)
+{ rep = b;  ; }
+inline  void  Int::operator  = (const Int&  b)
+{ rep = b.Int::val();  ; }
+
+inline  void  Int::complement()
+{ rep = ~rep;  ; }
+inline  void  Int::negate()
+{ rep = -rep;  ; }
+inline  void  Int::operator ++ ()
+{ ++rep;  ; }
+inline  void  Int::operator -- ()
+{ --rep;  ; }
+
+inline  void  Int::operator += (const Int &   b)
+{ rep += b.Int::val();  ; }
+inline  void  Int::operator -= (const Int &   b)
+{ rep -= b.Int::val();  ; }
+inline  void  Int::operator *= (const Int &   b)
+{ rep *= b.Int::val();  ; }
+inline  void  Int::operator /= (const Int &   b)
+{ rep /= b.Int::val();  ; }
+inline  void  Int::operator %= (const Int &   b)
+{ rep %= b.Int::val();  ; }
+inline  void  Int::operator |= (const Int &   b)
+{ rep |= b.Int::val();  ; }
+inline  void  Int::operator &= (const Int &   b)
+{ rep &= b.Int::val();  ; }
+inline  void  Int::operator ^= (const Int &   b)
+{ rep ^= b.Int::val();  ; }
+inline  void  Int::operator <<=(const Int &   b)
+{ rep <<= b.Int::val();  ; }
+inline  void  Int::operator >>=(const Int &   b)
+{ rep >>= b.Int::val();  ; }
+
+
+
+inline  void  Int::operator += (const int b)
+{ rep += b;  ; }
+inline  void  Int::operator -= (const int b)
+{ rep -= b;  ; }
+inline  void  Int::operator *= (const int b)
+{ rep *= b;  ; }
+inline  void  Int::operator /= (const int b)
+{ rep /= b;  ; }
+inline  void  Int::operator %= (const int b)
+{ rep %= b;  ; }
+inline  void  Int::operator |= (const int b)
+{ rep |= b;  ; }
+inline  void  Int::operator &= (const int b)
+{ rep &= b;  ; }
+inline  void  Int::operator ^= (const int b)
+{ rep ^= b;  ; }
+inline  void  Int::operator <<=(const int b)
+{ rep <<= b;  ; }
+inline  void  Int::operator >>=(const int b)
+{ rep >>= b;  ; }
+
+
+inline  int& operator  = (int& a,  const Int &   b)
+{ a = b.Int::val(); return a;}	// WARNING - 
+inline  int& operator += (int& a,  const Int &   b)
+{ a += b.Int::val(); return a; }
+inline  int& operator -= (int& a,  const Int &   b)
+{ a -= b.Int::val(); return a;}
+inline  int& operator *= (int& a,  const Int &   b)
+{ a *= b.Int::val(); return a;}
+inline  int& operator /= (int& a,  const Int &   b)
+{ a /= b.Int::val(); return a;}
+inline  int& operator %= (int& a,  const Int &   b)
+{ a %= b.Int::val(); return a;}
+inline  int& operator |= (int& a,  const Int &   b)
+{ a |= b.Int::val(); return a;}
+inline  int& operator &= (int& a,  const Int &   b)
+{ a &= b.Int::val(); return a;}
+inline  int& operator ^= (int& a,  const Int &   b)
+{ a ^= b.Int::val(); return a;}
+inline  int& operator <<=(int& a,  const Int &   b)
+{ a <<= b.Int::val(); return a;}
+inline  int& operator >>=(int& a,  const Int &   b)
+{ a >>= b.Int::val(); return a;}
+
+
+
+//# 289 "../../../../libg++/etc/benchmarks/Int.h"
+
+
+inline  Int  operator -  (const Int &   a) return r(a)
+{ r.negate();  }
+inline  Int  operator ~  (const Int &   a) return r(a)
+{ r.complement();  }
+
+inline  Int  operator +  (const Int &   a, const Int &   b) return r(a)
+{ r += b.Int::val();  }
+inline  Int  operator -  (const Int &   a, const Int &   b) return r(a)
+{ r -= b.Int::val();  }
+inline  Int  operator *  (const Int &   a, const Int &   b) return r(a)
+{ r *= b.Int::val();  }
+inline  Int  operator /  (const Int &   a, const Int &   b) return r(a)
+{ r /= b.Int::val();  }
+inline  Int  operator %  (const Int &   a, const Int &   b) return r(a)
+{ r %= b.Int::val();  }
+inline  Int  operator << (const Int &   a, const Int &   b) return r(a)
+{ r <<= b.Int::val();  }
+inline  Int  operator >> (const Int &   a, const Int &   b) return r(a)
+{ r >>= b.Int::val();  }
+inline  Int  operator &  (const Int &   a, const Int &   b) return r(a)
+{ r &= b.Int::val();  }
+inline  Int  operator |  (const Int &   a, const Int &   b) return r(a)
+{ r |= b.Int::val();  }
+inline  Int  operator ^  (const Int &   a, const Int &   b) return r(a)
+{ r ^= b.Int::val();  }
+
+inline  Int  operator +  (const Int &   a, const int b) return r(a)
+{ r += b;  }
+inline  Int  operator -  (const Int &   a, const int b) return r(a)
+{ r -= b;  }
+inline  Int  operator *  (const Int &   a, const int b) return r(a)
+{ r *= b;  }
+inline  Int  operator /  (const Int &   a, const int b) return r(a)
+{ r /= b;  }
+inline  Int  operator %  (const Int &   a, const int b) return r(a)
+{ r %= b;  }
+inline  Int  operator << (const Int &   a, const int b) return r(a)
+{ r <<= b;  }
+inline  Int  operator >> (const Int &   a, const int b) return r(a)
+{ r >>= b;  }
+inline  Int  operator &  (const Int &   a, const int b) return r(a)
+{ r &= b;  }
+inline  Int  operator |  (const Int &   a, const int b) return r(a)
+{ r |= b;  }
+inline  Int  operator ^  (const Int &   a, const int b) return r(a)
+{ r ^= b;  }
+
+inline  Int  operator +  (const int a, const Int &   b) return r(a)
+{ r += b.Int::val();  }
+inline  Int  operator -  (const int a, const Int &   b) return r(a)
+{ r -= b.Int::val();  }
+inline  Int  operator *  (const int a, const Int &   b) return r(a)
+{ r *= b.Int::val();  }
+inline  Int  operator /  (const int a, const Int &   b) return r(a)
+{ r /= b.Int::val();  }
+inline  Int  operator %  (const int a, const Int &   b) return r(a)
+{ r %= b.Int::val();  }
+inline  Int  operator << (const int a, const Int &   b) return r(a)
+{ r <<= b.Int::val();  }
+inline  Int  operator >> (const int a, const Int &   b) return r(a)
+{ r >>= b.Int::val();  }
+inline  Int  operator &  (const int a, const Int &   b) return r(a)
+{ r &= b.Int::val();  }
+inline  Int  operator |  (const int a, const Int &   b) return r(a)
+{ r |= b.Int::val();  }
+inline  Int  operator ^  (const int a, const Int &   b) return r(a)
+{ r ^= b.Int::val();  }
+
+
+
+inline  int  operator !  (const Int &   a) { return !a.Int::val(); }
+
+inline  int  operator == (const Int &   a, const Int &   b)
+{ return a.Int::val() == b.Int::val(); }
+inline  int  operator != (const Int &   a, const Int &   b)
+{ return a.Int::val() != b.Int::val(); }
+inline  int  operator <  (const Int &   a, const Int &   b)
+{ return a.Int::val() <  b.Int::val(); }
+inline  int  operator <= (const Int &   a, const Int &   b)
+{ return a.Int::val() <= b.Int::val(); }
+inline  int  operator >  (const Int &   a, const Int &   b)
+{ return a.Int::val() >  b.Int::val(); }
+inline  int  operator >= (const Int &   a, const Int &   b)
+{ return a.Int::val() >= b.Int::val(); }
+
+inline  int  operator == (const Int &   a, const int b)
+{ return a.Int::val() == b; }
+inline  int  operator != (const Int &   a, const int b)
+{ return a.Int::val() != b; }
+inline  int  operator <  (const Int &   a, const int b)
+{ return a.Int::val() <  b; }
+inline  int  operator <= (const Int &   a, const int b)
+{ return a.Int::val() <= b; }
+inline  int  operator >  (const Int &   a, const int b)
+{ return a.Int::val() >  b; }
+inline  int  operator >= (const Int &   a, const int b)
+{ return a.Int::val() >= b; }
+
+inline  int  operator == (const int a, const Int &   b)
+{ return a == b.Int::val(); }
+inline  int  operator != (const int a, const Int &   b)
+{ return a != b.Int::val(); }
+inline  int  operator <  (const int a, const Int &   b)
+{ return a <  b.Int::val(); }
+inline  int  operator <= (const int a, const Int &   b)
+{ return a <= b.Int::val(); }
+inline  int  operator >  (const int a, const Int &   b)
+{ return a >  b.Int::val(); }
+inline  int  operator >= (const int a, const Int &   b)
+{ return a >= b.Int::val(); }
+
+
+
+//# 26 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
+
+//# 1 "../../../../libg++/etc/benchmarks/Char.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Char
+{
+protected:
+  char          rep;
+
+
+
+public:
+               Char ();
+               Char (const char  b);
+               Char (const Char& b);
+              ~Char();
+
+               operator char() const;
+
+  inline virtual  char   val() const;
+
+  inline virtual  void  operator  = (const char);
+  inline virtual  void  operator  = (const Char&);
+
+  inline virtual  void  negate();
+  inline virtual  void  complement();
+  inline virtual  void  operator ++ ();
+  inline virtual  void  operator -- ();
+
+  inline virtual  void  operator += (const Char &  );
+  inline virtual  void  operator -= (const Char &  );
+  inline virtual  void  operator *= (const Char &  );
+  inline virtual  void  operator /= (const Char &  );
+  inline virtual  void  operator %= (const Char &  );
+  inline virtual  void  operator |= (const Char &  );
+  inline virtual  void  operator &= (const Char &  );
+  inline virtual  void  operator ^= (const Char &  );
+  inline virtual  void  operator <<=(const Char &  );
+  inline virtual  void  operator >>=(const Char &  );
+
+
+  inline virtual  void  operator += (const char);
+  inline virtual  void  operator -= (const char);
+  inline virtual  void  operator *= (const char);
+  inline virtual  void  operator /= (const char);
+  inline virtual  void  operator %= (const char);
+  inline virtual  void  operator |= (const char);
+  inline virtual  void  operator &= (const char);
+  inline virtual  void  operator ^= (const char);
+  inline virtual  void  operator <<=(const char);
+  inline virtual  void  operator >>=(const char);
+
+
+};
+
+inline  char  Char::val() const { return rep; }
+inline       Char::operator char() const { return val(); }
+
+inline       Char::Char () :rep(0) {}
+inline       Char::Char (const char  b) :rep(b) {}
+inline       Char::Char (const Char& b) :rep(b.Char::val()) {}
+inline       Char::~Char() {}
+
+inline  void  Char::operator  = (const char  b)
+{ rep = b;  ; }
+inline  void  Char::operator  = (const Char&  b)
+{ rep = b.Char::val();  ; }
+
+inline  void  Char::complement()
+{ rep = ~rep;  ; }
+inline  void  Char::negate()
+{ rep = -rep;  ; }
+inline  void  Char::operator ++ ()
+{ ++rep;  ; }
+inline  void  Char::operator -- ()
+{ --rep;  ; }
+
+inline  void  Char::operator += (const Char &   b)
+{ rep += b.Char::val();  ; }
+inline  void  Char::operator -= (const Char &   b)
+{ rep -= b.Char::val();  ; }
+inline  void  Char::operator *= (const Char &   b)
+{ rep *= b.Char::val();  ; }
+inline  void  Char::operator /= (const Char &   b)
+{ rep /= b.Char::val();  ; }
+inline  void  Char::operator %= (const Char &   b)
+{ rep %= b.Char::val();  ; }
+inline  void  Char::operator |= (const Char &   b)
+{ rep |= b.Char::val();  ; }
+inline  void  Char::operator &= (const Char &   b)
+{ rep &= b.Char::val();  ; }
+inline  void  Char::operator ^= (const Char &   b)
+{ rep ^= b.Char::val();  ; }
+inline  void  Char::operator <<=(const Char &   b)
+{ rep <<= b.Char::val();  ; }
+inline  void  Char::operator >>=(const Char &   b)
+{ rep >>= b.Char::val();  ; }
+
+
+
+inline  void  Char::operator += (const char b)
+{ rep += b;  ; }
+inline  void  Char::operator -= (const char b)
+{ rep -= b;  ; }
+inline  void  Char::operator *= (const char b)
+{ rep *= b;  ; }
+inline  void  Char::operator /= (const char b)
+{ rep /= b;  ; }
+inline  void  Char::operator %= (const char b)
+{ rep %= b;  ; }
+inline  void  Char::operator |= (const char b)
+{ rep |= b;  ; }
+inline  void  Char::operator &= (const char b)
+{ rep &= b;  ; }
+inline  void  Char::operator ^= (const char b)
+{ rep ^= b;  ; }
+inline  void  Char::operator <<=(const char b)
+{ rep <<= b;  ; }
+inline  void  Char::operator >>=(const char b)
+{ rep >>= b;  ; }
+
+
+inline  char& operator  = (char& a,  const Char &   b)
+{ a = b.Char::val(); return a;}	// WARNING - 
+inline  char& operator += (char& a,  const Char &   b)
+{ a += b.Char::val(); return a; }
+inline  char& operator -= (char& a,  const Char &   b)
+{ a -= b.Char::val(); return a;}
+inline  char& operator *= (char& a,  const Char &   b)
+{ a *= b.Char::val(); return a;}
+inline  char& operator /= (char& a,  const Char &   b)
+{ a /= b.Char::val(); return a;}
+inline  char& operator %= (char& a,  const Char &   b)
+{ a %= b.Char::val(); return a;}
+inline  char& operator |= (char& a,  const Char &   b)
+{ a |= b.Char::val(); return a;}
+inline  char& operator &= (char& a,  const Char &   b)
+{ a &= b.Char::val(); return a;}
+inline  char& operator ^= (char& a,  const Char &   b)
+{ a ^= b.Char::val(); return a;}
+inline  char& operator <<=(char& a,  const Char &   b)
+{ a <<= b.Char::val(); return a;}
+inline  char& operator >>=(char& a,  const Char &   b)
+{ a >>= b.Char::val(); return a;}
+
+
+
+//# 291 "../../../../libg++/etc/benchmarks/Char.h"
+
+
+inline  Char  operator -  (const Char &   a) return r(a)
+{ r.negate();  }
+inline  Char  operator ~  (const Char &   a) return r(a)
+{ r.complement();  }
+
+inline  Char  operator +  (const Char &   a, const Char &   b) return r(a)
+{ r += b.Char::val();  }
+inline  Char  operator -  (const Char &   a, const Char &   b) return r(a)
+{ r -= b.Char::val();  }
+inline  Char  operator *  (const Char &   a, const Char &   b) return r(a)
+{ r *= b.Char::val();  }
+inline  Char  operator /  (const Char &   a, const Char &   b) return r(a)
+{ r /= b.Char::val();  }
+inline  Char  operator %  (const Char &   a, const Char &   b) return r(a)
+{ r %= b.Char::val();  }
+inline  Char  operator << (const Char &   a, const Char &   b) return r(a)
+{ r <<= b.Char::val();  }
+inline  Char  operator >> (const Char &   a, const Char &   b) return r(a)
+{ r >>= b.Char::val();  }
+inline  Char  operator &  (const Char &   a, const Char &   b) return r(a)
+{ r &= b.Char::val();  }
+inline  Char  operator |  (const Char &   a, const Char &   b) return r(a)
+{ r |= b.Char::val();  }
+inline  Char  operator ^  (const Char &   a, const Char &   b) return r(a)
+{ r ^= b.Char::val();  }
+
+inline  Char  operator +  (const Char &   a, const char b) return r(a)
+{ r += b;  }
+inline  Char  operator -  (const Char &   a, const char b) return r(a)
+{ r -= b;  }
+inline  Char  operator *  (const Char &   a, const char b) return r(a)
+{ r *= b;  }
+inline  Char  operator /  (const Char &   a, const char b) return r(a)
+{ r /= b;  }
+inline  Char  operator %  (const Char &   a, const char b) return r(a)
+{ r %= b;  }
+inline  Char  operator << (const Char &   a, const char b) return r(a)
+{ r <<= b;  }
+inline  Char  operator >> (const Char &   a, const char b) return r(a)
+{ r >>= b;  }
+inline  Char  operator &  (const Char &   a, const char b) return r(a)
+{ r &= b;  }
+inline  Char  operator |  (const Char &   a, const char b) return r(a)
+{ r |= b;  }
+inline  Char  operator ^  (const Char &   a, const char b) return r(a)
+{ r ^= b;  }
+
+inline  Char  operator +  (const char a, const Char &   b) return r(a)
+{ r += b.Char::val();  }
+inline  Char  operator -  (const char a, const Char &   b) return r(a)
+{ r -= b.Char::val();  }
+inline  Char  operator *  (const char a, const Char &   b) return r(a)
+{ r *= b.Char::val();  }
+inline  Char  operator /  (const char a, const Char &   b) return r(a)
+{ r /= b.Char::val();  }
+inline  Char  operator %  (const char a, const Char &   b) return r(a)
+{ r %= b.Char::val();  }
+inline  Char  operator << (const char a, const Char &   b) return r(a)
+{ r <<= b.Char::val();  }
+inline  Char  operator >> (const char a, const Char &   b) return r(a)
+{ r >>= b.Char::val();  }
+inline  Char  operator &  (const char a, const Char &   b) return r(a)
+{ r &= b.Char::val();  }
+inline  Char  operator |  (const char a, const Char &   b) return r(a)
+{ r |= b.Char::val();  }
+inline  Char  operator ^  (const char a, const Char &   b) return r(a)
+{ r ^= b.Char::val();  }
+
+
+
+inline  char  operator !  (const Char &   a) { return !a.Char::val(); }
+
+inline  char  operator == (const Char &   a, const Char &   b)
+{ return a.Char::val() == b.Char::val(); }
+inline  char  operator != (const Char &   a, const Char &   b)
+{ return a.Char::val() != b.Char::val(); }
+inline  char  operator <  (const Char &   a, const Char &   b)
+{ return a.Char::val() <  b.Char::val(); }
+inline  char  operator <= (const Char &   a, const Char &   b)
+{ return a.Char::val() <= b.Char::val(); }
+inline  char  operator >  (const Char &   a, const Char &   b)
+{ return a.Char::val() >  b.Char::val(); }
+inline  char  operator >= (const Char &   a, const Char &   b)
+{ return a.Char::val() >= b.Char::val(); }
+
+inline  char  operator == (const Char &   a, const char b)
+{ return a.Char::val() == b; }
+inline  char  operator != (const Char &   a, const char b)
+{ return a.Char::val() != b; }
+inline  char  operator <  (const Char &   a, const char b)
+{ return a.Char::val() <  b; }
+inline  char  operator <= (const Char &   a, const char b)
+{ return a.Char::val() <= b; }
+inline  char  operator >  (const Char &   a, const char b)
+{ return a.Char::val() >  b; }
+inline  char  operator >= (const Char &   a, const char b)
+{ return a.Char::val() >= b; }
+
+inline  char  operator == (const char a, const Char &   b)
+{ return a == b.Char::val(); }
+inline  char  operator != (const char a, const Char &   b)
+{ return a != b.Char::val(); }
+inline  char  operator <  (const char a, const Char &   b)
+{ return a <  b.Char::val(); }
+inline  char  operator <= (const char a, const Char &   b)
+{ return a <= b.Char::val(); }
+inline  char  operator >  (const char a, const Char &   b)
+{ return a >  b.Char::val(); }
+inline  char  operator >= (const char a, const Char &   b)
+{ return a >= b.Char::val(); }
+
+
+
+//# 27 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
+
+
+//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
+
+extern "C" {
+//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int ptrdiff_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int size_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef short unsigned int wchar_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
+
+}
+//# 73 "/giga/hgs/lib/g++-include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/sys/types.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/sys/stdtypes.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+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;
+
+
+//# 16 "/usr/include/sys/types.h" 2
+
+
+
+//# 1 "/usr/include/sys/sysmacros.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 19 "/usr/include/sys/types.h" 2
+
+
+
+
+
+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	unsigned int	uint;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef	struct  _physadr_t { int r[1]; } *physadr_t;
+typedef	struct label_t {
+	int	val[2];
+} label_t;
+
+
+
+
+
+
+
+typedef	struct	_quad_t { long val[2]; } quad_t;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef	unsigned long	ino_t;
+typedef	short	dev_t;
+typedef	long	off_t;
+typedef	unsigned short	uid_t;
+typedef	unsigned short	gid_t;
+typedef	long	key_t;
+typedef	char *	addr_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;
+
+
+
+
+
+
+
+//# 113 "/usr/include/sys/types.h"
+
+
+
+//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+//# 310 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
+
+//# 1 "/giga/hgs/lib/g++-include/sys/times.h" 1
+//# 1 "/giga/hgs/lib/g++-include/time.h" 1
+
+
+
+
+
+//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
+
+extern "C" {
+//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
+//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
+
+}
+//# 73 "/giga/hgs/lib/g++-include/stddef.h"
+
+//# 6 "/giga/hgs/lib/g++-include/time.h" 2
+
+//# 1 "/giga/hgs/lib/g++-include/stdio.h" 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//#pragma interface
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 80 "/giga/hgs/lib/g++-include/stdio.h"
+
+
+
+//# 117 "/giga/hgs/lib/g++-include/stdio.h"
+
+
+
+
+
+//# 153 "/giga/hgs/lib/g++-include/stdio.h"
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/stdio.h" 1
+
+
+
+
+
+extern	struct	_iobuf {
+	int	_cnt;
+	unsigned char *_ptr;
+	unsigned char *_base;
+	int	_bufsiz;
+	short	_flag;
+	char	_file;
+} _iob[];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern struct _iobuf 	*c_proto_fopen ();
+extern struct _iobuf 	*c_proto_fdopen ();
+extern struct _iobuf 	*c_proto_freopen ();
+extern struct _iobuf 	*c_proto_popen ();
+extern struct _iobuf 	*tmpfile();
+extern long	ftell();
+extern char	*fgets();
+extern char	*gets();
+extern char	*c_proto_sprintf ();
+extern char	*ctermid();
+extern char	*cuserid();
+extern char	*c_proto_tempnam ();
+extern char	*tmpnam();
+
+
+
+
+
+
+//# 185 "/giga/hgs/lib/g++-include/stdio.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+//# 417 "/giga/hgs/lib/g++-include/stdio.h"
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+int    _doprnt(const char*, void*, struct _iobuf *);
+int    _doscan(struct _iobuf *, const char*, ...);
+int    _filbuf(struct _iobuf *);
+int    _flsbuf(unsigned, struct _iobuf *);
+
+int    fclose(struct _iobuf *);
+struct _iobuf *  fdopen(int, const char*);
+int    fflush(struct _iobuf *);
+int    fgetc(struct _iobuf *);
+char*  fgets(char*, int, struct _iobuf  *);
+struct _iobuf *  fopen(const char*, const char*);
+int    fprintf(struct _iobuf *, const char* ...);
+int    fputc(int, struct _iobuf *);
+int    fputs(const char*, struct _iobuf *);
+int fread(void*, int, int, struct _iobuf *);
+
+
+
+struct _iobuf *  freopen(const char*, const char*, struct _iobuf *);
+
+int    fscanf(struct _iobuf *, const char* ...);
+int    fseek(struct _iobuf *, long, int);
+long   ftell(struct _iobuf  *);
+int fwrite(const void*, int, int, struct _iobuf *);
+char*  gets(char*);
+int    getw(struct _iobuf *);
+int    pclose(struct _iobuf *);
+void   perror(const char*);
+struct _iobuf *  popen(const char*, const char*);
+int    printf(const char* ...);
+int    puts(const char*);
+int    putw(int, struct _iobuf *);
+int    rewind(struct _iobuf *);
+int    scanf(const char* ...);
+int    setbuf(struct _iobuf *, char*);
+int    setbuffer(struct _iobuf *, char*, int);
+int    setlinebuf(struct _iobuf *);
+int    setvbuf(struct _iobuf *, char*, int, int);
+int    sscanf(char*, const char* ...);
+struct _iobuf *  tmpfile();
+int    ungetc(int, struct _iobuf *);
+int    vfprintf(struct _iobuf *, const char*, ...);
+
+
+
+
+int    vprintf(const char*, ... );
+
+
+
+
+
+char*  sprintf(char*, const char*, ...);
+char*  vsprintf(char*, const char*, ...);
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 7 "/giga/hgs/lib/g++-include/time.h" 2
+
+
+//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
+
+
+//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
+
+extern "C" {
+//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
+//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
+
+}
+//# 73 "/giga/hgs/lib/g++-include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/sys/types.h" 1
+
+
+
+
+
+
+
+
+//# 115 "/usr/include/sys/types.h"
+
+//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+//# 9 "/giga/hgs/lib/g++-include/time.h" 2
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 42 "/giga/hgs/lib/g++-include/time.h"
+
+
+
+
+
+
+
+//# 1 "/usr/include/time.h" 1
+
+
+
+
+
+//# 1 "/usr/include/sys/stdtypes.h" 1
+
+
+
+
+
+
+
+
+
+
+//# 32 "/usr/include/sys/stdtypes.h"
+
+//# 6 "/usr/include/time.h" 2
+
+
+
+
+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 *c_proto_gmtime (), *c_proto_localtime ();
+extern	char *c_proto_asctime (), *c_proto_ctime ();
+extern	void c_proto_tzset (), c_proto_tzsetwall ();
+extern  int dysize();
+extern  time_t timelocal(), timegm();
+
+
+//# 49 "/giga/hgs/lib/g++-include/time.h" 2
+
+
+//# 1 "/usr/include/sys/times.h" 1
+
+
+
+
+
+
+
+
+
+//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
+
+
+//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
+
+extern "C" {
+//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
+//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
+
+}
+//# 73 "/giga/hgs/lib/g++-include/stddef.h"
+
+//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+extern "C"
+{
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/sys/types.h" 1
+
+
+
+
+
+
+
+
+//# 115 "/usr/include/sys/types.h"
+
+//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+//# 10 "/usr/include/sys/times.h" 2
+
+
+struct tms {
+	clock_t	tms_utime;
+	clock_t	tms_stime;
+	clock_t	tms_cutime;
+	clock_t	tms_cstime;
+};
+
+
+clock_t times( );
+
+
+
+//# 51 "/giga/hgs/lib/g++-include/time.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+extern struct tm* localtime(long*);
+extern struct tm* gmtime(long*);
+extern char* ctime(long*);
+extern char* asctime(struct tm*);
+extern void tzset();
+extern void tzsetwall();
+
+
+
+
+
+
+extern long times(struct tms*);
+
+
+//# 97 "/giga/hgs/lib/g++-include/time.h"
+
+extern char* timezone(int, int);
+extern int getitimer(int, struct itimerval*);
+extern int setitimer(int, struct itimerval*, struct itimerval*);
+extern int gettimeofday(struct timeval*, struct timezone*);
+extern int settimeofday(struct timeval*, struct timezone*);
+extern int stime(long*);
+int       dysize(int);
+
+
+
+
+
+
+
+
+long      clock(void);
+
+long      time(long*);
+unsigned  ualarm(unsigned, unsigned);
+unsigned  usleep(unsigned);
+int       profil(char*, int, int, int);
+
+}
+
+
+
+//# 1 "/giga/hgs/lib/g++-include/sys/times.h" 2
+
+//# 311 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef enum	{Ident1, Ident2, Ident3, Ident4, Ident5} Enumeration;
+
+
+
+
+typedef Int	OneToThirty;
+typedef Int	OneToFifty;
+typedef Char	CapitalLetter;
+typedef Char	String30[31];
+typedef Int	Array1Dim[51];
+typedef Int	Array2Dim[51][51];
+
+struct	Record
+{
+	struct Record		*PtrComp;
+	Enumeration		Discr;
+	Enumeration		EnumComp;
+	OneToFifty		IntComp;
+	String30		StringComp;
+};
+
+typedef struct Record 	RecordType;
+typedef RecordType *	RecordPtr;
+typedef int		boolean;
+
+
+
+
+
+
+
+
+
+
+
+extern "C" {
+extern int printf(const char* ...);
+extern void exit(int);
+}
+
+void Proc0();
+void Proc1(RecordPtr PtrParIn);
+void Proc2(OneToFifty	*IntParIO);
+void Proc3(RecordPtr	*PtrParOut);
+void Proc4();
+void Proc5();
+boolean Func3(Enumeration	EnumParIn);
+void Proc6(  Enumeration	EnumParIn,   Enumeration	*EnumParOut);
+void Proc7(OneToFifty IntParI1, OneToFifty IntParI2, OneToFifty *IntParOut);
+void Proc8(Array1Dim	Array1Par,
+      Array2Dim	Array2Par,
+      OneToFifty IntParI1,
+      OneToFifty IntParI2);
+Enumeration Func1(CapitalLetter	CharPar1, CapitalLetter	CharPar2);
+boolean Func2(String30	StrParI1, String30	StrParI2);
+boolean Func3(Enumeration	EnumParIn);
+
+void mystrcpy(String30 s, char* t)
+{
+  for (; *t != '\0'; ++s, ++t) *s = *t;
+  *s = '\0';
+}
+
+char mystrcmp(String30 s, String30 t)
+{
+  for (; *s == *t; ++s, ++t) if (*s == '\0') return 0;
+  return char(*s - *t);
+}
+
+
+
+main()
+{
+	Proc0();
+	exit(0);
+}
+
+
+
+
+Int		IntGlob;
+boolean		BoolGlob;
+char		Char1Glob;
+char		Char2Glob;
+Array1Dim	Array1Glob;
+Array2Dim	Array2Glob;
+RecordPtr	PtrGlb;
+RecordPtr	PtrGlbNext;
+
+void Proc0()
+{
+	OneToFifty		IntLoc1;
+	  OneToFifty		IntLoc2;
+	OneToFifty		IntLoc3;
+	  char		CharLoc;
+	  char		CharIndex;
+	Enumeration	 	EnumLoc;
+	String30		String1Loc;
+	String30		String2Loc;
+
+//# 445 "../../../../libg++/etc/benchmarks/dhrystone.cc"
+
+
+	time_t			starttime;
+	time_t			benchtime;
+	time_t			nulltime;
+	struct tms		Tms;
+	register unsigned int	i;
+
+	times(&Tms); starttime = Tms.tms_utime;
+	for (i = 0; i < 500000		; ++i);
+	times(&Tms);
+	nulltime = Tms.tms_utime - starttime;
+
+
+	PtrGlbNext = new Record;
+	PtrGlb = new Record;
+	PtrGlb->PtrComp = PtrGlbNext;
+	PtrGlb->Discr = Ident1;
+	PtrGlb->EnumComp = Ident3;
+	PtrGlb->IntComp = 40;
+	mystrcpy(PtrGlb->StringComp, "DHRYSTONE PROGRAM, SOME STRING");
+	mystrcpy(String1Loc, "JUST INITIALIZED TO SOME JUNK.");
+
+
+
+
+
+
+
+
+	times(&Tms); starttime = Tms.tms_utime;
+
+	for (i = 0; i < 500000		; ++i)
+	{
+
+		Proc5();
+		Proc4();
+		IntLoc1 = 2;
+		IntLoc2 = 3;
+		mystrcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
+		EnumLoc = Ident2;
+		BoolGlob = ! Func2(String1Loc, String2Loc);
+		while (IntLoc1 < IntLoc2)
+		{
+			IntLoc3 = 5 * IntLoc1 - IntLoc2;
+			Proc7(IntLoc1, IntLoc2, &IntLoc3);
+			++IntLoc1;
+		}
+		Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3);
+		Proc1(PtrGlb);
+		for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
+			if (EnumLoc == Func1(CharIndex, 'C'))
+				Proc6(Ident1, &EnumLoc);
+		IntLoc3 = IntLoc2 * IntLoc1;
+		IntLoc2 = IntLoc3 / IntLoc1;
+		IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1;
+		Proc2(&IntLoc1);
+	}
+
+
+
+
+
+
+
+
+
+
+
+
+
+	times(&Tms);
+	benchtime = Tms.tms_utime - starttime - nulltime;
+	printf("Dhrystone time for %ld passes = %ld\n",
+		(long) 500000		, benchtime/60		);
+	printf("This machine benchmarks at %ld dhrystones/second\n",
+		((long) 500000		) * 60		 / benchtime);
+
+
+}
+
+void Proc1(RecordPtr PtrParIn)
+{
+
+
+	(*(PtrParIn->PtrComp))  =  *PtrGlb ;
+	PtrParIn->IntComp = 5;
+	(*(PtrParIn->PtrComp)) .IntComp = PtrParIn->IntComp;
+	(*(PtrParIn->PtrComp)) .PtrComp = PtrParIn->PtrComp;
+
+	Proc3(&((*(PtrParIn->PtrComp)) .PtrComp));
+	if ((*(PtrParIn->PtrComp)) .Discr == Ident1)
+	{
+		(*(PtrParIn->PtrComp)) .IntComp = 6;
+		Proc6(PtrParIn->EnumComp, &(*(PtrParIn->PtrComp)) .EnumComp);
+		(*(PtrParIn->PtrComp)) .PtrComp = PtrGlb->PtrComp;
+		Proc7((*(PtrParIn->PtrComp)) .IntComp, 10, &(*(PtrParIn->PtrComp)) .IntComp);
+	}
+	else
+		*PtrParIn =  (*(PtrParIn->PtrComp))  ;
+
+
+}
+
+void Proc2(OneToFifty	*IntParIO)
+{
+	  OneToFifty		IntLoc;
+	  Enumeration		EnumLoc;
+
+	IntLoc = *IntParIO + 10;
+	for(;;)
+	{
+		if (Char1Glob == 'A')
+		{
+			--IntLoc;
+			*IntParIO = IntLoc - IntGlob;
+			EnumLoc = Ident1;
+		}
+		if (EnumLoc == Ident1)
+			break;
+	}
+}
+
+void Proc3(RecordPtr	*PtrParOut)
+{
+	if (PtrGlb != 0 )
+		*PtrParOut = PtrGlb->PtrComp;
+	else
+		IntGlob = 100;
+	Proc7(10, IntGlob, &PtrGlb->IntComp);
+}
+
+void Proc4()
+{
+	  boolean	BoolLoc;
+
+	BoolLoc = Char1Glob == 'A';
+	BoolLoc |= BoolGlob;
+	Char2Glob = 'B';
+}
+
+void Proc5()
+{
+	Char1Glob = 'A';
+	BoolGlob = 	0 ;
+}
+
+
+
+
+void Proc6(  Enumeration	EnumParIn,   Enumeration	*EnumParOut)
+{
+	*EnumParOut = EnumParIn;
+	if (! Func3(EnumParIn) )
+		*EnumParOut = Ident4;
+	switch (EnumParIn)
+	{
+	case Ident1:	*EnumParOut = Ident1; break;
+	case Ident2:	if (IntGlob > 100) *EnumParOut = Ident1;
+			else *EnumParOut = Ident4;
+			break;
+	case Ident3:	*EnumParOut = Ident2; break;
+	case Ident4:	break;
+	case Ident5:	*EnumParOut = Ident3;
+	}
+}
+
+void Proc7(OneToFifty IntParI1, OneToFifty IntParI2, OneToFifty *IntParOut)
+{
+	  OneToFifty	IntLoc;
+
+	IntLoc = IntParI1 + 2;
+	*IntParOut = IntParI2 + IntLoc;
+}
+
+void Proc8(Array1Dim	Array1Par,
+      Array2Dim	Array2Par,
+      OneToFifty IntParI1,
+      OneToFifty IntParI2)
+{
+	  OneToFifty	IntLoc;
+	  OneToFifty	IntIndex;
+
+	IntLoc = IntParI1 + 5;
+	Array1Par[IntLoc] = IntParI2;
+	Array1Par[IntLoc+1] = Array1Par[IntLoc];
+	Array1Par[IntLoc+30] = IntLoc;
+	for (IntIndex = IntLoc; IntIndex <= (IntLoc+1); ++IntIndex)
+		Array2Par[IntLoc][IntIndex] = IntLoc;
+	++Array2Par[IntLoc][IntLoc-1];
+	Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc];
+	IntGlob = 5;
+}
+
+Enumeration Func1(CapitalLetter	CharPar1, CapitalLetter	CharPar2)
+{
+	  CapitalLetter	CharLoc1;
+	  CapitalLetter	CharLoc2;
+
+	CharLoc1 = CharPar1;
+	CharLoc2 = CharLoc1;
+	if (CharLoc2 != CharPar2)
+		return (Ident1);
+	else
+		return (Ident2);
+}
+
+boolean Func2(String30	StrParI1, String30	StrParI2)
+{
+	  OneToThirty		IntLoc;
+	  CapitalLetter	CharLoc;
+
+	IntLoc = 1;
+	while (IntLoc <= 1)
+		if (Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1)
+		{
+			CharLoc = 'A';
+			++IntLoc;
+		}
+	if (CharLoc >= 'W' && CharLoc <= 'Z')
+		IntLoc = 7;
+	if (CharLoc == 'X')
+		return(	1 );
+	else
+	{
+		if (mystrcmp(StrParI1, StrParI2) > 0)
+		{
+			IntLoc += 7;
+			return (	1 );
+		}
+		else
+			return (	0 );
+	}
+}
+
+boolean Func3(Enumeration	EnumParIn)
+{
+	  Enumeration	EnumLoc;
+
+	EnumLoc = EnumParIn;
+	if (EnumLoc == Ident3) return (	1 );
+	return (	0 );
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p701.C b/gcc/testsuite/g++.old-deja/g++.mike/p701.C
new file mode 100644
index 00000000000..4acf17038d4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p701.C
@@ -0,0 +1,34 @@
+// Build don't link:
+// prms-id: 701
+
+extern "C" 
+{
+  int printf(const char *, ...);
+};
+
+
+void Munge(int& x) 
+{				// ERROR - referenced below
+   x = 2;
+}
+
+
+class A 
+{
+ public:
+   int i;
+   A(int x) : i(x) {}
+   void Safe() const;
+};
+
+void
+A::Safe() const 
+{
+   Munge(i);	// ERROR - should not be able to modify a const object
+}
+
+main()
+{
+   const A a(1);
+   a.Safe();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p710.C b/gcc/testsuite/g++.old-deja/g++.mike/p710.C
new file mode 100644
index 00000000000..56f09b1a67e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p710.C
@@ -0,0 +1,43 @@
+// Build don't link: 
+// GROUPS passed delete
+/*
+  Bug Id: 
+  PRMS Id: p0000710
+  Bug is : overloading operator delete in class def not allowed
+*/
+
+/*
+  In addition to this bug, the compiler permits overloading operator
+  delete in the class definition.  This is verboten, and should be
+  caught by a regression suite.  In other words, the following is also a
+  bug that's not caught:
+*/
+
+
+#include <stdlib.h>
+
+extern "C" 
+{
+   int printf(const char*, ...);
+};
+
+
+
+class B
+{
+ public:
+   int x;
+   virtual ~B() {}
+   void operator delete(void*,size_t s)
+  {// ERROR - previous declaration as.*
+      printf("B::delete() %d\n",s);
+   }
+   void operator delete(void*){} // ERROR - .B::operator.*overloaded
+};
+
+main()
+{
+   B* p = new B;
+   delete p;
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7180.C b/gcc/testsuite/g++.old-deja/g++.mike/p7180.C
new file mode 100644
index 00000000000..da75bd6d4ed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7180.C
@@ -0,0 +1,17 @@
+// prms-id: 7180
+
+class String {
+public:
+   String(const char*);
+   ~String();
+};
+ 
+String::String(const char* str = "") {
+}
+ 
+String::~String(void) {
+}
+ 
+int main() {
+   const String array[] = {"3"};
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7325.C b/gcc/testsuite/g++.old-deja/g++.mike/p7325.C
new file mode 100644
index 00000000000..8402a36cc34
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7325.C
@@ -0,0 +1,55 @@
+// I hate this type of test case.  I'm not sure how to code it better.
+// See the PR for what this tests.
+// prms-id: 7325
+// execution test fails *-*-*
+
+int fail = 0;
+
+struct A {
+  int i;
+  static const A* match_this;
+  static const A* match_arg;
+  A(): i(7) {
+    if (match_this)
+      if (match_this != this)
+	fail = 1;
+  }
+  A* get_this() { return this; }
+  A& operator = (const A& o) {
+    if (match_this)
+      if (match_this != this)
+	fail = 1;
+    if (match_arg)
+      if (match_arg != &o)
+	fail = 1;
+    match_arg = &o;
+  }
+};
+
+const A* A::match_this;
+const A* A::match_arg;
+A a;
+
+A foo() { return a; }
+void f ()
+{
+  A a;
+  A::match_this = &a;
+  a = foo ();
+  a = foo ();
+  A::match_this = 0;
+}
+
+void g ()
+{
+  A::match_this = A().get_this();
+  A();
+  A();
+  A::match_this = 0;
+}
+
+main() {
+  f();
+  g();
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7476.C b/gcc/testsuite/g++.old-deja/g++.mike/p7476.C
new file mode 100644
index 00000000000..acddf05ee13
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7476.C
@@ -0,0 +1,20 @@
+// Build don't link:
+// prms-id: 7476
+
+class HeapTracked {
+public:
+  virtual ~HeapTracked() { }
+  static void isObjectAllocation(const HeapTracked *ptr);
+  static void isObjectAllocation(HeapTracked *ptr);
+};
+
+void HeapTracked::isObjectAllocation(HeapTracked *ptr)
+{
+  dynamic_cast<const void*>(ptr);
+  dynamic_cast<void*>(ptr);
+}
+void HeapTracked::isObjectAllocation(const HeapTracked *ptr)
+{
+  const_cast<void*>(dynamic_cast<const void*>(ptr));
+  dynamic_cast<void*>(ptr);		// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p755.C b/gcc/testsuite/g++.old-deja/g++.mike/p755.C
new file mode 100644
index 00000000000..e01fc64e8ce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p755.C
@@ -0,0 +1,17 @@
+// It checks to see if you can define your own global new operator.
+// prms-id: 755
+
+typedef __SIZE_TYPE__ size_t;
+extern "C" void exit(int);
+
+void* operator new(size_t sz) {
+  void* p = 0;
+  exit(0);
+  return p;
+}
+
+main () {
+  int* i = new int;
+  delete i;
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p755a.C b/gcc/testsuite/g++.old-deja/g++.mike/p755a.C
new file mode 100644
index 00000000000..9f496c1e337
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p755a.C
@@ -0,0 +1,14 @@
+// It checks to see if you can define your own global delete operator.
+// prms-id: 755
+
+extern "C" void exit(int);
+
+void operator delete(void *p) throw() {
+  exit(0);
+}
+
+main () {
+  int* i = new int;
+  delete i;
+  return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7626.C b/gcc/testsuite/g++.old-deja/g++.mike/p7626.C
new file mode 100644
index 00000000000..61636d61fdb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7626.C
@@ -0,0 +1,43 @@
+// Build don't link:
+// prms-id: 7626
+
+int fail;
+
+typedef unsigned int UINT;
+
+class CObject{};
+
+class CCmdTarget : public CObject {
+};
+
+typedef void (CCmdTarget::*AFX_PMSG)(void);
+
+struct AFX_MSGMAP_ENTRY {
+  AFX_PMSG pfn;     
+};
+
+class CWnd : public CCmdTarget {
+public:
+  void OnMyMsg() { fail  = 1; }		// If this one is called, something is wrong.
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+};
+
+typedef void (CWnd::*AFX_PMSGW)(void);
+
+class CDialog : public CWnd
+{
+public:
+  void OnMyMsg() { }
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+};
+
+AFX_MSGMAP_ENTRY  CDialog ::_messageEntries[] = { 
+  { (AFX_PMSG)(AFX_PMSGW)(void (CWnd::*)())&CDialog::OnMyMsg }, 
+  { (AFX_PMSG)0 }
+}; 
+
+main() {
+  CDialog d;
+  (d.*((CDialog::_messageEntries)[0]).pfn)();	// This should call CDialog::OnMyMsg
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7635.C b/gcc/testsuite/g++.old-deja/g++.mike/p7635.C
new file mode 100644
index 00000000000..4cafa0e46fa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7635.C
@@ -0,0 +1,6 @@
+// prms-id: 7635
+
+class DaycountBasis {
+  mutable const int * p;
+  mutable int * const q;	// ERROR - 
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7651.C b/gcc/testsuite/g++.old-deja/g++.mike/p7651.C
new file mode 100644
index 00000000000..a295a8971af
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7651.C
@@ -0,0 +1,25 @@
+// prms-id: 7651
+
+int fail = 0;
+
+class Foo {
+public:
+  Foo(double i) : data(i) { if (data != 1.0) fail = 1; }
+  ~Foo() { if (data != 1.0) fail = 1; }
+private:
+  volatile double data;
+};
+
+int DingDong(double A) {
+  volatile Foo a(A);
+
+  if ( A != 0.0 ) {
+    return 1;
+  }
+  return 0;
+}
+
+
+main() {
+  DingDong(1.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p783.C b/gcc/testsuite/g++.old-deja/g++.mike/p783.C
new file mode 100644
index 00000000000..ce22a7c14b5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p783.C
@@ -0,0 +1,15 @@
+// prms-id: 783
+
+extern "C" void printf (char *, ...);
+
+class C {
+public:
+  C() { }
+  ~C() { }
+};
+
+main(int argc, char**argv) {
+  C c,d;
+  c = (argc&1) ? C() : d;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p783a.C b/gcc/testsuite/g++.old-deja/g++.mike/p783a.C
new file mode 100644
index 00000000000..1883fc7ded2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p783a.C
@@ -0,0 +1,26 @@
+// Copying into an object directly is a lose according to tiemann.
+// Deleting an object many times is a lose.
+// prms-id: 783
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+class C {
+  int i;
+public:
+  C() {
+    i = 1;
+  }
+  ~C() {
+    if (i != 1) {
+      exit(1);
+    }
+    i = 0;
+  }
+};
+
+main(int argc, char**argv) {
+  C c;
+  c = C();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p783b.C b/gcc/testsuite/g++.old-deja/g++.mike/p783b.C
new file mode 100644
index 00000000000..f4170bc21cc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p783b.C
@@ -0,0 +1,37 @@
+// This one check for objects being destroyed twice.  The bug it is
+// looking for is the extra dtor call on C() even though it is never
+// built.
+// prms-id: 783
+
+extern "C" void printf (char *, ...);
+extern "C" void exit (int);
+
+class C {
+  int i;
+public:
+//  C() {printf ("C ctor at %x\n", this);}
+//  ~C() {printf ("C dtor at %x\n", this);}
+  C() {
+    i = 1;
+  }
+  ~C() {
+    if (i != 1) {
+      exit(1);
+    }
+    i = 0;
+  }
+};
+
+C g;
+
+C func()  {
+  return g;
+}
+
+main(int argc, char**argv) {
+  C c,d;
+//  printf ("\n");
+  c = (argc != 1) ? C() : d;
+//  printf ("\n");
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p784.C b/gcc/testsuite/g++.old-deja/g++.mike/p784.C
new file mode 100644
index 00000000000..a8f05306c9d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p784.C
@@ -0,0 +1,3702 @@
+// Build don't link:
+// Special g++ Options: -w
+// prms-id: 784
+
+//# 1 "GctSymbol.GctSymbol.CHMap.cc"
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+//#pragma implementation
+
+//# 1 "GctSymbol.GctSymbol.CHMap.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+//# 1 "GctSymbol.GctSymbol.Map.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Pix.h" 1
+
+
+
+typedef void* Pix;
+
+//# 26 "GctSymbol.GctSymbol.Map.h" 2
+
+//# 1 "GctSymbol.defs.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+
+
+
+//# 1 "../../GctSymbol.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctSymbol class
+//
+// Expects to be included by Gct.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+#include <bool.h>
+
+//# 25 "../../GctSymbol.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 1
+
+
+
+// Compatibility with old library.
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+//#pragma interface
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+
+//#pragma interface
+
+
+/* KLUDGES!! */
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+
+
+extern "C" {
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/mips/lib/gcc/decstatn/cygnus-1.96/include/stddef.h" 1
+
+
+
+
+
+
+/* This avoids lossage on Sunos but only if stdtypes.h comes first.
+   There's no way to win with the other order!  Sun lossage.  */
+
+/* In case nobody has defined these types, but we aren't running under
+   GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE__TYPE__, and
+   __WCHAR_TYPE__ have reasonable values.  This can happen if the
+   parts of GCC is compiled by an older compiler, that actually
+   include gstddef.h, such as collect2.  */
+
+/* Signed type of difference of two pointers.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef long int ptrdiff_t;
+
+
+
+
+
+
+/* Unsigned type of `sizeof' something.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef unsigned int size_t;
+
+
+
+
+
+
+/* Data type for wide chars.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int wchar_t;
+
+
+
+
+
+
+
+
+/* A null pointer constant.  */
+
+
+
+
+/* Offset of member MEMBER in a struct of type TYPE.  */
+
+
+
+
+
+//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 2
+
+
+
+
+}
+
+//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ostream; class streambuf;
+
+typedef long streamoff, streampos;
+
+struct _ios_fields { // The data members of an ios.
+    streambuf *_strbuf;
+    ostream* _tie;
+    long _width;
+    unsigned long _flags;
+    char _fill;
+    unsigned char _state;
+    unsigned short _precision;
+};
+
+
+enum state_value { _good = 0, _eof = 1,  _fail = 2, _bad  = 4 };
+
+
+class ios : public _ios_fields {
+  public:
+    enum io_state { goodbit=0, eofbit=1, failbit=2, badbit=4 };
+    enum open_mode {
+	in=1,
+	out=2,
+	ate=4,
+	app=8,
+	trunc=16,
+	nocreate=32,
+	noreplace=64 };
+    enum seek_dir { beg, cur, end};
+    enum { skipws=01, left=02, right=04, internal=010,
+	   dec=020, oct=040, hex=0100,
+	   showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+	   scientific=04000, fixed=0100000, unitbuf=020000, stdio=040000,
+	   dont_close=0x80000000 //Don't close streambuf when destroying stream
+	   };
+
+    ostream* tie() { return _tie; }
+    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
+
+    // Methods to change the format state.
+    char fill() { return _fill; }
+    char fill(char newf) { char oldf = _fill; _fill = newf; return oldf; }
+    unsigned long flags() { return _flags; }
+    unsigned long flags(unsigned long new_val) {
+	unsigned long old_val = _flags; _flags = new_val; return old_val; }
+    unsigned short precision() { return _precision; }
+    unsigned short precision(int newp) {
+	unsigned short oldp = _precision; _precision = (unsigned short)newp;
+	return oldp; }
+    unsigned long setf(unsigned long val) {
+	unsigned long oldbits = _flags;
+	_flags |= val; return oldbits; }
+    unsigned long setf(unsigned long val, unsigned long mask) {
+	unsigned long oldbits = _flags;
+	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
+    unsigned long unsetf(unsigned long mask) {
+	unsigned long oldbits = _flags & mask;
+	_flags &= ~mask; return oldbits; }
+    long width() { return _width; }
+    long width(long val) { long save = _width; _width = val; return save; }
+
+    static const unsigned long basefield;
+    static const unsigned long adjustfield;
+    static const unsigned long floatfield;
+
+    streambuf* rdbuf() { return _strbuf; }
+    void clear(int state = 0) { _state = state; }
+    int good() { return _state == 0; }
+    int eof() { return _state & ios::eofbit; }
+    int fail() { return _state & (ios::badbit|ios::failbit); }
+    int bad() { return _state & ios::badbit; }
+    int rdstate() { return _state; }
+    void set(int flag) { _state |= flag; }
+    operator void*() { return fail() ? (void*)0 : (void*)this; }
+    int operator!() { return fail(); }
+
+
+    void unset(state_value flag) { _state &= ~flag; }
+    void close();
+    int is_open();
+    int readable();
+    int writable();
+
+
+  protected:
+    ios(streambuf*sb) { _strbuf=sb; _state=0; _width=0; _fill=' ';
+			_flags=ios::skipws; _precision=6; }
+};
+
+
+
+
+typedef ios::seek_dir _seek_dir;
+
+
+// Magic numbers and bits for the _flags field.
+// The magic numbers use the high-order bits of _flags;
+// the remaining bits are abailable for variable flags.
+// Note: The magic numbers must all be negative if stdio
+// emulation is desired.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct __streambuf {
+    // NOTE: If this is changed, also change __FILE in stdio/stdio.h!
+    int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
+    char* _gptr;	/* Current get pointer */
+    char* _egptr;	/* End of get area. */
+    char* _eback;	/* Start of putback+get area. */
+    char* _pbase;	/* Start of put area. */
+    char* _pptr;	/* Current put pointer. */
+    char* _epptr;	/* End of put area. */
+    char* _base;	/* Start of reserve area. */
+    char* _ebuf;	/* End of reserve area. */
+    struct streambuf *_chain;
+};
+
+struct streambuf : private __streambuf {
+    friend class ios;
+    friend class istream;
+    friend class ostream;
+  protected:
+    static streambuf* _list_all; /* List of open streambufs. */
+    streambuf*& xchain() { return _chain; }
+    void _un_link();
+    void _link_in();
+    char* gptr() const { return _gptr; }
+    char* pptr() const { return _pptr; }
+    char* egptr() const { return _egptr; }
+    char* epptr() const { return _epptr; }
+    char* pbase() const { return _pbase; }
+    char* eback() const { return _eback; }
+    char* ebuf() const { return _ebuf; }
+    char* base() const { return _base; }
+    void xput_char(char c) { *_pptr++ = c; }
+    int xflags() { return _flags; }
+    int xflags(int f) { int fl = _flags; _flags = f; return fl; }
+    void xsetflags(int f) { _flags |= f; }
+    void gbump(int n) { _gptr += n; }
+    void pbump(int n) { _pptr += n; }
+    void setb(char* b, char* eb, int a=0);
+    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
+    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
+  public:
+    static int flush_all();
+    static void flush_all_linebuffered(); // Flush all line buffered files.
+    virtual int underflow(); // Leave public for now
+    virtual int overflow(int c = (-1) ); // Leave public for now
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
+    int sputbackc(char c);
+    int sungetc();
+    streambuf();
+    virtual ~streambuf();
+    int unbuffered() { return _flags & 2  ? 1 : 0; }
+    int linebuffered() { return _flags & 0x4000  ? 1 : 0; }
+    void unbuffered(int i)
+	{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
+    void linebuffered(int i)
+	{ if (i) _flags |= 0x4000 ; else _flags &= ~0x4000 ; }
+    int allocate() {
+	if (base() || unbuffered()) return 0;
+	else return doallocate(); }
+    virtual int sync();
+    virtual int pbackfail(int c);
+    virtual int ungetfail();
+    virtual streambuf* setbuf(char* p, int len);
+    int in_avail() { return _egptr - _gptr; }
+    int out_waiting() { return _pptr - _pbase; }
+    virtual int sputn(const char* s, int n);
+    virtual int sgetn(char* s, int n);
+    long sgetline(char* buf, size_t n, char delim, int putback_delim);
+    int sbumpc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr++; }
+    int sgetc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int snextc() {
+	if (++_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int sputc(int c) {
+	if (_pptr >= _epptr) return overflow(c);
+	return *_pptr++ = c, (unsigned char)c; }
+    int vscan(char const *fmt0, char*  ap);
+    int vform(char const *fmt0, char*  ap);
+};
+
+struct __file_fields {
+    char _fake;
+    char _shortbuf[1];
+    short _fileno;
+    int _blksize;
+    char* _save_gptr;
+    char* _save_egptr;
+    long  _offset;
+};
+
+class filebuf : public streambuf {
+    struct __file_fields _fb;
+    void init();
+  public:
+    filebuf();
+    filebuf(int fd);
+    filebuf(int fd, char* p, int len);
+    ~filebuf();
+    filebuf* attach(int fd);
+    filebuf* open(const char *filename, const char *mode);
+    filebuf* open(const char *filename, int mode, int prot = 0664);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+    int is_open() { return _fb._fileno >= 0; }
+    int fd() { return is_open() ? _fb._fileno : (-1) ; }
+    filebuf* close();
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    int sputn(const char* s, int n);
+    int sgetn(char* s, int n);
+  protected: // See documentation in filebuf.C.
+    virtual int pbackfail(int c);
+    virtual int sync();
+    int is_reading() { return eback() != egptr(); }
+    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
+    /* System's idea of pointer */
+    char* file_ptr() { return _fb._save_gptr ? _fb._save_egptr : egptr(); }
+    int do_flush();
+    // Low-level operations (Usually invoke system calls.)
+    virtual int sys_read(char* buf, size_t size);
+    virtual long  sys_seek(long , _seek_dir);
+    virtual long sys_write(const void*, long);
+    virtual int sys_stat(void*); // Actually, a (struct stat*)
+    virtual int sys_close();
+};
+
+
+inline int ios::readable() { return rdbuf()->_flags & 4 ; }
+inline int ios::writable() { return rdbuf()->_flags & 8 ; }
+inline int ios::is_open() {return rdbuf()->_flags & 4 +8 ;}
+
+
+
+
+//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 2
+
+
+class istream; class ostream;
+typedef istream& (*__imanip)(istream&);
+typedef ostream& (*__omanip)(ostream&);
+
+extern istream& ws(istream& ins);
+extern ostream& flush(ostream& outs);
+extern ostream& endl(ostream& outs);
+extern ostream& ends(ostream& outs);
+
+class ostream : public ios
+{
+    void do_osfx();
+  public:
+    ostream();
+    ostream(streambuf* sb, ostream* tied=((void *)0) );
+    ~ostream();
+
+    int opfx() { if (!good()) return 0; if (_tie) _tie->flush(); return 1; }
+    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
+		      do_osfx(); }
+    streambuf* ostreambuf() const { return _strbuf; }
+    ostream& flush();
+    ostream& put(char c);
+    ostream& write(const char *s, int n);
+    ostream& write(const unsigned char *s, int n) { return write((char*)s, n);}
+    ostream& write(const void *s, int n) { return write((char*)s, n);}
+    ostream& seekp(streampos);
+    ostream& seekp(streamoff, _seek_dir);
+    streampos tellp();
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args);
+};
+
+ostream& operator<<(ostream&, char c);
+ostream& operator<<(ostream& os, unsigned char c) { return os << (char)c; }
+//ostream& operator<<(ostream &os, signed char c) { return os << (char)c; }
+extern ostream& operator<<(ostream&, const char *s);
+inline ostream& operator<<(ostream& os, const unsigned char *s)
+{ return os << (const char*)s; }
+//inline ostream& operator<<(ostream& os, const signed char *s)
+//{ return os << (const char*)s; }
+ostream& operator<<(ostream&, void *p);
+ostream& operator<<(ostream&, int n);
+ostream& operator<<(ostream&, long n);
+ostream& operator<<(ostream&, unsigned int n);
+ostream& operator<<(ostream&, unsigned long n);
+ostream& operator<<(ostream& os, short n) {return os << (int)n;}
+ostream& operator<<(ostream& os, unsigned short n)
+{return os << (unsigned int)n;}
+ostream& operator<<(ostream&, float n);
+ostream& operator<<(ostream&, double n);
+ostream& operator<<(ostream& os, __omanip func) { return (*func)(os); }
+ostream& operator<<(ostream&, streambuf*);
+
+class istream : public ios
+{
+    size_t _gcount;
+  public:
+    istream();
+    istream(streambuf* sb, ostream*tied=((void *)0) );
+    ~istream();
+    streambuf* istreambuf() const { return _strbuf; }
+    istream& get(char& c);
+    istream& get(unsigned char& c);
+    istream& read(char *ptr, int n);
+    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
+    int get() { return _strbuf->sbumpc(); }
+    istream& getline(char* ptr, int len, char delim = '\n');
+    istream& get(char* ptr, int len, char delim = '\n');
+    istream& gets(char **s, char delim = '\n');
+    int ipfx(int need) {
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && (need == 0 || rdbuf()->in_avail())) ;  //??? THIS LINE IS QUESTIONABLE */
+	if (!need && (flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx0() { // Optimized version of ipfx(0).
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie) _tie->flush();
+	if ((flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx1() { // Optimized version of ipfx(1).
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
+	return 1;
+    }
+    size_t gcount() { return _gcount; }
+    istream& seekg(streampos);
+    istream& seekg(streamoff, _seek_dir);
+    streampos tellg();
+    istream& putback(char ch) {
+	if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& unget() {
+	if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
+	return *this;}
+
+    istream& unget(char ch) { return putback(ch); }
+    int skip(int i);
+
+};
+
+istream& operator>>(istream&, char*);
+istream& operator>>(istream& is, unsigned char* p) { return is >> (char*)p; }
+//istream& operator>>(istream& is, signed char* p) { return is >> (char*)p; }
+istream& operator>>(istream&, char& c);
+istream& operator>>(istream&, unsigned char& c);
+//istream& operator>>(istream&, signed char& c);
+istream& operator>>(istream&, int&);
+istream& operator>>(istream&, long&);
+istream& operator>>(istream&, short&);
+istream& operator>>(istream&, unsigned int&);
+istream& operator>>(istream&, unsigned long&);
+istream& operator>>(istream&, unsigned short&);
+istream& operator>>(istream&, float&);
+istream& operator>>(istream&, double&);
+istream& operator>>(istream& is, __imanip func) { return (*func)(is); }
+
+class iostream : public ios {
+    size_t _gcount;
+  public:
+    iostream();
+    operator istream&() { return *(istream*)this; }
+    operator ostream&() { return *(ostream*)this; }
+    ~iostream();
+    // NOTE: These duplicate istream methods.
+    istream& get(char& c) { return ((istream*)this)->get(c); }
+    istream& get(unsigned char& c) { return ((istream*)this)->get(c); }
+    istream& read(char *ptr, int n) { return ((istream*)this)->read(ptr, n); }
+    istream& read(unsigned char *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    istream& read(void *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    int get() { return _strbuf->sbumpc(); }
+    istream& getline(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->getline(ptr, len, delim); }
+    istream& get(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->get(ptr, len, delim); }
+    istream& gets(char **s, char delim = '\n')
+	{ return ((istream*)this)->gets(s, delim); }
+    int ipfx(int need) { return ((istream*)this)->ipfx(need); }
+    int ipfx0()  { return ((istream*)this)->ipfx0(); }
+    int ipfx1()  { return ((istream*)this)->ipfx1(); }
+    size_t gcount() { return _gcount; }
+    istream& putback(char ch) { return ((istream*)this)->putback(ch); }
+    istream& unget() { return ((istream*)this)->unget(); }
+    istream& seekg(streampos pos) { return ((istream*)this)->seekg(pos); }
+    istream& seekg(streamoff off, _seek_dir dir)
+	{ return ((istream*)this)->seekg(off, dir); }
+    streampos tellg() { return ((istream*)this)->tellg(); }
+
+    istream& unget(char ch) { return putback(ch); }
+
+
+    // NOTE: These duplicate ostream methods.
+    int opfx() { return ((ostream*)this)->opfx(); }
+    void osfx() { ((ostream*)this)->osfx(); }
+    ostream& flush() { return ((ostream*)this)->flush(); }
+    ostream& put(char c) { return ((ostream*)this)->put(c); }
+    ostream& write(const char *s, int n)
+	{ return ((ostream*)this)->write(s, n); }
+    ostream& write(const unsigned char *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& write(const void *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args)
+	{ return ((ostream*)this)->vform(format, args); }
+    ostream& seekp(streampos pos) { return ((ostream*)this)->seekp(pos); }
+    ostream& seekp(streamoff off, _seek_dir dir)
+	{ return ((ostream*)this)->seekp(off, dir); }
+    streampos tellp() { return ((ostream*)this)->tellp(); }
+};
+
+extern istream cin;
+extern ostream cout, cerr, clog; // clog->rdbuf() == cerr->rdbuf()
+
+inline ostream& ostream::put(char c) { _strbuf->sputc(c); return *this; }
+
+struct Iostream_init { } ;  // Compatibility hack for AT&T libraray.
+
+
+//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 2
+
+
+extern char* form(char*, ...);
+
+extern char* dec(long, int=0);
+extern char* dec(int, int=0);
+extern char* dec(unsigned long, int=0);
+extern char* dec(unsigned int, int=0);
+
+extern char* hex(long, int=0);
+extern char* hex(int, int=0);
+extern char* hex(unsigned long, int=0);
+extern char* hex(unsigned int, int=0);
+
+extern char* oct(long, int=0);
+extern char* oct(int, int=0);
+extern char* oct(unsigned long, int=0);
+extern char* oct(unsigned int, int=0);
+
+inline istream& WS(istream& str) { return ws(str); }
+
+
+//# 26 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Regex.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+
+
+
+
+
+
+struct re_pattern_buffer;       // defined elsewhere
+struct re_registers;
+
+class Regex
+{
+private:
+
+                     Regex(const Regex&) {}  // no X(X&)
+  void               operator = (const Regex&) {} // no assignment
+
+protected:
+  re_pattern_buffer* buf;
+  re_registers*      reg;
+
+public:
+                     Regex(const char* t,
+                           int fast = 0,
+                           int bufsize = 40,
+                           const char* transtable = 0);
+
+                    ~Regex();
+
+  int                match(const char* s, int len, int pos = 0) const;
+  int                search(const char* s, int len,
+                            int& matchlen, int startpos = 0) const;
+  int                match_info(int& start, int& length, int nth = 0) const;
+
+  int                OK() const;  // representation invariant
+};
+
+// some built in regular expressions
+
+extern const Regex RXwhite;          // = "[ \n\t\r\v\f]+"
+extern const Regex RXint;            // = "-?[0-9]+"
+extern const Regex RXdouble;         // = "-?\\(\\([0-9]+\\.[0-9]*\\)\\|
+                                     //    \\([0-9]+\\)\\|\\(\\.[0-9]+\\)\\)
+                                     //    \\([eE][---+]?[0-9]+\\)?"
+extern const Regex RXalpha;          // = "[A-Za-z]+"
+extern const Regex RXlowercase;      // = "[a-z]+"
+extern const Regex RXuppercase;      // = "[A-Z]+"
+extern const Regex RXalphanum;       // = "[0-9A-Za-z]+"
+extern const Regex RXidentifier;     // = "[A-Za-z_][A-Za-z0-9_]*"
+
+
+
+//# 27 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
+
+
+struct StrRep                     // internal String representations
+{
+  unsigned short    len;         // string length
+  unsigned short    sz;          // allocated space
+  char              s[1];        // the string starts here
+                                 // (at least 1 char for trailing null)
+                                 // allocated & expanded via non-public fcts
+};
+
+// primitive ops on StrReps -- nearly all String fns go through these.
+
+StrRep*     Salloc(StrRep*, const char*, int, int);
+StrRep*     Scopy(StrRep*, StrRep*);
+StrRep*     Sresize(StrRep*, int);
+StrRep*     Scat(StrRep*, const char*, int, const char*, int);
+StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
+StrRep*     Sprepend(StrRep*, const char*, int);
+StrRep*     Sreverse(StrRep*, StrRep*);
+StrRep*     Supcase(StrRep*, StrRep*);
+StrRep*     Sdowncase(StrRep*, StrRep*);
+StrRep*     Scapitalize(StrRep*, StrRep*);
+
+// These classes need to be defined in the order given
+
+class String;
+class SubString;
+
+class SubString
+{
+  friend class      String;
+protected:
+
+  String&           S;        // The String I'm a substring of
+  unsigned short    pos;      // starting position in S's rep
+  unsigned short    len;      // length of substring
+
+  void              assign(StrRep*, const char*, int = -1);
+                    SubString(String& x, int p, int l);
+                    SubString(const SubString& x);
+
+public:
+
+// Note there are no public constructors. SubStrings are always
+// created via String operations
+
+                   ~SubString();
+
+  void              operator =  (const String&     y);
+  void              operator =  (const SubString&  y);
+  void              operator =  (const char* t);
+  void              operator =  (char        c);
+
+// return 1 if target appears anywhere in SubString; else 0
+
+  int               contains(char        c) const;
+  int               contains(const String&     y) const;
+  int               contains(const SubString&  y) const;
+  int               contains(const char* t) const;
+  int               contains(const Regex&       r) const;
+
+// return 1 if target matches entire SubString
+
+  int               matches(const Regex&  r) const;
+
+// IO
+
+  friend ostream&   operator<<(ostream& s, const SubString& x);
+
+// status
+
+  unsigned int      length() const;
+  int               empty() const;
+  const char*       chars() const;
+
+  int               OK() const;
+
+};
+
+
+class String
+{
+  friend class      SubString;
+
+protected:
+  StrRep*           rep;   // Strings are pointers to their representations
+
+// some helper functions
+
+  int               search(int, int, const char*, int = -1) const;
+  int               search(int, int, char) const;
+  int               match(int, int, int, const char*, int = -1) const;
+  int               _gsub(const char*, int, const char* ,int);
+  int               _gsub(const Regex&, const char*, int);
+  SubString         _substr(int, int);
+
+public:
+
+// constructors & assignment
+
+                    String();
+                    String(const String& x);
+                    String(const SubString&  x);
+                    String(const char* t);
+                    String(const char* t, int len);
+                    String(char c);
+
+                    ~String();
+
+  void              operator =  (const String&     y);
+  void              operator =  (const char* y);
+  void              operator =  (char        c);
+  void              operator =  (const SubString&  y);
+
+// concatenation
+
+  void              operator += (const String&     y);
+  void              operator += (const SubString&  y);
+  void              operator += (const char* t);
+  void              operator += (char        c);
+
+  void              prepend(const String&     y);
+  void              prepend(const SubString&  y);
+  void              prepend(const char* t);
+  void              prepend(char        c);
+
+
+// procedural versions:
+// concatenate first 2 args, store result in last arg
+
+  friend void     cat(const String&, const String&, String&);
+  friend void     cat(const String&, const SubString&, String&);
+  friend void     cat(const String&, const char*, String&);
+  friend void     cat(const String&, char, String&);
+
+  friend void     cat(const SubString&, const String&, String&);
+  friend void     cat(const SubString&, const SubString&, String&);
+  friend void     cat(const SubString&, const char*, String&);
+  friend void     cat(const SubString&, char, String&);
+
+  friend void     cat(const char*, const String&, String&);
+  friend void     cat(const char*, const SubString&, String&);
+  friend void     cat(const char*, const char*, String&);
+  friend void     cat(const char*, char, String&);
+
+// double concatenation, by request. (yes, there are too many versions,
+// but if one is supported, then the others should be too...)
+// Concatenate first 3 args, store in last arg
+
+  friend void     cat(const String&,const String&, const String&,String&);
+  friend void     cat(const String&,const String&,const SubString&,String&);
+  friend void     cat(const String&,const String&, const char*, String&);
+  friend void     cat(const String&,const String&, char, String&);
+  friend void     cat(const String&,const SubString&,const String&,String&);
+  friend void     cat(const String&,const SubString&,const SubString&,String&);
+  friend void     cat(const String&,const SubString&, const char*, String&);
+  friend void     cat(const String&,const SubString&, char, String&);
+  friend void     cat(const String&,const char*, const String&,    String&);
+  friend void     cat(const String&,const char*, const SubString&, String&);
+  friend void     cat(const String&,const char*, const char*, String&);
+  friend void     cat(const String&,const char*, char, String&);
+
+  friend void     cat(const char*, const String&, const String&,String&);
+  friend void     cat(const char*,const String&,const SubString&,String&);
+  friend void     cat(const char*,const String&, const char*, String&);
+  friend void     cat(const char*,const String&, char, String&);
+  friend void     cat(const char*,const SubString&,const String&,String&);
+  friend void     cat(const char*,const SubString&,const SubString&,String&);
+  friend void     cat(const char*,const SubString&, const char*, String&);
+  friend void     cat(const char*,const SubString&, char, String&);
+  friend void     cat(const char*,const char*, const String&,    String&);
+  friend void     cat(const char*,const char*, const SubString&, String&);
+  friend void     cat(const char*,const char*, const char*, String&);
+  friend void     cat(const char*,const char*, char, String&);
+
+
+// searching & matching
+
+// return position of target in string or -1 for failure
+
+  int               index(char        c, int startpos = 0) const;
+  int               index(const String&     y, int startpos = 0) const;
+  int               index(const SubString&  y, int startpos = 0) const;
+  int               index(const char* t, int startpos = 0) const;
+  int               index(const Regex&      r, int startpos = 0) const;
+
+// return 1 if target appears anyhere in String; else 0
+
+  int               contains(char        c) const;
+  int               contains(const String&     y) const;
+  int               contains(const SubString&  y) const;
+  int               contains(const char* t) const;
+  int               contains(const Regex&      r) const;
+
+// return 1 if target appears anywhere after position pos
+// (or before, if pos is negative) in String; else 0
+
+  int               contains(char        c, int pos) const;
+  int               contains(const String&     y, int pos) const;
+  int               contains(const SubString&  y, int pos) const;
+  int               contains(const char* t, int pos) const;
+  int               contains(const Regex&      r, int pos) const;
+
+// return 1 if target appears at position pos in String; else 0
+
+  int               matches(char        c, int pos = 0) const;
+  int               matches(const String&     y, int pos = 0) const;
+  int               matches(const SubString&  y, int pos = 0) const;
+  int               matches(const char* t, int pos = 0) const;
+  int               matches(const Regex&      r, int pos = 0) const;
+
+//  return number of occurences of target in String
+
+  int               freq(char        c) const;
+  int               freq(const String&     y) const;
+  int               freq(const SubString&  y) const;
+  int               freq(const char* t) const;
+
+// SubString extraction
+
+// Note that you can't take a substring of a const String, since
+// this leaves open the possiblility of indirectly modifying the
+// String through the SubString
+
+  SubString         at(int         pos, int len);
+  SubString         operator () (int         pos, int len); // synonym for at
+
+  SubString         at(const String&     x, int startpos = 0);
+  SubString         at(const SubString&  x, int startpos = 0);
+  SubString         at(const char* t, int startpos = 0);
+  SubString         at(char        c, int startpos = 0);
+  SubString         at(const Regex&      r, int startpos = 0);
+
+  SubString         before(int          pos);
+  SubString         before(const String&      x, int startpos = 0);
+  SubString         before(const SubString&   x, int startpos = 0);
+  SubString         before(const char*  t, int startpos = 0);
+  SubString         before(char         c, int startpos = 0);
+  SubString         before(const Regex&       r, int startpos = 0);
+
+  SubString         through(int          pos);
+  SubString         through(const String&      x, int startpos = 0);
+  SubString         through(const SubString&   x, int startpos = 0);
+  SubString         through(const char*  t, int startpos = 0);
+  SubString         through(char         c, int startpos = 0);
+  SubString         through(const Regex&       r, int startpos = 0);
+
+  SubString         from(int          pos);
+  SubString         from(const String&      x, int startpos = 0);
+  SubString         from(const SubString&   x, int startpos = 0);
+  SubString         from(const char*  t, int startpos = 0);
+  SubString         from(char         c, int startpos = 0);
+  SubString         from(const Regex&       r, int startpos = 0);
+
+  SubString         after(int         pos);
+  SubString         after(const String&     x, int startpos = 0);
+  SubString         after(const SubString&  x, int startpos = 0);
+  SubString         after(const char* t, int startpos = 0);
+  SubString         after(char        c, int startpos = 0);
+  SubString         after(const Regex&      r, int startpos = 0);
+
+
+// deletion
+
+// delete len chars starting at pos
+  void              del(int         pos, int len);
+
+// delete the first occurrence of target after startpos
+
+  void              del(const String&     y, int startpos = 0);
+  void              del(const SubString&  y, int startpos = 0);
+  void              del(const char* t, int startpos = 0);
+  void              del(char        c, int startpos = 0);
+  void              del(const Regex&      r, int startpos = 0);
+
+// global substitution: substitute all occurrences of pat with repl
+
+  int               gsub(const String&     pat, const String&     repl);
+  int               gsub(const SubString&  pat, const String&     repl);
+  int               gsub(const char* pat, const String&     repl);
+  int               gsub(const char* pat, const char* repl);
+  int               gsub(const Regex&      pat, const String&     repl);
+
+// friends & utilities
+
+// split string into array res at separators; return number of elements
+
+  friend int        split(const String& x, String res[], int maxn,
+                          const String& sep);
+  friend int        split(const String& x, String res[], int maxn,
+                          const Regex&  sep);
+
+  friend String     common_prefix(const String& x, const String& y,
+                                  int startpos = 0);
+  friend String     common_suffix(const String& x, const String& y,
+                                  int startpos = -1);
+  friend String     replicate(char        c, int n);
+  friend String     replicate(const String&     y, int n);
+  friend String     join(String src[], int n, const String& sep);
+
+// simple builtin transformations
+
+  friend String     reverse(const String& x);
+  friend String     upcase(const String& x);
+  friend String     downcase(const String& x);
+  friend String     capitalize(const String& x);
+
+// in-place versions of above
+
+  void              reverse();
+  void              upcase();
+  void              downcase();
+  void              capitalize();
+
+// element extraction
+
+  char&             operator [] (int i);
+  char              elem(int i) const;
+  char              firstchar() const;
+  char              lastchar() const;
+
+// conversion
+
+                    operator const char*() const;
+  const char*       chars() const;
+
+
+// IO
+
+  friend ostream&   operator<<(ostream& s, const String& x);
+  friend ostream&   operator<<(ostream& s, const SubString& x);
+  friend istream&   operator>>(istream& s, String& x);
+
+  friend int        readline(istream& s, String& x,
+                             char terminator = '\n',
+                             int discard_terminator = 1);
+
+// status
+
+  unsigned int      length() const;
+  int               empty() const;
+
+// preallocate some space for String
+  void              alloc(int newsize);
+
+// report current allocation (not length!)
+
+  int               allocation() const;
+
+
+  volatile void     error(const char* msg) const;
+
+  int               OK() const;
+};
+
+typedef String StrTmp; // for backward compatibility
+
+// other externs
+
+int        compare(const String&    x, const String&     y);
+int        compare(const String&    x, const SubString&  y);
+int        compare(const String&    x, const char* y);
+int        compare(const SubString& x, const String&     y);
+int        compare(const SubString& x, const SubString&  y);
+int        compare(const SubString& x, const char* y);
+int        fcompare(const String&   x, const String&     y); // ignore case
+
+extern StrRep  _nilStrRep;
+extern String _nilString;
+
+// other inlines
+
+String operator + (const String& x, const String& y);
+String operator + (const String& x, const SubString& y);
+String operator + (const String& x, const char* y);
+String operator + (const String& x, char y);
+String operator + (const SubString& x, const String& y);
+String operator + (const SubString& x, const SubString& y);
+String operator + (const SubString& x, const char* y);
+String operator + (const SubString& x, char y);
+String operator + (const char* x, const String& y);
+String operator + (const char* x, const SubString& y);
+
+int operator==(const String& x, const String& y);
+int operator!=(const String& x, const String& y);
+int operator> (const String& x, const String& y);
+int operator>=(const String& x, const String& y);
+int operator< (const String& x, const String& y);
+int operator<=(const String& x, const String& y);
+int operator==(const String& x, const SubString&  y);
+int operator!=(const String& x, const SubString&  y);
+int operator> (const String& x, const SubString&  y);
+int operator>=(const String& x, const SubString&  y);
+int operator< (const String& x, const SubString&  y);
+int operator<=(const String& x, const SubString&  y);
+int operator==(const String& x, const char* t);
+int operator!=(const String& x, const char* t);
+int operator> (const String& x, const char* t);
+int operator>=(const String& x, const char* t);
+int operator< (const String& x, const char* t);
+int operator<=(const String& x, const char* t);
+int operator==(const SubString& x, const String& y);
+int operator!=(const SubString& x, const String& y);
+int operator> (const SubString& x, const String& y);
+int operator>=(const SubString& x, const String& y);
+int operator< (const SubString& x, const String& y);
+int operator<=(const SubString& x, const String& y);
+int operator==(const SubString& x, const SubString&  y);
+int operator!=(const SubString& x, const SubString&  y);
+int operator> (const SubString& x, const SubString&  y);
+int operator>=(const SubString& x, const SubString&  y);
+int operator< (const SubString& x, const SubString&  y);
+int operator<=(const SubString& x, const SubString&  y);
+int operator==(const SubString& x, const char* t);
+int operator!=(const SubString& x, const char* t);
+int operator> (const SubString& x, const char* t);
+int operator>=(const SubString& x, const char* t);
+int operator< (const SubString& x, const char* t);
+int operator<=(const SubString& x, const char* t);
+
+
+
+
+// status reports, needed before defining other things
+
+inline unsigned int String::length() const {  return rep->len; }
+inline int         String::empty() const { return rep->len == 0; }
+inline const char* String::chars() const { return &(rep->s[0]); }
+inline int         String::allocation() const { return rep->sz; }
+inline void        String::alloc(int newsize) { rep = Sresize(rep, newsize); }
+
+inline unsigned int SubString::length() const { return len; }
+inline int         SubString::empty() const { return len == 0; }
+inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
+
+
+// constructors
+
+inline String::String()
+  : rep(&_nilStrRep) {}
+inline String::String(const String& x)
+  : rep(Scopy(0, x.rep)) {}
+inline String::String(const char* t)
+  : rep(Salloc(0, t, -1, -1)) {}
+inline String::String(const char* t, int tlen)
+  : rep(Salloc(0, t, tlen, tlen)) {}
+inline String::String(const SubString& y)
+  : rep(Salloc(0, y.chars(), y.length(), y.length())) {}
+inline String::String(char c)
+  : rep(Salloc(0, &c, 1, 1)) {}
+
+inline String::~String() { if (rep != &_nilStrRep) delete rep; }
+
+inline SubString::SubString(const SubString& x)
+  :S(x.S), pos(x.pos), len(x.len) {}
+inline SubString::SubString(String& x, int first, int l)
+  :S(x), pos(first), len(l) {}
+
+inline SubString::~SubString() {}
+
+// assignment
+
+inline void String::operator =  (const String& y)
+{
+  rep = Scopy(rep, y.rep);
+}
+
+inline void String::operator=(const char* t)
+{
+  rep = Salloc(rep, t, -1, -1);
+}
+
+inline void String::operator=(const SubString&  y)
+{
+  rep = Salloc(rep, y.chars(), y.length(), y.length());
+}
+
+inline void String::operator=(char c)
+{
+  rep = Salloc(rep, &c, 1, 1);
+}
+
+
+inline void SubString::operator = (const char* ys)
+{
+  assign(0, ys);
+}
+
+inline void SubString::operator = (char ch)
+{
+  assign(0, &ch, 1);
+}
+
+inline void SubString::operator = (const String& y)
+{
+  assign(y.rep, y.chars(), y.length());
+}
+
+inline void SubString::operator = (const SubString& y)
+{
+  assign(y.S.rep, y.chars(), y.length());
+}
+
+// Zillions of cats...
+
+inline void cat(const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y, -1);
+}
+
+inline void cat(const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, &y, 1);
+}
+
+inline void cat(const String& a, const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& a, const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const String& a, const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& a, const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const String& a, const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
+}
+
+inline void cat(const String& a, const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
+}
+
+inline void cat(const String& a, const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
+}
+
+inline void cat(const String& a, const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
+}
+
+
+inline void cat(const char* a, const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const char* a, const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* a, const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const char* a, const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* a, const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* a, const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* a, const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
+}
+
+inline void cat(const char* a, const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
+}
+
+
+// operator versions
+
+inline void String::operator +=(const String& y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String::operator +=(const SubString& y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String::operator += (const char* y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String:: operator +=(char y)
+{
+  cat(*this, y, *this);
+}
+
+// constructive concatenation
+
+
+
+inline String operator + (const String& x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, const char* y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, char y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const char* y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, char y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const char* x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const char* x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String reverse(const String& x) return r;
+{
+  r.rep = Sreverse(x.rep, r.rep);
+}
+
+inline String upcase(const String& x) return r;
+{
+  r.rep = Supcase(x.rep, r.rep);
+}
+
+inline String downcase(const String& x) return r;
+{
+  r.rep = Sdowncase(x.rep, r.rep);
+}
+
+inline String capitalize(const String& x) return r;
+{
+  r.rep = Scapitalize(x.rep, r.rep);
+}
+
+//# 883 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h"
+
+
+// prepend
+
+inline void String::prepend(const String& y)
+{
+  rep = Sprepend(rep, y.chars(), y.length());
+}
+
+inline void String::prepend(const char* y)
+{
+  rep = Sprepend(rep, y, -1);
+}
+
+inline void String::prepend(char y)
+{
+  rep = Sprepend(rep, &y, 1);
+}
+
+inline void String::prepend(const SubString& y)
+{
+  rep = Sprepend(rep, y.chars(), y.length());
+}
+
+// misc transformations
+
+
+inline void String::reverse()
+{
+  rep = Sreverse(rep, rep);
+}
+
+
+inline void String::upcase()
+{
+  rep = Supcase(rep, rep);
+}
+
+
+inline void String::downcase()
+{
+  rep = Sdowncase(rep, rep);
+}
+
+
+inline void String::capitalize()
+{
+  rep = Scapitalize(rep, rep);
+}
+
+// element extraction
+
+inline char&  String::operator [] (int i)
+{
+  if (((unsigned)i) >= length()) error("invalid index");
+  return rep->s[i];
+}
+
+inline char  String::elem (int i) const
+{
+  if (((unsigned)i) >= length()) error("invalid index");
+  return rep->s[i];
+}
+
+inline char  String::firstchar() const
+{
+  return elem(0);
+}
+
+inline char  String::lastchar() const
+{
+  return elem(length() - 1);
+}
+
+// searching
+
+inline int String::index(char c, int startpos) const
+{
+  return search(startpos, length(), c);
+}
+
+inline int String::index(const char* t, int startpos) const
+{
+  return search(startpos, length(), t);
+}
+
+inline int String::index(const String& y, int startpos) const
+{
+  return search(startpos, length(), y.chars(), y.length());
+}
+
+inline int String::index(const SubString& y, int startpos) const
+{
+  return search(startpos, length(), y.chars(), y.length());
+}
+
+inline int String::index(const Regex& r, int startpos) const
+{
+  int unused;  return r.search(chars(), length(), unused, startpos);
+}
+
+inline int String::contains(char c) const
+{
+  return search(0, length(), c) >= 0;
+}
+
+inline int String::contains(const char* t) const
+{
+  return search(0, length(), t) >= 0;
+}
+
+inline int String::contains(const String& y) const
+{
+  return search(0, length(), y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const SubString& y) const
+{
+  return search(0, length(), y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(char c, int p) const
+{
+  return match(p, length(), 0, &c, 1) >= 0;
+}
+
+inline int String::contains(const char* t, int p) const
+{
+  return match(p, length(), 0, t) >= 0;
+}
+
+inline int String::contains(const String& y, int p) const
+{
+  return match(p, length(), 0, y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const SubString& y, int p) const
+{
+  return match(p, length(), 0, y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const Regex& r) const
+{
+  int unused;  return r.search(chars(), length(), unused, 0) >= 0;
+}
+
+inline int String::contains(const Regex& r, int p) const
+{
+  return r.match(chars(), length(), p) >= 0;
+}
+
+
+inline int String::matches(const SubString& y, int p) const
+{
+  return match(p, length(), 1, y.chars(), y.length()) >= 0;
+}
+
+inline int String::matches(const String& y, int p) const
+{
+  return match(p, length(), 1, y.chars(), y.length()) >= 0;
+}
+
+inline int String::matches(const char* t, int p) const
+{
+  return match(p, length(), 1, t) >= 0;
+}
+
+inline int String::matches(char c, int p) const
+{
+  return match(p, length(), 1, &c, 1) >= 0;
+}
+
+inline int String::matches(const Regex& r, int p) const
+{
+  int l = (p < 0)? -p : length() - p;
+  return r.match(chars(), length(), p) == l;
+}
+
+
+inline int SubString::contains(const char* t) const
+{
+  return S.search(pos, pos+len, t) >= 0;
+}
+
+inline int SubString::contains(const String& y) const
+{
+  return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
+}
+
+inline int SubString::contains(const SubString&  y) const
+{
+  return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
+}
+
+inline int SubString::contains(char c) const
+{
+  return S.search(pos, pos+len, 0, c) >= 0;
+}
+
+inline int SubString::contains(const Regex& r) const
+{
+  int unused;  return r.search(chars(), len, unused, 0) >= 0;
+}
+
+inline int SubString::matches(const Regex& r) const
+{
+  return r.match(chars(), len, 0) == len;
+}
+
+
+inline int String::gsub(const String& pat, const String& r)
+{
+  return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
+}
+
+inline int String::gsub(const SubString&  pat, const String& r)
+{
+  return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
+}
+
+inline int String::gsub(const Regex& pat, const String& r)
+{
+  return _gsub(pat, r.chars(), r.length());
+}
+
+inline int String::gsub(const char* pat, const String& r)
+{
+  return _gsub(pat, -1, r.chars(), r.length());
+}
+
+inline int String::gsub(const char* pat, const char* r)
+{
+  return _gsub(pat, -1, r, -1);
+}
+
+
+
+inline  ostream& operator<<(ostream& s, const String& x)
+{
+   s << x.chars(); return s;
+}
+
+// a zillion comparison operators
+
+inline int operator==(const String& x, const String& y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const String& x, const String& y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const String& x, const String& y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const String& x, const String& y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const String& x, const String& y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const String& x, const String& y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const String& x, const SubString&  y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const String& x, const SubString&  y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const String& x, const SubString&  y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const String& x, const SubString&  y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const String& x, const SubString&  y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const String& x, const SubString&  y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const String& x, const char* t)
+{
+  return compare(x, t) == 0;
+}
+
+inline int operator!=(const String& x, const char* t)
+{
+  return compare(x, t) != 0;
+}
+
+inline int operator>(const String& x, const char* t)
+{
+  return compare(x, t) > 0;
+}
+
+inline int operator>=(const String& x, const char* t)
+{
+  return compare(x, t) >= 0;
+}
+
+inline int operator<(const String& x, const char* t)
+{
+  return compare(x, t) < 0;
+}
+
+inline int operator<=(const String& x, const char* t)
+{
+  return compare(x, t) <= 0;
+}
+
+inline int operator==(const SubString& x, const String& y)
+{
+  return compare(y, x) == 0;
+}
+
+inline int operator!=(const SubString& x, const String& y)
+{
+  return compare(y, x) != 0;
+}
+
+inline int operator>(const SubString& x, const String& y)
+{
+  return compare(y, x) < 0;
+}
+
+inline int operator>=(const SubString& x, const String& y)
+{
+  return compare(y, x) <= 0;
+}
+
+inline int operator<(const SubString& x, const String& y)
+{
+  return compare(y, x) > 0;
+}
+
+inline int operator<=(const SubString& x, const String& y)
+{
+  return compare(y, x) >= 0;
+}
+
+inline int operator==(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const SubString& x, const char* t)
+{
+  return compare(x, t) == 0;
+}
+
+inline int operator!=(const SubString& x, const char* t)
+{
+  return compare(x, t) != 0;
+}
+
+inline int operator>(const SubString& x, const char* t)
+{
+  return compare(x, t) > 0;
+}
+
+inline int operator>=(const SubString& x, const char* t)
+{
+  return compare(x, t) >= 0;
+}
+
+inline int operator<(const SubString& x, const char* t)
+{
+  return compare(x, t) < 0;
+}
+
+inline int operator<=(const SubString& x, const char* t)
+{
+  return compare(x, t) <= 0;
+}
+
+
+// a helper needed by at, before, etc.
+
+inline SubString String::_substr(int first, int l)
+{
+  if (first >= length() )  // ??? THIS LINE IS QUESTIONABLE
+    return SubString(_nilString, 0, 0) ;
+  else
+    return SubString(*this, first, l);
+}
+
+
+
+
+
+//# 26 "../../GctSymbol.h" 2
+
+
+//# 1 "../../../../../../mips/include/Gct/Object/GctHashObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctHashObject class (is abstract)
+//
+// Expects to be included by Object.h or where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "../../../../../../mips/include/Gct/Object/GctObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctObject class (is abstract)
+//
+// Expects to be included by Object.h or where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+
+
+
+//
+// tostrstream class
+//
+// A terminated oststream - an ostsrstream that auto-terminates on str()
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 1
+//    This is part of the iostream library, providing input/output for C++.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+
+//#pragma interface
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 23 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 2
+
+
+class strstreambuf : public streambuf {
+    size_t *lenp; /* current (logical) length (i.e. valid data bytes) */
+    size_t *sizep; /* allocated (physical) buffer size */
+    char **bufp;
+    size_t _len;
+    size_t _size;
+    char *buf;
+    int _frozen;
+  protected:
+    virtual int overflow(int = (-1) );
+  public:
+    strstreambuf();
+    strstreambuf(int initial);
+    strstreambuf(char *ptr, int size, char *pstart = ((void *)0) );
+    ~strstreambuf();
+    int frozen() { return _frozen; }
+    void freeze(int n=1) { _frozen = n != 0; }
+    size_t pcount();
+    char *str();
+};
+
+class istrstream : public istream {
+  public:
+    istrstream(char*);
+    istrstream(char*, int);
+    strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
+};
+
+class ostrstream : public ostream {
+  public:
+    ostrstream();
+    ostrstream(char *cp, int n, int mode=ios::out);
+    size_t pcount() { return ((strstreambuf*)_strbuf)->pcount(); }
+    char *str() { return ((strstreambuf*)_strbuf)->str(); }
+    void freeze(int n = 1) { ((strstreambuf*)_strbuf)->freeze(n); }
+    int frozen() { return ((strstreambuf*)_strbuf)->frozen(); }
+    strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
+};
+
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 2
+
+
+//
+// tostrstream class
+//
+// An isteam class that doesn't have that nasty skipws parameter that
+// you have to remember to set.  This class simply provides the istream
+// functionality with a set of constructors which defaults skipws to
+// FALSE (instead of defaulting to TRUE as is the case with plain istream).
+//
+class tostrstream: public ostrstream {
+public:
+    tostrstream(): ostrstream()
+	{ }
+    // This constructor defines cp as the buffer to use for the
+    // stream (instead of one of its own devising); it does NOT
+    // initialize the ostrstream to contain cp (of length n).
+  tostrstream(char *cp, int n, int mode=ios::out): ostrtream(cp, n, mode)	// ERROR - 
+	{ }
+    char *str()
+	{
+	    char *s = ostrstream::str();
+	    s[ostrstream::pcount()] = '\0';
+	    return s;
+	}
+};
+
+
+//# 25 "../../../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GttObject class (is abstract)
+//
+// Expects to be included where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GttErrorHandler class
+//
+// Expects to be included by Gtt.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 1
+// -*- C++ -*-
+
+
+
+//
+// Fake up a libstuff++
+//
+// This is done as a complete and utter hack; this library has no function
+// at all being in the boot area; it is here solely in order to provide a
+// libstuff++ against which the Makefiles can resolve link lines.
+//
+// The only reason that this is done is to allow the STANDARD_C++_LIBRARIES
+// as provided by the Makefile templates in the boot area to be the same
+// ones that are used by the tools outside this hierarchy.
+//
+// The tools outside this hierarchy use a different libstuff++; one that is
+// written in C++.  This one is not written in C++ in order to be simpler.
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+extern "C" {
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 1
+
+
+
+/*
+ * Useful stuff
+ */
+
+/*
+ * $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+ * $Revision: 1.6 $
+ * $Author: jason $
+ * $Date: 1994/05/16 09:13:02 $
+ */
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/ansi.h" 1
+
+
+
+
+/*
+ * ANSI Compiler Support
+ *
+ * David Harrison
+ * University of California, Berkeley
+ * 1988
+ *
+ * ANSI compatible compilers are supposed to define the preprocessor
+ * directive __STDC__.  Based on this directive, this file defines
+ * certain ANSI specific macros.
+ *
+ * ARGS:
+ *   Used in function prototypes.  Example:
+ *   extern int foo
+ *     ARGS((char *blah, double threshold));
+ */
+
+/*
+ * $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+ * $Author: jason $
+ * $Revision: 1.6 $
+ * $Date: 1994/05/16 09:13:02 $
+ *
+ * Modifications
+ * Wendell C Baker
+ * University of California, Berkeley
+ */
+
+/* Function prototypes */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 15 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
+
+
+
+/*
+ * If g++, then we stub out part of this thing and let the C++ types take
+ * over and do the same job; some compatibility must be given however
+ */
+
+/*
+ *    Use the GNU libg++ definition
+ */
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 26 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
+
+//# 35 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
+
+
+/*
+ * Make various pieces of C code that use the old ``Boolean''
+ * be compatible by faking up the definition of Boolean using
+ * the new bool type.
+ */
+
+
+//# 58 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
+
+
+typedef long FitAny;		/* can fit any integral type */
+
+/*
+ * typedef char *String;	- DO NOT USE THIS - it conflicts with C++
+ * typedef char **Stringv;	- just use char* and char** instead.
+ * 				- void* can be used for arbitrary pointers
+ */
+
+
+
+
+extern int nocase_strcmp (char *, char *)		;
+extern int nocase_strncmp (char *, char *, int)		;
+
+extern bool	 nocase_strequal (char *, char *)		;
+extern bool	 nocase_strnequal (char *, char *, int)		;
+
+extern bool	 lead_strequal (char *, char *)		;
+extern bool	 nocase_lead_strequal (char *, char *)		;
+
+extern int strhash (char *, int)		;
+extern int nocase_strhash (char *, int)		;
+
+extern int sign (int)		;
+
+/*
+ *    Some useful macros.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 33 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+}
+
+//
+// This is here because we wish to provide externs for the two
+// functions btoa(bool, unsigned = 0) and operator<<(ostream&, bool)
+// because they are not provided in bool.h.
+//
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 41 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+extern const char *stringify(bool b);
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 43 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+extern ostream& operator<<(ostream&, bool);
+
+// Should this be kept separate?   bool isn't, but then  is
+// included here only to define ostream& operator<<(ostream&, bool)
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 1
+// -*- C++ -*-
+
+
+
+//
+// unit enum
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//
+// unit enum
+//
+// This _looks_ silly, but it has an important theoretical basis in category
+// theory.  For the pragmatic reason for its existence, see the example below.
+//
+enum unit {
+    UNIT = 1,
+};
+
+extern const char *stringify(unit u);
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 2
+
+extern ostream& operator<<(ostream&, unit);
+
+//
+// A unit is used in cases where the type signature of an overloaded
+// function must be differentiated in some stronger way than can be
+// denoted unambiguously in the C++ syntax.  This enum is used to give
+// one of the functions a different type signature, thereby allowing
+// the overloading.
+//
+// The use of ``unit'' instead of int or bool is important because a unit
+// has only one possible value; therefore it adds no more information to
+// the code.   For example, say a bool was used instead, then in the testing
+// phase, would have to ask: what if TRUE was given, what if FALSE was given.
+// The problem is compounded if char or int is used.
+//
+// Example:
+//
+//     class ID {
+//     public:
+//         ID();		// construct a null ID
+//         ID(unit);		// alloc a ID with a new id
+//     private:
+//         static unsigned high_water;
+//         unsigned id;
+//     };
+//
+// Try working this example save that ID implements all of the generic
+// features of the identifier object, but the high_water is stored
+// in the heir.  That is what originally motivated the creation of unit.
+//
+
+
+//# 48 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+
+//
+// In the spirit of the standard GNU error handler functions
+// as described in
+//     typedef void (*one_arg_error_handler_t)(const char*);
+//         a one argument error handler function pointer
+//     typedef void (*two_arg_error_handler_t)(const char*, const char*);
+//         a two argument error handler function pointer
+//
+// And now the NEW
+//
+// typedef void (*zero_arg_error_handler_t)();
+//     a zero argument error handler function pointer
+//
+typedef void (*zero_arg_error_handler_t)();
+
+//
+// In the spirit of the default GNU error handler functions
+// as described in
+//     extern void default_one_arg_error_handler(const char *message);
+//         print out message on stderr, and do the default thing (abort)
+//     extern void default_two_arg_error_handler(const char *kind, const char *message);
+//         print out kind and message on stderr, and do the default thing (abort)
+//
+// And now the NEW
+//
+// extern void default_zero_arg_error_handler(const char *message);
+//     do the default thing (abort)
+//
+extern void default_zero_arg_error_handler();
+
+// Guaranteed to exit (1)
+extern void exit_zero_arg_error_handler();
+extern void exit_one_arg_error_handler(const char *message);
+extern void exit_two_arg_error_handler(const char *kind, const char *message);
+
+// Guaranteed to abort()
+extern void abort_zero_arg_error_handler();
+extern void abort_one_arg_error_handler(const char *message);
+extern void abort_two_arg_error_handler(const char *kind, const char *message);
+
+//
+// In the spirit of the standard GNU error handlers
+// as described in
+//     extern void  verbose_File_error_handler(const char*);
+//         perror and set errno = 0
+//     extern void  quiet_File_error_handler(const char*);
+//         set errno = 0
+//     extern void  fatal_File_error_handler(const char*);
+//         perror and exit 1
+//
+// And now the NEW
+//
+// extern void preserve_File_error_handler(const char *message);
+//     no perror, no assignment to errno.
+//
+extern void preserve_File_error_handler(const char *message);
+
+
+//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+
+//
+// It is expected that this will be virtually multiply inherited
+// into all of the classes that need error reporting services.
+//
+// The typical way to have that done is by inheriting the GttObject
+// as a virtual base class.
+//
+
+//
+// GttErrorHandler class
+//
+class GttErrorHandler {
+public:
+    GttErrorHandler();
+    GttErrorHandler(const char *program);
+    virtual ~GttErrorHandler();
+
+    //
+    // Error messages
+    //     - an unacceptable, but expected and recoverable condition
+    //       was was detected (but the test fails)
+    //     - errors are for ``the expected environment was not found''
+    //       rather than for ``file couldn't be opened''
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void error(const char *message);
+    static void error(tostrstream& message);
+
+    static void error(const char *function, const char *message);
+    static void error(const char *function, tostrstream& message);
+
+    static void error(const char *class_name, const char *method, const char *message);
+    static void error(const char *class_name, const char *method, tostrstream& message);
+
+    //
+    // Fatal messages
+    //     - an unacceptable and unexpected error was detected
+    //       the data invariants were violated, there is no recovery
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void fatal(const char *message);
+    static void fatal(tostrstream& message);
+
+    static void fatal(const char *function, const char *message);
+    static void fatal(const char *function, tostrstream& message);
+
+    static void fatal(const char *class_name, const char *method, const char *message);
+    static void fatal(const char *class_name, const char *method, tostrstream& message);
+private:
+    //
+    // Two underscores are used here in order to prevent confusion of these
+    // private variables with any of the heir's private variables.  Note that
+    // access control is different than visibility in C++, so all the variable
+    // names in a class hierarchy must be unique.
+    //
+
+    static bool __partial_init;
+    static void __partial_initialize();
+    static bool __full_init;
+    static void __full_initialize(const char *program);
+    static char *__program;
+
+    static void __handle_error();
+    static void __handle_fatal();
+    static void __add_newline(const char *message);
+
+    static bool __output_valid();
+    static ostream *__output;
+};
+
+
+//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+
+//
+// GttObject class (is abstract)
+//
+class GttObject: virtual public GttErrorHandler {
+protected:
+    GttObject();
+    GttObject(const GttObject&);
+    virtual ~GttObject();	// ensure descendants have virtual destructors
+
+public:
+    //
+    // I/O Support
+    //
+    // The value typically persists only long enough for an i/o operation
+    // to be performed (see the defintion of output via operator<<(... ) below)
+    virtual const char *stringify();
+protected:
+    // This is the buffer into which the printed representation of this
+    // object will be put when the time comes.  It is associated with the
+    // object so it will never go away (so long as the object exists).
+    // Use a pointer so that you only pay for the space when I/O is used
+    tostrstream *stringbuf;
+    void clear_stringbuf();
+
+public:
+    //
+    // Consistency
+    //
+    // The global data invariant for the whole object (heirs included).
+    // This OK function will call the local invariant function ok() if
+    // necessary and in addition the OK functions of the heirs
+    // This is expected to compute the data invariant of the object.
+    // It will execute GctErrorHandler::fatal if there is wrong.
+    virtual void OK() const;
+
+protected:
+    //
+    // consistency
+    //
+    // This function computes the invariant which is local to this object.
+    // It does not call any of the ancestor's OK() or ok() functions.
+    // It is not a virtual function so that it can be called from within a
+    // constructor with impunity.  Thus this function MUST NOT call any
+    // virtual functions either; it should call them by their full name if
+    // that is necessary.  The global OK() function will call this function
+    // as necessary.
+    //
+    // This function must NOT NEVER EVER be made virtual.
+    void ok() const;
+
+protected:
+    //
+    // Class Name
+    //
+    // This must return a static (constant) string which is the name
+    // of the class being declared.  By convention, not all classes
+    // must have one of these, but the major root abstract class must
+    // have one in order to allow the stringify() to work approximately
+    // correctly.
+    virtual const char *class_name() const = 0;
+};
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 91 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+extern ostream& operator<<(ostream&, GttObject&);
+
+// There may be other X& operator<<(X&, GttObject&) defined in the
+// packages defining class X.  For example see the definition of
+// GttUnitObject& operator<<(GttUnitObject&, GttObject&) in Unit.
+
+
+//# 27 "../../../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//# 1 "../../../../../../mips/include/Gct/GctErrorHandler.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctErrorHandler class
+//
+// Expects to be included by Gct.h
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p784.C,v $
+// $Author: jason $
+// $Revision: 1.6 $
+// $Date: 1994/05/16 09:13:02 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+//# 1321 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h"
+
+//# 26 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 27 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 1
+// -*- C++ -*-
+//# 107 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h"
+
+//# 29 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 30 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 1
+// -*- C++ -*-
+//# 98 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h"
+
+//# 32 "../../../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//
+// It is expected that this will be virtually multiply inherited
+// into all of the classes that need error reporting services.
+//
+// The typical way to have that done is by inheriting the GctObject
+// as a virtual base class.
+//
+
+//
+// GctErrorHandler class
+//
+// GPP_1_96_BUG
+// NOTE - virtual public GttObject should be MI into GctObject - but that
+// causes g++ 1.96 to segfault; so we must inherit GttObject here and use SI
+// GPP_1_96_BUG
+class GctErrorHandler: virtual public GttObject {
+public:
+    GctErrorHandler();
+    GctErrorHandler(const String& program);
+    virtual ~GctErrorHandler();
+
+    //
+    // Debugging messages
+    //     - these are turned off for production code.
+    //     - these messages can be shut off
+    //
+    static void debug(const char *message);
+    static void debug(tostrstream& message);
+
+    static void debug(const char *function, const char *message);
+    static void debug(const char *function, tostrstream& message);
+
+    static void debug(const char *class_name, const char *method, const char *message);
+    static void debug(const char *class_name, const char *method, tostrstream& message);
+
+    static bool debug();		// current debug switch
+    static void debug(bool value);	// change the debug switch
+
+    //
+    // Informational messages
+    //     - these correspond to a ``verbose'' mode
+    //     - these are not errors, just chatty progress reports
+    //     - these messages can be shut off
+    //
+    static void note(const char *message);
+    static void note(tostrstream& message);
+
+    static void note(const char *function, const char *message);
+    static void note(const char *function, tostrstream& message);
+
+    static void note(const char *class_name, const char *method, const char *message);
+    static void note(const char *class_name, const char *method, tostrstream& message);
+
+    static bool note();			// current note switch
+    static void note(bool value);	// change the note switch
+
+    //
+    // Warning messages
+    //     - warnings are system-recoverable errors
+    //     - the system has noticed something and taken some
+    //       corrective action
+    //     - these messages can be shut off
+    //
+    static void warning(const char *message);
+    static void warning(tostrstream& message);
+
+    static void warning(const char *function, const char *message);
+    static void warning(const char *function, tostrstream& message);
+
+    static void warning(const char *class_name, const char *method, const char *message);
+    static void warning(const char *class_name, const char *method, tostrstream& message);
+
+    static bool warning();		// current warning switch
+    static void warning(bool value);	// change the warning switch
+
+    //
+    // Error messages
+    //     - an unacceptable, but expected and recoverable
+    //       condition was was detected
+    //     - errors are for ``the expected environment was not found''
+    //       rather than for ``file couldn't be opened''
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void error(const char *message);
+    static void error(tostrstream& message);
+
+    static void error(const char *function, const char *message);
+    static void error(const char *function, tostrstream& message);
+
+    static void error(const char *class_name, const char *method, const char *message);
+    static void error(const char *class_name, const char *method, tostrstream& message);
+
+    // can't turn off errors - no ``static void error(bool value);''
+    static zero_arg_error_handler_t error();		// current error handler
+    static void error(zero_arg_error_handler_t handler);// change the error handler
+
+    static void error_is_lib_error_handler();		// change the error handler
+    static void error_is_exit();			// change the error handler
+
+    // Describes the fatal handler - WATCHOUT - implicitly uses AllocRing
+    static const char *error_handler_description();
+
+    //
+    // Fatal messages
+    //     - an unacceptable and unexpected error was detected
+    //       the data invariants were violated, there is no recovery
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void fatal(const char *message);
+    static void fatal(tostrstream& message);
+
+    static void fatal(const char *function, const char *message);
+    static void fatal(const char *function, tostrstream& message);
+
+    static void fatal(const char *class_name, const char *method, const char *message);
+    static void fatal(const char *class_name, const char *method, tostrstream& message);
+
+    // can't turn off fatals - no ``static void fatal(bool value);''
+    static zero_arg_error_handler_t fatal();			// return the fatal handler
+    static void fatal(zero_arg_error_handler_t handler);	// change the fatal handler
+
+    static void fatal_is_exit();	// change the fatal handler
+    static void fatal_is_abort();	// change the fatal handler
+
+    // Describes the fatal handler - WATCHOUT - implicitly uses AllocRing
+    static const char *fatal_handler_description();
+private:
+    //
+    // Two underscores are used here in order to prevent confusion of these
+    // private variables with any of the heir's private variables.  Note that
+    // access control is different than visibility in C++, so all the variable
+    // names in a class hierarchy must be unique.
+    //
+    static bool __debug;
+    static bool __note;
+    static bool __warning;
+    static void (*__error_handler)();	// can't turn off errors
+    static void (*__fatal_handler)();	// can't turn off fatals
+
+    static bool __partial_init;
+    static void __partial_initialize();
+    static bool __full_init;
+    static void __full_initialize(const char *program);
+    static char *__program;
+
+    static void __handle_error();
+    static void __handle_fatal();
+    static void __add_newline(const char *message);
+    static void __message_switch(bool value, bool& flag, const char *description);
+    static void __message_switch(bool value, bool& flag);
+    static const char *__describe_handler(zero_arg_error_handler_t handler);
+
+    static bool __output_valid();
+    static ostream *__output;
+
+    // GPP_1_96_BUG
+    const char *class_name() const;
+    // GPP_1_96_BUG
+};
+
+
+//# 29 "../../../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//
+// GctObject class (is abstract)
+//
+class GctObject: virtual public GctErrorHandler /*, virtual public GttObject*/ {
+protected:
+    GctObject();
+    GctObject(const GctObject&);
+    virtual ~GctObject();	// ensure descendants have virtual destructors
+
+public:
+    //
+    // I/O Support
+    //
+    // The value typically persists only long enough for an i/o operation
+    // to be performed (see the defintion of output via operator<<(... ) below)
+    virtual const char *stringify();
+protected:
+    // This is the buffer into which the printed representation of this
+    // object will be put when the time comes.  It is associated with the
+    // object so it will never go away (so long as the object exists).
+    // Use a pointer so that you only pay for the space when I/O is used
+    tostrstream *stringbuf;
+    void clear_stringbuf();
+
+public:
+    //
+    // Consistency (global consistency)
+    //
+    // The global data invariant for the whole object (heirs included).
+    // This OK function will call the local invariant function ok() if
+    // necessary and in addition the OK functions of the heirs
+    // This is expected to compute the data invariant of the object.
+    // It will execute GctErrorHandler::fatal if there is wrong.
+    virtual void OK() const;
+
+protected:
+    //
+    // consistency (local consistency)
+    //
+    // This function computes the invariant which is local to this object.
+    // It does not call any of the ancestor's OK() or ok() functions.
+    // It is not a virtual function so that it can be called from within a
+    // constructor with impunity.  Thus this function MUST NOT call any
+    // virtual functions either; it should call them by their full name if
+    // that is necessary.  The global OK() function will call this function
+    // as necessary.
+    //
+    // This function must NOT NEVER EVER be made virtual.
+    void ok() const;
+protected:
+    //
+    // Class Name
+    //
+    // This must return a static (constant) string which is the name
+    // of the class being declared.  By convention, not all classes
+    // must have one of these, but the major root abstract class must
+    // have one in order to allow the stringify() to work approximately
+    // correctly.
+    virtual const char *class_name() const = 0;
+
+public:
+    //
+    // The ``id'' of this object
+    //
+    // NOTE - we explicitly allow the situation where this function
+    // can return the address of the object - the ``this'' pointer
+    // instead of a computed id field (the __object_id field below).
+    //
+    // This function is protected because we don't want too much dependence
+    // on this notion of object identity.  I want to be able to rip it
+    // out if it becomes to cumbersome.
+    unsigned objectId() const;
+private:
+    //
+    // Symbolic ID
+    //
+    // NOTE - Normally this would be implemented by the `this' pointer.
+    // TODO - remove this for production code
+    //
+    // However, in order to make the test suites run on all machines, we
+    // make this into a symbolic id that is maintained with each object.
+    // Thus the valid outputs are always consistent across all machines.
+    unsigned __object_id;
+    static unsigned __next_id;
+};
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 117 "../../../../../../mips/include/Gct/Object/GctObject.h" 2
+
+extern ostream& operator<<(ostream&, GctObject&);
+
+
+//# 25 "../../../../../../mips/include/Gct/Object/GctHashObject.h" 2
+
+
+//
+// GctHashObject class (is abstract)
+//
+class GctHashObject: virtual public GctObject {
+protected:
+    GctHashObject();
+    GctHashObject(const GctHashObject&);
+
+public:
+    //
+    // hash support
+    //
+    virtual unsigned hash() const;
+};
+
+
+//# 28 "../../GctSymbol.h" 2
+
+
+//
+// GctSymbol
+//
+class GctSymbol: virtual public GctHashObject, String {
+public:
+    GctSymbol();		// vacuous symbol required for genclass usage
+    GctSymbol(const char*);
+    GctSymbol(const String&);
+    GctSymbol(const GctSymbol&);
+
+    operator const char *() const;
+
+    bool operator==(const GctSymbol&) const;
+    bool operator!=(const GctSymbol&) const;
+
+    bool operator<=(const GctSymbol&) const;
+    bool operator<(const GctSymbol&) const;
+    bool operator>=(const GctSymbol&) const;
+    bool operator>(const GctSymbol&) const;
+
+    unsigned hash() const;
+
+    // I/O Support
+    const char *stringify();
+
+    // Consistency
+    void OK() const;
+private:
+    const char *class_name() const;
+};
+
+extern unsigned hash(GctSymbol&);	// genclass support (no const)
+
+//
+// Inline functions
+//
+// Note - none of the String operators save for operator const char *()
+// are String member functions, instead, they are anonymous functions
+// which work by overloading.
+//
+
+
+
+
+
+GctSymbol::operator const char *() const
+{
+
+
+
+
+
+    return String::operator const char *();
+}
+
+bool
+GctSymbol::operator==(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator==(*this, other);
+}
+
+bool
+GctSymbol::operator!=(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator!=(*this, other);
+}
+
+bool
+GctSymbol::operator<=(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator<=(*this, other);
+}
+
+bool
+GctSymbol::operator<(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator<(*this, other);
+}
+
+bool
+GctSymbol::operator>=(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator>=(*this, other);
+}
+
+bool
+GctSymbol::operator>(const GctSymbol& other) const
+{
+
+
+
+
+
+    return (bool)::operator>(*this, other);
+}
+
+
+//# 25 "GctSymbol.defs.h" 2
+
+
+// equality operator
+
+
+
+
+// less-than-or-equal
+
+
+
+
+// comparison : less-than ->  0
+
+
+
+
+// hash function
+
+extern unsigned int hash(GctSymbol&);
+
+
+
+// initial capacity for structures requiring one
+
+
+
+
+
+
+
+//# 27 "GctSymbol.GctSymbol.Map.h" 2
+
+
+class GctSymbolGctSymbolMap
+{
+protected:
+  int                   count;
+  GctSymbol                   def;
+
+public:
+                        GctSymbolGctSymbolMap(GctSymbol& dflt);
+  virtual              ~GctSymbolGctSymbolMap();
+
+  int                   length();                // current number of items
+  int                   empty();
+
+  virtual int           contains(GctSymbol& key);      // is key mapped?
+
+  virtual void          clear();                 // delete all items
+
+  virtual GctSymbol&          operator [] (GctSymbol& key) = 0; // access contents by key
+
+  virtual void          del(GctSymbol& key) = 0;       // delete entry
+
+  virtual Pix           first() = 0;             // Pix of first item or 0
+  virtual void          next(Pix& i) = 0;        // advance to next or 0
+  virtual GctSymbol&          key(Pix i) = 0;          // access key at i
+  virtual GctSymbol&          contents(Pix i) = 0;     // access contents at i
+
+  virtual int           owns(Pix i);             // is i a valid Pix  ?
+  virtual Pix           seek(GctSymbol& key);          // Pix of key
+
+  GctSymbol&                  dflt();                  // access default val
+
+  void                  error(const char* msg);
+  virtual int           OK() = 0;                // rep invariant
+};
+
+
+
+inline GctSymbolGctSymbolMap::~GctSymbolGctSymbolMap() {}
+
+inline int GctSymbolGctSymbolMap::length()
+{
+  return count;
+}
+
+inline int GctSymbolGctSymbolMap::empty()
+{
+  return count == 0;
+}
+
+inline GctSymbol& GctSymbolGctSymbolMap::dflt()
+{
+  return def;
+}
+
+inline GctSymbolGctSymbolMap::GctSymbolGctSymbolMap(GctSymbol& dflt) :def(dflt)
+{
+  count = 0;
+}
+
+
+
+
+//# 26 "GctSymbol.GctSymbol.CHMap.h" 2
+
+
+
+
+
+struct GctSymbolGctSymbolCHNode
+{
+  GctSymbolGctSymbolCHNode*      tl;
+  GctSymbol                hd;
+  GctSymbol                cont;
+                     GctSymbolGctSymbolCHNode();
+                     GctSymbolGctSymbolCHNode(GctSymbol& h, GctSymbol& c, GctSymbolGctSymbolCHNode* t = 0);
+                     ~GctSymbolGctSymbolCHNode();
+};
+
+
+
+inline GctSymbolGctSymbolCHNode::GctSymbolGctSymbolCHNode() {}
+
+inline GctSymbolGctSymbolCHNode::GctSymbolGctSymbolCHNode(GctSymbol& h, GctSymbol& c, GctSymbolGctSymbolCHNode* t)
+     : hd(h), cont(c), tl(t) {}
+
+inline GctSymbolGctSymbolCHNode::~GctSymbolGctSymbolCHNode() {}
+
+
+
+
+typedef GctSymbolGctSymbolCHNode* GctSymbolGctSymbolCHNodePtr;
+
+
+
+
+class GctSymbolGctSymbolCHMap : public GctSymbolGctSymbolMap
+{
+protected:
+  GctSymbolGctSymbolCHNode** tab;
+  unsigned int   size;
+
+public:
+                GctSymbolGctSymbolCHMap(GctSymbol& dflt,unsigned int sz=100 );
+                GctSymbolGctSymbolCHMap(GctSymbolGctSymbolCHMap& a);
+                ~GctSymbolGctSymbolCHMap();
+
+  GctSymbol&          operator [] (GctSymbol& key);
+
+  void          del(GctSymbol& key);
+
+  Pix           first();
+  void          next(Pix& i);
+  GctSymbol&          key(Pix i);
+  GctSymbol&          contents(Pix i);
+
+  Pix           seek(GctSymbol& key);
+  int           contains(GctSymbol& key);
+
+  void          clear();
+  int           OK();
+};
+
+
+
+inline GctSymbolGctSymbolCHMap::~GctSymbolGctSymbolCHMap()
+{
+  clear();
+  delete tab;
+}
+
+inline int GctSymbolGctSymbolCHMap::contains(GctSymbol& key)
+{
+  return seek(key) != 0;
+}
+
+inline GctSymbol& GctSymbolGctSymbolCHMap::key(Pix p)
+{
+  if (p == 0) error("null Pix");
+  return ((GctSymbolGctSymbolCHNode*)p)->hd;
+}
+
+inline GctSymbol& GctSymbolGctSymbolCHMap::contents(Pix p)
+{
+  if (p == 0) error("null Pix");
+  return ((GctSymbolGctSymbolCHNode*)p)->cont;
+}
+
+
+
+
+//# 22 "GctSymbol.GctSymbol.CHMap.cc" 2
+
+
+// The nodes are linked together serially via a version
+// of a trick used in some vtables: odd pointers are
+// actually links to the next table entry.
+// Not terrible, but not wonderful either
+
+static inline int goodCHptr(GctSymbolGctSymbolCHNode* t)
+{
+  return ((((unsigned)t) & 1) == 0);
+}
+
+static inline GctSymbolGctSymbolCHNode* index_to_CHptr(int i)
+{
+  return (GctSymbolGctSymbolCHNode*)((i << 1) + 1);
+}
+
+static inline int CHptr_to_index(GctSymbolGctSymbolCHNode* t)
+{
+  return ( ((unsigned) t) >> 1);
+}
+
+GctSymbolGctSymbolCHMap::GctSymbolGctSymbolCHMap(GctSymbol& dflt, unsigned int sz)
+     :GctSymbolGctSymbolMap(dflt)
+{
+  tab = (GctSymbolGctSymbolCHNode**)(new GctSymbolGctSymbolCHNodePtr[size = sz]);
+  for (unsigned int i = 0; i < size; ++i) tab[i] = index_to_CHptr(i+1);
+  count = 0;
+}
+
+GctSymbolGctSymbolCHMap::GctSymbolGctSymbolCHMap(GctSymbolGctSymbolCHMap& a) :GctSymbolGctSymbolMap(a.def)
+{
+  tab = (GctSymbolGctSymbolCHNode**)(new GctSymbolGctSymbolCHNodePtr[size = a.size]);
+  for (unsigned int i = 0; i < size; ++i) tab[i] = index_to_CHptr(i+1);
+  count = 0;
+  for (Pix p = a.first(); p; a.next(p)) (*this)[a.key(p)] = a.contents(p); // gets bogus error - type `GctSymbol' is derived from private `String'
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p785.C b/gcc/testsuite/g++.old-deja/g++.mike/p785.C
new file mode 100644
index 00000000000..897f06a810a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p785.C
@@ -0,0 +1,8154 @@
+// Special g++ Options: -w
+// Build don't link:
+// prms-id: 785
+
+//# 1 "GctNameRef.List.cc"
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h" 1
+// -*- C++ -*-
+#ifndef FALSE
+#define FALSE false
+#endif
+#ifndef TRUE
+#define TRUE true
+#endif
+
+
+//
+// WATCHOUT - CC 2.1 uses regular old cpp as its #ifdef processor
+// whereas GNU uses a special preprocessor (actually ``gcc-cpp -+'')
+// This implies that there can be no C++ comments on lines which are
+// to be understood by cpp.   Actually it turns out that only lines
+// with grammatical structures (such as ``#if defined( ... )'') are
+// affected, but this is probably a good rule to follow elsewhere too.
+//
+
+//
+// Define a ``Standard C++ Unix Machine''
+//
+// By whatever means are available in sumachine and elsewhere,
+// figure out what type of C++ world we are on.
+//
+// See also "sumachine.h"
+//
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+//
+// This file is expected to be included as the first #include file in
+// all .cc files This file should be included in each and every src file
+// compiled b/c it ensures that the environment which those src files
+// expect exists either by fiat or by faking it.
+//
+
+
+//
+// Its GNU C++
+//
+// This pragma only works under g++ 1 (it no longer works for gcc2)
+
+
+
+
+// Because between releases of Cygnus' stuff, the definitions keep bouncing
+// around between  so fast that one can't
+// keep one's code compiling ...  Just include them all and be done with it.
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdlib.h" 1
+
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+
+
+extern "C" {
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/mips/lib/gcc/decstatn/cygnus-1.96/include/stddef.h" 1
+
+
+
+
+
+
+/* This avoids lossage on Sunos but only if stdtypes.h comes first.
+   There's no way to win with the other order!  Sun lossage.  */
+
+/* In case nobody has defined these types, but we aren't running under
+   GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE__TYPE__, and
+   __WCHAR_TYPE__ have reasonable values.  This can happen if the
+   parts of GCC is compiled by an older compiler, that actually
+   include gstddef.h, such as collect2.  */
+
+/* Signed type of difference of two pointers.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef long int ptrdiff_t;
+
+
+
+
+
+
+/* Unsigned type of `sizeof' something.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int size_t;
+
+
+
+
+
+
+/* Data type for wide chars.  */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef int wchar_t;
+
+
+
+
+
+
+
+
+/* A null pointer constant.  */
+
+
+
+
+/* Offset of member MEMBER in a struct of type TYPE.  */
+
+
+
+
+
+//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 2
+
+
+
+
+}
+
+//# 6 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdlib.h" 2
+
+
+extern "C" {
+
+int       abs(int);
+
+
+void abort(void);
+
+
+
+
+double    atof(const char*);
+int       atoi(const char*);
+long      atol(const char*);
+
+int       atexit(auto void (*p) (void));
+int       bsearch (const void *, const void *, size_t,
+                   size_t, auto int (*ptf)(const void*, const void*));
+void*     calloc(size_t, size_t);
+void      cfree(void*);
+
+
+void exit(int);
+
+
+
+
+char*     fcvt(double, int, int*, int*);
+void      free(void*);
+char*     getenv(const char*);
+int       getopt(int, const char**, const char*);
+int       getpw(int, char*);
+char*     gcvt(double, int, char*);
+char*     ecvt(double, int, int*, int*);
+extern char**   environ;
+
+long      labs(long);
+void*     malloc(size_t);
+size_t    malloc_usable_size(void*);
+int       putenv(const char*);
+extern char*    optarg;
+extern int      opterr;
+extern int      optind;
+void      qsort(void*, size_t, size_t, auto int (*ptf)(void*,void*));
+int       rand(void);
+void*     realloc(void*, size_t);
+int       setkey(const char*);
+int       srand(unsigned int);
+double    strtod(const char*, char**);
+long      strtol(const char*, char**, int);
+unsigned long stroul(const char**, int);
+int       system(const char*);
+
+long      random(void);
+void      srandom(int);
+char*     setstate(char*);
+char*     initstate(unsigned, char*, int);
+
+double    drand48(void);
+void      lcong48(short*);
+long      jrand48(short*);
+long      lrand48(void);
+long      mrand48(void);
+long      nrand48(short*);
+short*    seed48(short*);
+void      srand48(long);
+
+char*     ctermid(char*);
+char*     cuserid(char*);
+char*     tempnam(const char*, const char*);
+char*     tmpnam(char*);
+
+}
+
+//# 44 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988, 1992 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 23 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdlib.h" 1
+
+
+//# 80 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdlib.h"
+
+//# 24 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/string.h" 1
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 5 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/string.h" 2
+
+
+
+extern "C" {
+
+char*     strcat(char*, const char*);
+char*     strchr(const char*, int);
+int       strcmp(const char*, const char*);
+int       strcoll(const char*, const char*);
+char*     strcpy(char*, const char*);
+size_t    strcspn(const char*, const char*);
+char*     strdup(const char*);
+
+char*     strncat(char*, const char*, size_t);
+int       strncmp(const char*, const char*, size_t);
+char*     strncpy(char*, const char*, size_t);
+char*     strpbrk(const char*, const char*);
+char*     strrchr(const char*, int);
+size_t    strspn(const char*, const char*);
+char*     strstr(const char*, const char *);
+char*     strtok(char*, const char*);
+size_t    strxfrm(char*, const char*, size_t);
+
+}
+
+
+
+
+
+
+
+extern "C" {
+char*     index(const char*, int);
+char*     rindex(const char*, int);
+}
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/memory.h" 1
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 5 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/memory.h" 2
+
+
+extern "C" {
+
+void*     memalign(size_t, size_t);
+void*     memccpy(void*, const void*, int, size_t);
+void*     memchr(const void*, int, size_t);
+
+
+void*     memset(void*, int, size_t);
+int       ffs(int);
+size_t    getpagesize(void);
+void*     valloc(size_t);
+
+}
+
+
+
+
+
+
+
+
+
+extern "C" {
+void      bcopy(const void*, void*, size_t); // USG uses version in bcopy.c
+int       bcmp(const void*, const void*, int);
+void      bzero(void*, int);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 43 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/string.h" 2
+
+
+
+//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/memory.h" 1
+
+//# 49 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/memory.h"
+
+//# 26 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/unistd.h" 1
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 4 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/unistd.h" 2
+
+
+extern "C" {
+
+
+void _exit(int);
+
+
+
+
+unsigned  alarm(unsigned);
+int       brk(void*);
+int       chdir(const char*);
+int       chmod(const char*, int);
+int       chown(const char*, int, int);
+int       close(int);
+char*     crypt(const char*, const char*);
+int       dup(int);
+int       dup2(int, int);
+char*     encrypt(char*, int);
+int       execl(const char*, const char *, ...);
+int       execle(const char*, const char *, ...);
+int       execlp(const char*, const char*, ...);
+int       exect(const char*,  const char**,  char**);
+int       execv(const char*,  const char**);
+int       execve(const char*, const char**, char**);
+int       execvp(const char*,  const char**);
+int       fchown(int, int, int);
+int       fork(void);
+int       fsync(int);
+int       ftruncate(int, unsigned long);
+char*     getcwd(char*, int);
+int       getdomainname(char*, int);
+int       getdtablesize(void);
+
+int       getgroups(int, int*);
+int       geteuid(void);
+int       getegid(void);
+int       getgid(void);
+long      gethostid(void);
+int       gethostname(char*, int);
+int       getpgrp(...);
+int       getpid(void);
+int       getppid(void);
+char*     getlogin(void);
+char*     getpass(const char*);
+unsigned  getuid(void);
+int       ioctl(int, int, void*);
+int       isatty(int);
+int       link(const char*, const char*);
+int       mkstemp(char*);
+char*     mktemp(char*);
+int       nice(int);
+
+void volatile pause(void);
+
+
+
+int       pipe(int*);
+int       readlink(const char*, char*, int);
+int       rename(const char*, const char*);
+int       rmdir(const char*);
+void*     sbrk(int);
+int       syscall(int, ...);
+int       setgid(int);
+int       sethostname(const char*, int);
+int       setpgrp(...);
+int       setregid(int, int);
+int       setreuid(int, int);
+int       setuid(int);
+unsigned  sleep(unsigned);
+void      swab(void*, void*, int);
+int       symlink(const char*, const char*);
+int       truncate(const char*, unsigned long);
+char*     ttyname(int);
+int       ttyslot(void);
+// int       umask(int); /* commented out for now; wrong for SunOs4.1 */
+int       unlink(const char*);
+int       vfork(void);
+int       vadvise(int);
+int       vhangup(void);
+
+long      lseek(int, long, int);
+int       read(int, void*, size_t);
+int       write(int, const void*, size_t);
+int       access(const char*, int);
+
+int       flock(int, int);
+
+
+}
+
+
+
+
+//# 27 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdio.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ *  Please check the following before installing this file:
+ *
+ *  Make sure USG is #defined if you are on a USG system!
+ *
+ *  Check the value of _NFILE against the one in your /usr/include/stdio.h.
+ *  (USG only)
+ *
+ *  Check whether your libc.a sprintf function returns
+ *  an int (as do most) versus a char* (BSD), and (un)comment
+ *  the corresponding SPRINTF_RETURNS_INT line.
+ *
+ *  Check the value of BUFSIZ against the one in your /usr/include/stdio.h.
+ *
+ *  Carefully check the fields and order of _iobuf declaration against
+ *  the one in your /usr/include/stdio.h. Xenix-based systems
+ *  may need some re-ordering of _iobuf. fields.
+ *
+ *  Note that some _IOXXX #defines may not be present in your
+ *  /usr/include/stdio.h. This is ok, so long as the ones that
+ *  are present in both are set to the same values.
+ *
+ *  Some of the prototypes refer to functions that may not be
+ *  present in your libc.a. This is ok so long as you do not
+ *  actually call such functions.
+ *
+ */
+
+
+
+//#pragma interface
+
+
+
+
+
+
+
+// Note:  The #define _stdio_h is at the end of this file,
+// in case #include_next  finds an installed version of this
+// same file -- we want it to continue until it finds the C version.
+
+/*
+   HAVE_VPRINTF should be set if vprintf is in libc.a
+   HAVE_SETVBUF should be set if setvbuf is in libc.a
+   HAVE_SETLINEBUF should be set if setlinebuf in libc.a
+
+   The following are probably correct for the listed systems
+
+*/
+
+
+
+
+
+//# 85 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdio.h"
+
+
+
+//# 158 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdio.h"
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/stdio.h" 1
+/*	@(#)stdio.h	4.6	(ULTRIX)	3/1/91	*/
+/************************************************************************
+ *									*
+ *			Copyright (c) 1985 by				*
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   This software is  derived  from  software  received  from  the	*
+ *   University    of   California,   Berkeley,   and   from   Bell	*
+ *   Laboratories.  Use, duplication, or disclosure is  subject  to	*
+ *   restrictions  under  license  agreements  with  University  of	*
+ *   California and with AT&T.						*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+/************************************************************************
+ *			Modification History
+ *
+ *	Mitch Condylis 28-Feb-1991
+ *	Changed _file member of FILE structure from char to short
+ *	as part of work to increase max number of open file descriptors.
+ *
+ *	Mike Thomas, 7-Sep-1990
+ * 016	Back out most of 015. Leave in explicit declarations.
+ *
+ * 	Mike Thomas, 21-Aug-1990
+ * 015	DECwest ANSI - change _filbuf to __filbuf for ANSI compliance.
+ *	Explicitly declare __filbuf under __STDC__.
+ *	Likewise flsbuf.
+ *
+ * 014  Mike Thomas, 08-Jun-90
+ *	Changed _POSIX_SOURCE reference back to POSIX.
+ *
+ * 013  Dan Smith, 23-Feb-90
+ *      Added const to several prototypes. More namespace protection.
+ *      Changed reference of POSIX to _POSIX_SOURCE.
+ *
+ *	Jon Reeves, 07-Dec-1989
+ * 012	Namespace protection.
+ *
+ *	Jon Reeves, 09-Nov-1989
+ * 011	Fix putc properly: could still sign-extend in some cases before.
+ *
+ *	Linda Wilson, 06-Oct-1989
+ * 010  Declare sprintf as int for std conformance
+ *
+ *	Jon Reeves, 25-Aug-1989
+ * 009	Fix putc[har] for 8-bit mode (unsigned int->char)
+ *
+ *	Jon Reeves, 18-Jul-1989
+ * 008	Add getw, putw for X/Open conformance.
+ *
+ *	Jon Reeves, 31-May-1989
+ * 007	ANSI conformance; clean up rogue comments.  sprintf is still
+ *	wrong.
+ *
+ *	Lu Anne Van de Pas, 02-Jun-1986
+ * 006  Added ending "/" to P_tmpdir string.
+ *
+ *	David L Ballenger, 22-Nov-1985
+ * 005	Correct definition of sprintf() for System V environment.
+ *
+ *	David L Ballenger, 01-Aug-1985
+ * 004	Add _IOAPPEND flag for files opened with "A" or "A+".
+ *
+ *	David L Ballenger, 26-Jun-1985
+ * 003	Add changes so that FILE structures are allocated dynamically.
+ *
+ *	Larry Cohen, 23-April-1985
+ *      - change NFILE from 20 to 64
+ *
+ *	David L Ballenger, 13-Mar-1985
+ * 0001	Add System V definitions.
+ ************************************************************************/
+
+//# 1 "/usr/include/ansi_compat.h" 1
+/*
+ * 	@(#)ansi_compat.h	4.4	(ULTRIX)	10/8/90
+ */
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1990 by			        *
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+
+/*
+ *   To avoid namespace pollution when using the ULTRIX header files under the
+ * DEC ANSI compiler, all user-visible header files were modifed to reference
+ * ANSI-style predefined macro name rather than their traditional names
+ * (__ultrix vice ultrix).  Every file which accesses a predefined macro name
+ * must include this file before any other files are included or the macros
+ * are tested.
+ *
+ *   In strict ANSI mode, the appropriate ANSI-style macros are already
+ * defined and the redefinitions in this file will not be seen.  When using
+ * pcc, the traditional macro names are defined and this file will define
+ * ANSI-style equivalents of the traditional names.  When using the DEC C
+ * compiler, both the traditional and ANSI predefined macro names are
+ * available so the definitions in this file are not made visible.
+ *
+ */
+
+
+//# 116 "/usr/include/ansi_compat.h"
+
+//# 89 "/usr/include/stdio.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+			/* Note: spacing must match, too, to avoid warnings */
+
+
+
+
+extern	struct	_iobuf {
+	int	_cnt;
+	char	*_ptr;
+	char	*_base;
+	int	_bufsiz;
+	short	_flag;
+	short	_file;
+} _iob[3 ];
+typedef	struct _iobuf	FILE;
+
+typedef	long	fpos_t;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*	fseek() values	*/
+
+
+
+
+
+
+
+/*
+ *  prototype
+ *
+ */
+extern int 	getc( FILE *__stream );
+extern int	getchar( void );
+extern int	putc( int __c, FILE *__stream);
+extern int	putchar( int __c);
+extern int	feof( FILE *__stream );
+extern int	ferror( FILE *__stream );
+extern int	fileno( FILE *__stream );
+extern int	_filbuf( FILE *p);
+extern int	_flsbuf( unsigned char x , FILE *p);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+typedef char *va_list;
+
+/*
+ *  prototypes
+ *
+ */
+extern void	clearerr( FILE *__stream);
+extern int	fclose( FILE *__stream );
+extern FILE *	c_proto_fdopen ( int __filedes, char *__type );
+extern int	fflush( FILE *__stream );
+extern int	fgetc( FILE *__stream );
+extern int	fgetpos( FILE *__stream, fpos_t *__pos );
+extern char *	fgets( char *__s, int __n, FILE *__stream );
+extern FILE *	c_proto_fopen ( const char *__filename, const char *__type );
+extern int	c_proto_fprintf ( FILE *__stream, const char *__format, ... );
+extern int	fputc( int __c, FILE *__stream );
+extern int	c_proto_fputs ( const char *__s, FILE *__stream );
+extern size_t	fread( void *__ptr, size_t __size,
+			size_t __nitems, FILE *__stream );
+extern FILE *	c_proto_freopen ( const char *__filename, const char *__type,
+			FILE *__stream );
+extern int	c_proto_fscanf ( FILE *__stream, const char *__format, ... );
+extern int	fseek( FILE *__stream, long __offset, int __ptrname );
+extern int	fsetpos( FILE *__stream, const fpos_t *__pos );
+extern long	ftell( FILE *__stream );
+extern size_t	c_proto_fwrite ( const void *__ptr, size_t __size,
+			size_t __nitems, FILE *__stream );
+extern char *	gets( char *__s );
+extern void	c_proto_perror ( const char *__s );
+extern FILE  *	c_proto_popen (const char *__command, const char *__type );
+extern int	c_proto_printf ( const char *__format, ... );
+extern int	c_proto_puts ( const char *__s );
+extern int	remove( const char *__filename );
+extern int	rename( const char *__from, const char *__to );
+extern void	c_proto_rewind ( FILE *__stream );
+extern int	c_proto_scanf ( const char *__format, ... );
+extern void	c_proto_setbuf ( FILE *__stream, char *__buf );
+extern int	c_proto_setvbuf ( FILE *__stream, char *__buf,
+			int __type, size_t __size );
+extern int	c_proto_sscanf ( const char *__s, const char *__format, ... );
+extern FILE *	tmpfile( void );
+extern char *	tmpnam( char *__s );
+extern int	ungetc( int __c, FILE *__stream );
+extern int	c_proto_vfprintf ( FILE *__stream, const char *__format, va_list __ap );
+extern int	c_proto_vprintf ( const char *__format, va_list __ap );
+extern int	c_proto_vsprintf ( char *__s, const char *__format, va_list __ap);
+
+
+extern char *	c_proto_tempnam ( const char *__dir, const char *__pfx);
+extern int	c_proto_putw ( int __w, FILE *__stream );
+extern int	getw(FILE *__stream);
+extern int	pclose( FILE *__stream );
+
+
+//# 298 "/usr/include/stdio.h"
+
+
+
+/* function prototype */
+extern int	c_proto_sprintf ( char *__s, const char *__format, ... );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 189 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdio.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+
+
+extern "C" {
+
+//# 239 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stdio.h"
+
+int    fclose(FILE*);
+FILE*  fdopen(int, const char*);
+int    fflush(FILE*);
+int    fgetc(FILE*);
+char*  fgets(char*, int, FILE *);
+FILE*  fopen(const char*, const char*);
+int    fprintf(FILE*, const char* ...);
+int    fputc(int, FILE*);
+int    fputs(const char*, FILE*);
+size_t fread(void*, size_t, size_t, FILE*);
+
+
+
+FILE*  freopen(const char*, const char*, FILE*);
+
+int    fscanf(FILE*, const char* ...);
+int    fseek(FILE*, long, int);
+long   ftell(FILE *);
+unsigned int fwrite(const void*, unsigned int, unsigned int, FILE*);
+char*  gets(char*);
+int    getw(FILE*);
+int    pclose(FILE*);
+void   perror(const char*);
+FILE*  popen(const char*, const char*);
+int    printf(const char* ...);
+int    puts(const char*);
+int    putw(int, FILE*);
+int    rewind(FILE*);
+int    scanf(const char* ...);
+int    setbuf(FILE*, char*);
+int    setbuffer(FILE*, char*, int);
+int    setlinebuf(FILE*);
+int    setvbuf(FILE*, char*, int, unsigned int);
+int    sscanf(char*, const char* ...);
+FILE*  tmpfile();
+int    ungetc(int, FILE*);
+int    vfprintf(FILE*, const char*, ...);
+
+// Third arg to vprintf must be '...' for some machines, & doesn't
+// hurt for others.
+
+int    vprintf(const char*, ... );
+
+
+
+
+
+char*  sprintf(char*, const char*, ...);
+char*  vsprintf(char*, const char*, ...);
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 28 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/errno.h" 1
+
+
+extern "C" {
+
+
+
+
+
+//# 1 "/usr/include/errno.h" 1
+/*	@(#)errno.h	2.4	(ULTRIX)	11/10/89	*/
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1984, 1987 by			*
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   This software is  derived  from  software  received  from  the	*
+ *   University    of   California,   Berkeley,   and   from   Bell	*
+ *   Laboratories.  Use, duplication, or disclosure is  subject  to	*
+ *   restrictions  under  license  agreements  with  University  of	*
+ *   California and with AT&T.						*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+/*
+ *
+ *   Modification history:
+ *
+ * 10 Jul 89 -- jlr
+ *	Added ENOSYS for POSIX
+ *
+ * 13 Jan 88 -- map
+ *	Added ENOLCK for POSIX
+ *
+ * 4 Aug 86 -- chet
+ *	Moved NFS error codes to match SUN's.
+ *
+ * 24 Feb 86 -- depp
+ *	Added EALIGN error code
+ *
+ * 28-Mar-85 -- David L Ballenger
+ *	Add mapping of System V error numbers from BRL package.
+ *
+ * 01 Mar 85 -- depp
+ *	Added System V IPC error codes error codes.
+ *
+ */
+
+/*
+ * Error codes
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* math software */
+
+
+
+/* non-blocking and interrupt i/o */
+
+
+
+/* ipc/network software */
+
+	/* argument errors */
+
+
+
+
+
+
+
+
+
+
+
+
+
+	/* operational errors */
+
+
+
+
+
+
+
+
+
+
+
+
+
+	/* */
+
+
+
+/* should be rearranged */
+
+
+
+
+/* quotas & mush */
+
+
+
+
+/* NFS error codes */
+
+
+
+/* IPC errors
+ */
+
+
+
+/* Alignment error of some type (i.e., cluster, page, block ...) */
+
+
+/* System V mappings from BRL package
+ */
+
+
+/* POSIX errnos
+ */
+
+
+
+/*
+ * DUP (Diagnostic/Utilities Protocol) related error numbers.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* External definition of errno from System V
+ */
+
+extern int errno;
+
+//# 9 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/errno.h" 2
+
+
+
+
+extern char*    sys_errlist[];
+extern int      sys_nerr;
+extern int      errno;
+void      perror(const char*);
+char*     strerr(int);
+
+
+}
+
+
+//# 29 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 2
+
+
+
+//# 45 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+
+/*
+Copyright (C) 1988, 1992 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+  arithmetic, etc. functions on built in types
+*/
+
+
+
+
+//#pragma interface
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 31 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988, 1992 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+//# 31 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/std.h"
+
+//# 32 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/math.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+
+
+
+
+
+
+
+
+//# 64 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/math.h"
+
+extern "C" {
+
+double  acos(double);
+double  acosh(double);
+double  asin(double);
+double  asinh(double);
+double  atan(double);
+double  atan2(double, double);
+double  atanh(double);
+double  cbrt(double);
+double  ceil(double);
+double  copysign(double,double);
+double  cos(double);
+double  cosh(double);
+double  drem(double,double);
+double  erf(double);
+double  erfc(double);
+double  exp(double);
+double  expm1(double);
+double  fabs(double);
+double  finite(double);
+double  floor(double);
+double  frexp(double, int*);
+double  gamma(double);
+double  hypot(double,double);
+double  infnan(int);
+
+/* see below */
+int     isinf(double);
+int     isnan(double);
+
+double  j0(double);
+double  j1(double);
+double  jn(int, double);
+double  ldexp(double, int);
+double  lgamma(double);
+double  log(double);
+double  log10(double);
+double  log1p(double);
+double  logb(double);
+double  modf(double, double*);
+double  pow(double, double);
+double  rint(double);
+double  scalb(double, int);
+double  sin(double);
+double  sinh(double);
+double  sqrt(double);
+double  tan(double);
+double  tanh(double);
+double  y0(double);
+double  y1(double);
+double  yn(int, double);
+
+double aint(double);
+double anint(double);
+int irint(double);
+int nint(double);
+}
+
+
+
+/* libg++ doesn't use this since it is not available on some systems */
+
+/* the following ifdef is just for compiling OOPS */
+
+
+struct libm_exception
+{
+  int type;
+  char* name;
+  double arg1, arg2, retval;
+};
+
+
+
+
+
+
+
+
+extern "C" int matherr(libm_exception*);
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/values.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 150 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/values.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 149 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/math.h" 2
+
+
+/* On some systems, HUGE ought to be MAXFLOAT or IEEE infinity */
+
+
+
+
+
+
+/* sequents don't supply these. The following should suffice */
+
+
+
+
+
+
+
+
+
+/* These seem to be sun & sysV names of these constants */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 33 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h" 2
+
+
+typedef void (*one_arg_error_handler_t)(const char*);
+typedef void (*two_arg_error_handler_t)(const char*, const char*);
+
+long         gcd(long, long);
+long         lg(unsigned long);
+double       pow(double, long);
+long         pow(long, long);
+
+double       start_timer();
+double       return_elapsed_time(double last_time = 0.0);
+
+char*        itoa(long x, int base = 10, int width = 0);
+char*        itoa(unsigned long x, int base = 10, int width = 0);
+
+char*        itoa(long long x, int base = 10, int width = 0);
+char*        itoa(unsigned long long x, int base = 10, int width = 0);
+
+char*        dtoa(double x, char cvt = 'g', int width = 0, int prec = 6);
+
+char*        hex(long x, int width);
+char*        hex(unsigned long x, int width);
+char*        hex(int x, int width);
+char*        hex(short x, int width);
+char*        hex(unsigned int x, int width);
+char*        hex(unsigned short x, int width);
+
+char*        oct(long x, int width);
+char*        oct(unsigned long x, int width);
+char*        oct(int x, int width);
+char*        oct(short x, int width);
+char*        oct(unsigned int x, int width) ;
+char*        oct(unsigned short x, int width);
+
+char*        dec(long x, int width);
+char*        dec(unsigned long x, int width);
+char*        dec(int x, int width);
+char*        dec(short x, int width);
+char*        dec(unsigned int x, int width) ;
+char*        dec(unsigned short x, int width);
+
+char*        form(const char* fmt ...);
+char*        chr(char ch, int width = 0);
+char*        str(const char* s, int width = 0);
+
+unsigned int hashpjw(const char*);
+unsigned int multiplicativehash(int);
+unsigned int foldhash(double);
+
+extern void default_one_arg_error_handler(const char*);
+extern void default_two_arg_error_handler(const char*, const char*);
+
+extern two_arg_error_handler_t lib_error_handler;
+
+extern two_arg_error_handler_t
+       set_lib_error_handler(two_arg_error_handler_t f);
+
+
+double abs(double arg);
+float abs(float arg);
+short abs(short arg);
+long abs(long arg);
+int sign(long arg);
+int sign(double arg);
+long sqr(long arg);
+double sqr(double arg);
+int even(long arg);
+int odd(long arg);
+long lcm(long x, long y);
+void setbit(long& x, long b);
+void clearbit(long& x, long b);
+int testbit(long x, long b);
+
+signed char min(signed char a, signed char b);
+unsigned char min(unsigned char a, unsigned char b);
+
+signed short min(signed short a, signed short b);
+unsigned short min(unsigned short a, unsigned short b);
+
+signed int min(signed int a, signed int b);
+unsigned int min(unsigned int a, unsigned int b);
+
+signed long min(signed long a, signed long b);
+unsigned long min(unsigned long a, unsigned long b);
+
+float min(float a, float b);
+
+double min(double a, double b);
+
+signed char max(signed char a, signed char b);
+unsigned char max(unsigned char a, unsigned char b);
+
+signed short max(signed short a, signed short b);
+unsigned short max(unsigned short a, unsigned short b);
+
+signed int max(signed int a, signed int b);
+unsigned int max(unsigned int a, unsigned int b);
+
+signed long max(signed long a, signed long b);
+unsigned long max(unsigned long a, unsigned long b);
+
+float max(float a, float b);
+
+double max(double a, double b);
+
+
+
+
+inline double abs(double arg)
+{
+  return (arg < 0.0)? -arg : arg;
+}
+
+inline float abs(float arg)
+{
+  return (arg < 0.0)? -arg : arg;
+}
+
+inline short abs(short arg)
+{
+  return (arg < 0)? -arg : arg;
+}
+
+inline long abs(long arg)
+{
+  return (arg < 0)? -arg : arg;
+}
+
+inline int sign(long arg)
+{
+  return (arg == 0) ? 0 : ( (arg > 0) ? 1 : -1 );
+}
+
+inline int sign(double arg)
+{
+  return (arg == 0.0) ? 0 : ( (arg > 0.0) ? 1 : -1 );
+}
+
+inline long sqr(long arg)
+{
+  return arg * arg;
+}
+
+inline double sqr(double arg)
+{
+  return arg * arg;
+}
+
+inline int even(long arg)
+{
+  return !(arg & 1);
+}
+
+inline int odd(long arg)
+{
+  return (arg & 1);
+}
+
+inline long lcm(long x, long y)
+{
+  return x / gcd(x, y) * y;
+}
+
+inline void setbit(long& x, long b)
+{
+  x |= (1 << b);
+}
+
+inline void clearbit(long& x, long b)
+{
+  x &= ~(1 << b);
+}
+
+inline int testbit(long x, long b)
+{
+  return ((x & (1 << b)) != 0);
+}
+
+
+
+
+//# 46 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h" 2
+
+
+//# 65 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h"
+
+
+// Take the nice stuff that the regular sumachine.h provides
+extern "C" {
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h" 1
+
+
+
+/*
+ *    Define a ``Standard Unix Machine''
+ *
+ *    By whatever means are available in /lib/cpp, figure out
+ *    what type of operating system, maker, machine architecture
+ *    and architecture instance we are on.
+ *
+ *    OPSYS_TYPE	- the type of operating system (e.g. vms)
+ *    OPSYS_SUBTYPE	- the subtype of operating system (e.g. bsd, sys5, etc)
+ *    OPSYS_MFR		- the manufacturer (e.g. Hewlett-Packard)
+ *    OPSYS_VERS	- the operating system version (e.g. sun 4.0)
+ *
+ *    CPU_TYPE		- the architecture (e.g. 68K)
+ *    CPU_MODEL		- the architecture instance (e.g. 68010)
+ *
+ *    $Revision: 1.8 $
+ *    $Date: 1995/05/07 18:57:48 $
+ *    $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+ *
+ *    This file should be #included as the 1st line of each and every .c file
+ *
+ *    It ensures that the environment which those src files expect exists
+ *    either by fiat or by faking it where the host operating system is not
+ *    up to snuff.
+ */
+
+/*
+ *    The OPSYS specifics
+ *
+ *    Parameterized with the best known /lib/cpp predefines
+ */
+
+
+
+
+
+
+
+
+
+/*
+ *    Note that everyone defines the symbol unix except IBM's AIX 3.1
+ *    which doesn't define unix but DOES define the symbol _AIX
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *    WATCHOUT - the newer gcc doesn't define __GNU__
+ *    So we may have to define __GNU__ ourselves
+ *
+ *    __GNU__ is the old way
+ *    __GNUC__ is the new way
+ *
+ *    Use gcc -v somefile.c to determine what is being passed.
+ */
+
+/*
+ *    GNU doesn't know about any opsys-specific
+ *    cpp tokens, so we must figure them out for it.
+ *    GNU does however know about architecture-tokens
+ */
+//# 93 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+/* then if  defined(vax) || defined(mips) */
+/* then if >= ultrix 4.2 => defined(__vax) || defined(__mips) */
+
+
+/*
+ *    gcc 1.39 uses the words mips and __mips__ while Ultrix 4.2 has
+ *    been coded in terms of __mips (only!) - so we have to hack it.
+ *
+ *    See  from Ultrix 4.2
+ *
+ *    Unfortunately also,  is turned on only if __STDC__
+ *    is undefined.  gcc defines __STDC__ and you can't undef it.  So
+ *    We are forced here (as with math.h) to copy  and
+ *    strip off the #if !defined(__STDC__).
+ *
+ *    Further unfortunateness occurs in that the only way we have of
+ *    discovering that we're in Ultrix 4.2 is to #include
+ *    and check for the vector unit support #defined there.  However
+ *    we need the  workarounds to be defined first in
+ *    order to get the full effect of .
+ *
+ *    So we have to do all this stuff under any and all Ultrix versions.
+ *
+ *    We also have to work around the fact that the GNU (gcc 1.95.0 and later)
+ *    compilers may be defining this stuff already
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* end of  fakeout */
+
+
+/*
+ *   The r2000 and r3000 are indistinguishable (so far)
+ */
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/sys/types.h" 1
+
+
+extern "C"
+{
+
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 10 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/sys/types.h" 2
+
+
+
+
+
+//# 1 "/usr/include/sys/types.h" 1
+/* @(#)types.h	4.3	(ULTRIX)	2/28/91 */
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1984 - 1989 by			*
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   This software is  derived  from  software  received  from  the	*
+ *   University    of   California,   Berkeley,   and   from   Bell	*
+ *   Laboratories.  Use, duplication, or disclosure is  subject  to	*
+ *   restrictions  under  license  agreements  with  University  of	*
+ *   California and with AT&T.						*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+
+/* ------------------------------------------------------------------------
+ * Modification History: /sys/h/types.h
+ *
+ * 20-Dec-1989  Larry Scott
+ *	added #ifdef's for compliance
+ *
+ * 16-Jun-1989	Jon Reeves
+ *	size_t must be unsigned, per ANSI and X/Open
+ *
+ * 05-Jun-1989	Jon Reeves
+ *	Change latch name for size_t; it's in lots of headers.
+ *
+ * 12-May-1989	Todd M. Katz		TMK0001
+ *	Added volatile type definitions: vu_long, vu_short, vu_char,
+ *	v_long, v_short, and v_char.
+ *
+ * 08-May-1989 -- Ken Lesniak
+ *	Conditionalize items also defined in time.h.
+ *
+ *  1-Feb-89 -- jmartin
+ *	typedef s_char
+ *
+ * 15-Jan-88	lp
+ *	Merge of final 43BSD changes.
+ *
+ * 31-August-1987 -- Mark Parenti
+ *	Add definitions needed for POSIX compliance
+ *
+ * 27-April-1987 -- Larry Cohen
+ *	Modify the typedef "fd_set" to accomodate 64 file descriptors.
+ *
+ * 	David L Ballenger, 8-Mar-1985
+ * 0002	Add types for System V compatibility.
+ *
+ * 23 Oct 84 -- jrs
+ *	Add ifdef so we can be nested without problem
+ *	Derived from 4.2BSD, labeled:
+ *		types.h 6.2	84/06/09
+ *
+ * -----------------------------------------------------------------------
+ */
+
+
+
+
+
+
+
+//# 1 "/usr/include/ansi_compat.h" 1
+/*
+ * 	@(#)ansi_compat.h	4.4	(ULTRIX)	10/8/90
+ */
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1990 by			        *
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+
+/*
+ *   To avoid namespace pollution when using the ULTRIX header files under the
+ * DEC ANSI compiler, all user-visible header files were modifed to reference
+ * ANSI-style predefined macro name rather than their traditional names
+ * (__ultrix vice ultrix).  Every file which accesses a predefined macro name
+ * must include this file before any other files are included or the macros
+ * are tested.
+ *
+ *   In strict ANSI mode, the appropriate ANSI-style macros are already
+ * defined and the redefinitions in this file will not be seen.  When using
+ * pcc, the traditional macro names are defined and this file will define
+ * ANSI-style equivalents of the traditional names.  When using the DEC C
+ * compiler, both the traditional and ANSI predefined macro names are
+ * available so the definitions in this file are not made visible.
+ *
+ */
+
+
+//# 116 "/usr/include/ansi_compat.h"
+
+//# 79 "/usr/include/sys/types.h" 2
+
+
+
+
+/*
+ * Basic system types and major/minor device constructing/busting macros.
+ */
+
+/* major part of a device */
+
+
+/* minor part of a device */
+
+
+/* make a device number */
+
+
+typedef	unsigned char	u_char;
+typedef	unsigned short	u_short;
+typedef	unsigned int	u_int;
+typedef	unsigned int	uint;		/* sys V compatibility */
+typedef	unsigned long	u_long;
+typedef	unsigned short	ushort;		/* sys III compat */
+
+typedef	volatile char		v_char;
+typedef	volatile short		v_short;
+typedef	volatile long		v_long;
+typedef	volatile unsigned char	vu_char;
+typedef	volatile unsigned short	vu_short;
+typedef	volatile unsigned long	vu_long;
+
+typedef
+
+	signed
+
+		char	s_char;
+
+
+
+
+
+
+
+
+
+typedef	struct	_physadr { int r[1]; } *physadr;
+/*
+ * WARNING:
+ * this must match the definition of kernel jmpbuf's in machine/pcb.h
+ */
+typedef	struct	label_t	{
+	int	val[12];
+} label_t;
+
+
+typedef	struct	_quad { long val[2]; } quad;
+typedef	long	daddr_t;
+typedef	char *	caddr_t;
+typedef u_long	gno_t;
+typedef short	cnt_t;			/* sys V compatibility */
+typedef	long	swblk_t;
+typedef long	paddr_t;		/* sys V compatibility */
+typedef	long	audit_ID_t;
+
+
+typedef	short	dev_t;
+typedef short	gid_t;			/* POSIX compliance    */
+typedef	unsigned long	ino_t;
+typedef unsigned short	mode_t;		/* POSIX compliance    */
+typedef short	nlink_t;		/* POSIX compliance    */
+typedef	int	off_t;
+
+
+typedef int	pid_t;			/* POSIX compliance    */
+
+typedef short	uid_t;			/* POSIX compliance    */
+
+
+typedef int	time_t;
+
+
+
+
+
+
+
+
+
+typedef int	clock_t;			/* POSIX compliance */
+
+typedef long	key_t;			/* sys V compatibility */
+
+
+
+
+/*
+ * The maximum number of file descriptors is now a configurable option
+ * (max_nofile variable in /sys/conf/{mips|vax}/param.c).
+ * The getdtablesize(2) system call should be used to obtain the
+ * current limit. The value returned by getdtablesize() must be greater
+ * than 64, and less than or equal to MAX_NOFILE in types.h . The
+ * MAX_NOFILE define is needed for backward compatability with broken
+ * programs that need a static sized array for selecting. These programs
+ * should be modified to use the getdtablesize() interface for sizing.
+ */
+
+
+/*
+ * Select uses bit masks of file descriptors in longs.
+ * These macros manipulate such bit fields (the filesystem macros use chars).
+ * FD_SETSIZE may be defined by the user, but the default here
+ * should be >= NOFILE (param.h).
+ */
+
+
+
+
+/* How many things we'll allow select to use. 0 if unlimited */
+
+typedef long	fd_mask;
+
+
+
+
+
+
+typedef	struct fd_set {
+	fd_mask	fds_bits[(((4096	 )+(( (sizeof(fd_mask) * 8		)	)-1))/( (sizeof(fd_mask) * 8		)	)) ];
+} fd_set;
+
+
+
+
+
+
+
+
+//# 15 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/sys/types.h" 2
+
+
+
+
+
+
+}
+
+
+
+
+//# 199 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/signal.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1989 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+extern "C" {
+
+
+
+
+//# 1 "/usr/include/signal.h" 1
+/*	@(#)signal.h	2.8	(ULTRIX)	11/9/89	*/
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1987-1989 by			*
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   This software is  derived  from  software  received  from  the	*
+ *   University    of   California,   Berkeley,   and   from   Bell	*
+ *   Laboratories.  Use, duplication, or disclosure is  subject  to	*
+ *   restrictions  under  license  agreements  with  University  of	*
+ *   California and with AT&T.						*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+/************************************************************************
+ *			Modification History				*
+ *									*
+ *	Debby Haeck 11/14/90						*
+ *		added new Vector Arithmetic Exception handling codes	*
+ *	Debby Haeck 9/4/90						*
+ *		added new u_code for vector support			*
+ *		ILL_VECOP_FAULT, ILL_VECINST_FAULT, TERM_VECT_HARD and	*
+ *		TERM_VECT_TOOMANY					*
+ *	Tak Yin Wong 3/390                                              *
+ *		Add ifdef's for POSIX and XOPEN                         *
+ *	Linda Wilson 9/12/89                                            *
+ *		typedef sigset_t for X/OPEN			        *
+ *	Linda Wilson 9/12/89                                            *
+ *      	ifdef out sigmask for POSIX                             *
+ *	Jon Reeves 7/14/89						*
+ *		Add X/Open mandated function declarations.		*
+ *	Jon Reeves 5/16/89						*
+ *		Add new BRK_STACKOVERFLOW def from MIPS 2.0 cmplrs	*
+ *	Jon Reeves 5/12/89						*
+ *		Add raise() and sig_atomic_t for ANSI			*
+ *	Mark Parenti 2/06/88						*
+ *		Change SA_CLDSTOP to SA_NOCLDSTOP per POSIX change	*
+ *	Fred Glover 1/12/88						*
+ *		Add SIGLOST - server crash Sys-V lock notification      *
+ *									*
+ *	Larry Cohen 10/1/85						*
+ *		Add SIGWINCH - window change signal			*
+ *									*
+ *	Greg Depp  25 Jun 85						*
+ *	Moved SIGUSR1 and SIGUSR2 to 30 and 31 to conform with Berkeley *
+ *									*
+ *	David L Ballenger, 28-Mar-1985					*
+ * 0001 Add definitions for System V compatibility			*
+ *									*
+ ************************************************************************/
+
+
+
+
+
+
+
+
+//# 1 "/usr/include/ansi_compat.h" 1
+/*
+ * 	@(#)ansi_compat.h	4.4	(ULTRIX)	10/8/90
+ */
+
+/************************************************************************
+ *									*
+ *			Copyright (c) 1990 by			        *
+ *		Digital Equipment Corporation, Maynard, MA		*
+ *			All rights reserved.				*
+ *									*
+ *   This software is furnished under a license and may be used and	*
+ *   copied  only  in accordance with the terms of such license and	*
+ *   with the  inclusion  of  the  above  copyright  notice.   This	*
+ *   software  or  any  other copies thereof may not be provided or	*
+ *   otherwise made available to any other person.  No title to and	*
+ *   ownership of the software is hereby transferred.			*
+ *									*
+ *   The information in this software is subject to change  without	*
+ *   notice  and should not be construed as a commitment by Digital	*
+ *   Equipment Corporation.						*
+ *									*
+ *   Digital assumes no responsibility for the use  or  reliability	*
+ *   of its software on equipment which is not supplied by Digital.	*
+ *									*
+ ************************************************************************/
+
+/*
+ *   To avoid namespace pollution when using the ULTRIX header files under the
+ * DEC ANSI compiler, all user-visible header files were modifed to reference
+ * ANSI-style predefined macro name rather than their traditional names
+ * (__ultrix vice ultrix).  Every file which accesses a predefined macro name
+ * must include this file before any other files are included or the macros
+ * are tested.
+ *
+ *   In strict ANSI mode, the appropriate ANSI-style macros are already
+ * defined and the redefinitions in this file will not be seen.  When using
+ * pcc, the traditional macro names are defined and this file will define
+ * ANSI-style equivalents of the traditional names.  When using the DEC C
+ * compiler, both the traditional and ANSI predefined macro names are
+ * available so the definitions in this file are not made visible.
+ *
+ */
+
+
+//# 116 "/usr/include/ansi_compat.h"
+
+//# 74 "/usr/include/signal.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+					/* absent or non-vector capable sys */
+/* CHME, CHMS, CHMU are not yet given back to users reasonably */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* the following are used to for Vector Arithmetic Exception handling */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Add System V signal definitions (DLB001) */
+
+
+
+
+
+
+
+/*
+ * Codes for the mips break instruction.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Accesses to sig_atomic_t are atomic, even with async interrupts.
+   Not an issue for us, but ANSI requires the definition. */
+typedef long	sig_atomic_t;
+typedef int sigset_t;	/* type used for sigsetops() functions  */
+
+
+/*
+ * Signal vector "template" used in sigvec call.
+ */
+struct	sigvec {
+	void	 (*sv_handler)();	/* signal handler */
+	sigset_t sv_mask;		/* signal mask to apply */
+	int	sv_flags;		/* see signal options below */
+};
+
+
+/*
+ * The following structure must be exactly the same as the above structure
+ * with the names changed for POSIX compliance.
+ */
+struct	sigaction {
+	void	 (*sa_handler)();	/* signal handler */
+	sigset_t sa_mask;		/* signal mask to apply */
+	int	 sa_flags;		/* see signal options below */
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Defines for sigprocmask() call. POSIX.
+ */
+
+
+
+
+
+
+/*
+ * Structure used in sigstack call.
+ */
+struct	sigstack {
+	char	*ss_sp;			/* signal stack pointer */
+	int	ss_onstack;		/* current status */
+};
+
+/*
+ * Information pushed on stack when a signal is delivered.
+ * This is used by the kernel to restore state following
+ * execution of the signal handler.  It is also made available
+ * to the handler to allow it to properly restore state if
+ * a non-standard exit is performed.
+ *
+//#ifdef __vax
+ *	XXX - sigcontext needs updating per 4.3BSD - rr
+ *
+//#endif __vax
+//#ifdef __mips
+ * WARNING: THE sigcontext MUST BE KEPT CONSISTENT WITH /usr/include/setjmp.h
+ * AND THE LIBC ROUTINES setjmp() AND longjmp()
+//#endif __mips
+ */
+struct	sigcontext {
+
+	/*
+	 * BEGIN REGION THAT MUST CORRESPOND WITH setjmp.h
+	 * BEGIN REGION THAT MUST CORRESPOND WITH A jmp_buf
+	 */
+
+	int	sc_onstack;		/* sigstack state to restore */
+	int	sc_mask;		/* signal mask to restore */
+
+
+
+
+
+
+	int	sc_pc;			/* pc at time of signal */
+	/*
+	 * General purpose registers
+	 */
+	int	sc_regs[32];	/* processor regs 0 to 31 */
+	int	sc_mdlo;	/* mul/div low */
+	int	sc_mdhi;	/* mul/div high */
+	/*
+	 * Floating point coprocessor state
+	 */
+	int	sc_ownedfp;	/* fp has been used */
+	int	sc_fpregs[32];	/* fp regs 0 to 31 */
+	int	sc_fpc_csr;	/* floating point control and status reg */
+	int	sc_fpc_eir;	/* floating point exception instruction reg */
+	/*
+	 * END OF REGION THAT MUST AGREE WITH setjmp.h
+	 * END OF jmp_buf REGION
+	 */
+	/*
+	 * System coprocessor registers at time of signal
+	 */
+	int	sc_cause;	/* cp0 cause register */
+	int	sc_badvaddr;	/* cp0 bad virtual address */
+	int	sc_badpaddr;	/* cpu bd bad physical address */
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *  prototypes
+ *
+ */
+extern void	(*signal(int __sig, void(*__func)(int)))(int);
+int	raise( int __sig );
+int 	kill( pid_t __pid, int __sig );
+int 	sigemptyset( sigset_t *__set );
+int 	sigfillset( sigset_t *__set );
+int 	sigaddset( sigset_t *__set, int __signo );
+int	sigdelset( sigset_t *__set, int __signo );
+int	sigismember( const sigset_t *__set, int __signo );
+int 	sigaction( int __sig, const struct sigaction *__act,
+		struct sigaction *__oact );
+int 	sigprocmask( int __how, const sigset_t *__set, sigset_t *__oset );
+int	sigpending( sigset_t *__set );
+int	sigsuspend( const sigset_t *__sigmask );
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * Macro for converting signal number to a mask suitable for
+ * sigblock().
+ */
+
+
+
+
+
+
+//# 26 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/signal.h" 2
+
+
+
+
+// The Interviews folks call this SignalHandler. Might as well conform.
+// Beware: some systems think that SignalHandler returns int.
+typedef void (*SignalHandler) (int);
+
+extern SignalHandler signal(int sig, SignalHandler action);
+extern SignalHandler sigset(int sig, SignalHandler action);
+extern SignalHandler ssignal(int sig, SignalHandler action);
+extern int           gsignal (int sig);
+extern int           kill (int pid, int sig);
+extern int           killpg(int, int);
+extern int           siginterrupt(int, int);
+extern void          psignal(unsigned, char*);
+
+
+extern int           sigsetmask(int mask);
+extern int           sigblock(int mask);
+extern int           sigpause(int mask);
+extern int           sigvec(int sig, struct sigvec* v, struct sigvec* prev);
+
+
+// The Interviews version also has these ...
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+
+//# 200 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h" 2
+
+
+/*
+ *    Note that in Ultrix 4.2  renames all of the
+ *    previously-predefined cpp names to __names.  Also there is
+ *    new support for vector processors - TERM_VECT_HARD etc.
+ */
+
+//# 244 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+//# 263 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+//# 283 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+/* { */
+//# 298 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+//# 319 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+//# 328 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+//# 345 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 387 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+
+
+
+/*
+ *    THE CPU specifics
+ *
+ *    Parameterized with the best known /lib/cpp predefines
+ *    Set up for a middle-of-the-road machine.
+ */
+
+/*
+ *    DECstation	Processor
+ *       2100		  R2000 (slower clock)
+ *       3100		  R2000
+ *       5000		  R3000
+ *       5400		  R3000
+ *       ????		  R6000
+ */
+/*
+ *    We might be on the R3000 machine, but there is really
+ *    no way of distinguishing that from the src-code level.
+ *    The GNU people define some stuff, but its usually wrong.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 453 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+
+
+
+
+
+//# 471 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 512 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+/* will we be porting to this? */
+//# 522 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+//# 537 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+/*
+ *    The following MUST be literals else /lib/cpp cannot do
+ *    == operations on them.  Remember cpp does strcmps, not MATH
+ *
+ *    OPSYS_TYPE
+ *
+ *    #if OPSYS_TYPE == MD_opsystype
+ *    #endif
+ */
+
+
+
+
+
+
+/*
+ *    OPSYS_SUBTYPE
+ *
+ *    #if OPSYS_SUBTYPE == MD_opsyssubtype
+ *    #endif
+ */
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *    OPSYS_MFR
+ *
+ *    #if OPSYS_MFR == MD_opsysmfr
+ *    #endif
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *    OPSYS_VERS
+ *
+ *    #if OPSYS_VERS == MD_opsysvers
+ *    #endif
+ *    #if OPSYS_MFR == MD_opsysmfr && OPSYS_VERS <= MD_opsysvers
+ *    #endif
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *    CPU_TYPE
+ *
+ *    #if CPU_TYPE == MD_cputype
+ *    #endif
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ *    CPU_MODEL
+ *
+ *    #if CPU_MODEL == MD_modelname
+ *    #endif
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* don't add this stuff in if the query program display.sh is being run */
+
+//# 1754 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine.h"
+
+
+
+
+
+//# 69 "/sandbox/wbaker/wbaker0/source/mips/include/sumachine++.h" 2
+
+}
+
+// Always turn this stuff on b/c otherwise nothing works
+
+
+
+
+
+//# 1 "GctNameRef.List.cc" 2
+
+//# 1 "../../../../mips/include/Gct/genclasses.h" 1
+// -*- C++ -*-
+
+
+
+//
+// genclasses - The GNU Container Classes
+//
+// Expects to be included by Gct.h or where appropriate
+// especially before any genclass class headerfile is included.
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+// Make sure that we get all of the inline functions too but prevent duplicate
+// definition warnings.
+
+
+
+
+
+
+
+
+
+
+//
+// Turn off the definitions of these hash functions
+//
+//     unsigned hash(GctAstRef&)
+//
+// So that the following will match and be used instead:
+//
+//     unsigned hash(GctRef&)
+//
+// The idea is to not allow the various header files to
+// create (say) ``unsigned hash(GctAstRef&)'' but to use
+// ``hash(x)'' for the hash function anyway.  We just want
+// the hash() function used to be ``unsigned hash(GctRef&)''
+//
+
+
+//# 1 "../../../../mips/include/Gct/Reference.h" 1
+// -*- C++ -*-
+
+
+
+//
+// Classes:
+//     GctRef
+//     GctReferenceObject
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "../../../../mips/include/Gct/Reference/GctReferenceCount.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctReferenceCount class
+//
+// Expects to be included by Gct/Reference.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+#include <bool.h>
+
+//# 25 "../../../../mips/include/Gct/Reference/GctReferenceCount.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/GctErrorHandler.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctErrorHandler class
+//
+// Expects to be included by Gct.h
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 1
+
+
+
+// Compatibility with old library.
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+//#pragma interface
+
+
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+
+//#pragma interface
+
+
+/* KLUDGES!! */
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h" 1
+//# 12 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stddef.h"
+
+//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/streambuf.h" 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ostream; class streambuf;
+
+typedef long streamoff, streampos;
+
+struct _ios_fields { // The data members of an ios.
+    streambuf *_strbuf;
+    ostream* _tie;
+    long _width;
+    unsigned long _flags;
+    char _fill;
+    unsigned char _state;
+    unsigned short _precision;
+};
+
+
+enum state_value { _good = 0, _eof = 1,  _fail = 2, _bad  = 4 };
+
+
+class ios : public _ios_fields {
+  public:
+    enum io_state { goodbit=0, eofbit=1, failbit=2, badbit=4 };
+    enum open_mode {
+	in=1,
+	out=2,
+	ate=4,
+	app=8,
+	trunc=16,
+	nocreate=32,
+	noreplace=64 };
+    enum seek_dir { beg, cur, end};
+    enum { skipws=01, left=02, right=04, internal=010,
+	   dec=020, oct=040, hex=0100,
+	   showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+	   scientific=04000, fixed=0100000, unitbuf=020000, stdio=040000,
+	   dont_close=0x80000000 //Don't close streambuf when destroying stream
+	   };
+
+    ostream* tie() { return _tie; }
+    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
+
+    // Methods to change the format state.
+    char fill() { return _fill; }
+    char fill(char newf) { char oldf = _fill; _fill = newf; return oldf; }
+    unsigned long flags() { return _flags; }
+    unsigned long flags(unsigned long new_val) {
+	unsigned long old_val = _flags; _flags = new_val; return old_val; }
+    unsigned short precision() { return _precision; }
+    unsigned short precision(int newp) {
+	unsigned short oldp = _precision; _precision = (unsigned short)newp;
+	return oldp; }
+    unsigned long setf(unsigned long val) {
+	unsigned long oldbits = _flags;
+	_flags |= val; return oldbits; }
+    unsigned long setf(unsigned long val, unsigned long mask) {
+	unsigned long oldbits = _flags;
+	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
+    unsigned long unsetf(unsigned long mask) {
+	unsigned long oldbits = _flags & mask;
+	_flags &= ~mask; return oldbits; }
+    long width() { return _width; }
+    long width(long val) { long save = _width; _width = val; return save; }
+
+    static const unsigned long basefield;
+    static const unsigned long adjustfield;
+    static const unsigned long floatfield;
+
+    streambuf* rdbuf() { return _strbuf; }
+    void clear(int state = 0) { _state = state; }
+    int good() { return _state == 0; }
+    int eof() { return _state & ios::eofbit; }
+    int fail() { return _state & (ios::badbit|ios::failbit); }
+    int bad() { return _state & ios::badbit; }
+    int rdstate() { return _state; }
+    void set(int flag) { _state |= flag; }
+    operator void*() { return fail() ? (void*)0 : (void*)this; }
+    int operator!() { return fail(); }
+
+
+    void unset(state_value flag) { _state &= ~flag; }
+    void close();
+    int is_open();
+    int readable();
+    int writable();
+
+
+  protected:
+    ios(streambuf*sb) { _strbuf=sb; _state=0; _width=0; _fill=' ';
+			_flags=ios::skipws; _precision=6; }
+};
+
+
+
+
+typedef ios::seek_dir _seek_dir;
+
+
+// Magic numbers and bits for the _flags field.
+// The magic numbers use the high-order bits of _flags;
+// the remaining bits are abailable for variable flags.
+// Note: The magic numbers must all be negative if stdio
+// emulation is desired.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct __streambuf {
+    // NOTE: If this is changed, also change __FILE in stdio/stdio.h!
+    int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
+    char* _gptr;	/* Current get pointer */
+    char* _egptr;	/* End of get area. */
+    char* _eback;	/* Start of putback+get area. */
+    char* _pbase;	/* Start of put area. */
+    char* _pptr;	/* Current put pointer. */
+    char* _epptr;	/* End of put area. */
+    char* _base;	/* Start of reserve area. */
+    char* _ebuf;	/* End of reserve area. */
+    struct streambuf *_chain;
+};
+
+struct streambuf : private __streambuf {
+    friend class ios;
+    friend class istream;
+    friend class ostream;
+  protected:
+    static streambuf* _list_all; /* List of open streambufs. */
+    streambuf*& xchain() { return _chain; }
+    void _un_link();
+    void _link_in();
+    char* gptr() const { return _gptr; }
+    char* pptr() const { return _pptr; }
+    char* egptr() const { return _egptr; }
+    char* epptr() const { return _epptr; }
+    char* pbase() const { return _pbase; }
+    char* eback() const { return _eback; }
+    char* ebuf() const { return _ebuf; }
+    char* base() const { return _base; }
+    void xput_char(char c) { *_pptr++ = c; }
+    int xflags() { return _flags; }
+    int xflags(int f) { int fl = _flags; _flags = f; return fl; }
+    void xsetflags(int f) { _flags |= f; }
+    void gbump(int n) { _gptr += n; }
+    void pbump(int n) { _pptr += n; }
+    void setb(char* b, char* eb, int a=0);
+    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
+    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
+  public:
+    static int flush_all();
+    static void flush_all_linebuffered(); // Flush all line buffered files.
+    virtual int underflow(); // Leave public for now
+    virtual int overflow(int c = (-1) ); // Leave public for now
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
+    int sputbackc(char c);
+    int sungetc();
+    streambuf();
+    virtual ~streambuf();
+    int unbuffered() { return _flags & 2  ? 1 : 0; }
+    int linebuffered() { return _flags & 0x4000  ? 1 : 0; }
+    void unbuffered(int i)
+	{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
+    void linebuffered(int i)
+	{ if (i) _flags |= 0x4000 ; else _flags &= ~0x4000 ; }
+    int allocate() {
+	if (base() || unbuffered()) return 0;
+	else return doallocate(); }
+    virtual int sync();
+    virtual int pbackfail(int c);
+    virtual int ungetfail();
+    virtual streambuf* setbuf(char* p, int len);
+    int in_avail() { return _egptr - _gptr; }
+    int out_waiting() { return _pptr - _pbase; }
+    virtual int sputn(const char* s, int n);
+    virtual int sgetn(char* s, int n);
+    long sgetline(char* buf, size_t n, char delim, int putback_delim);
+    int sbumpc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr++; }
+    int sgetc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int snextc() {
+	if (++_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int sputc(int c) {
+	if (_pptr >= _epptr) return overflow(c);
+	return *_pptr++ = c, (unsigned char)c; }
+    int vscan(char const *fmt0, char*  ap);
+    int vform(char const *fmt0, char*  ap);
+};
+
+struct __file_fields {
+    char _fake;
+    char _shortbuf[1];
+    short _fileno;
+    int _blksize;
+    char* _save_gptr;
+    char* _save_egptr;
+    long  _offset;
+};
+
+class filebuf : public streambuf {
+    struct __file_fields _fb;
+    void init();
+  public:
+    filebuf();
+    filebuf(int fd);
+    filebuf(int fd, char* p, int len);
+    ~filebuf();
+    filebuf* attach(int fd);
+    filebuf* open(const char *filename, const char *mode);
+    filebuf* open(const char *filename, int mode, int prot = 0664);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+    int is_open() { return _fb._fileno >= 0; }
+    int fd() { return is_open() ? _fb._fileno : (-1) ; }
+    filebuf* close();
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    int sputn(const char* s, int n);
+    int sgetn(char* s, int n);
+  protected: // See documentation in filebuf.C.
+    virtual int pbackfail(int c);
+    virtual int sync();
+    int is_reading() { return eback() != egptr(); }
+    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
+    /* System's idea of pointer */
+    char* file_ptr() { return _fb._save_gptr ? _fb._save_egptr : egptr(); }
+    int do_flush();
+    // Low-level operations (Usually invoke system calls.)
+    virtual int sys_read(char* buf, size_t size);
+    virtual long  sys_seek(long , _seek_dir);
+    virtual long sys_write(const void*, long);
+    virtual int sys_stat(void*); // Actually, a (struct stat*)
+    virtual int sys_close();
+};
+
+
+inline int ios::readable() { return rdbuf()->_flags & 4 ; }
+inline int ios::writable() { return rdbuf()->_flags & 8 ; }
+inline int ios::is_open() {return rdbuf()->_flags & 4 +8 ;}
+
+
+
+
+//# 25 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 2
+
+
+class istream; class ostream;
+typedef istream& (*__imanip)(istream&);
+typedef ostream& (*__omanip)(ostream&);
+
+extern istream& ws(istream& ins);
+extern ostream& flush(ostream& outs);
+extern ostream& endl(ostream& outs);
+extern ostream& ends(ostream& outs);
+
+class ostream : public ios
+{
+    void do_osfx();
+  public:
+    ostream();
+    ostream(streambuf* sb, ostream* tied=0 );
+    ~ostream();
+
+    int opfx() { if (!good()) return 0; if (_tie) _tie->flush(); return 1; }
+    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
+		      do_osfx(); }
+    streambuf* ostreambuf() const { return _strbuf; }
+    ostream& flush();
+    ostream& put(char c);
+    ostream& write(const char *s, int n);
+    ostream& write(const unsigned char *s, int n) { return write((char*)s, n);}
+    ostream& write(const void *s, int n) { return write((char*)s, n);}
+    ostream& seekp(streampos);
+    ostream& seekp(streamoff, _seek_dir);
+    streampos tellp();
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args);
+};
+
+ostream& operator<<(ostream&, char c);
+ostream& operator<<(ostream& os, unsigned char c) { return os << (char)c; }
+//ostream& operator<<(ostream &os, signed char c) { return os << (char)c; }
+extern ostream& operator<<(ostream&, const char *s);
+inline ostream& operator<<(ostream& os, const unsigned char *s)
+{ return os << (const char*)s; }
+//inline ostream& operator<<(ostream& os, const signed char *s)
+//{ return os << (const char*)s; }
+ostream& operator<<(ostream&, void *p);
+ostream& operator<<(ostream&, int n);
+ostream& operator<<(ostream&, long n);
+ostream& operator<<(ostream&, unsigned int n);
+ostream& operator<<(ostream&, unsigned long n);
+ostream& operator<<(ostream& os, short n) {return os << (int)n;}
+ostream& operator<<(ostream& os, unsigned short n)
+{return os << (unsigned int)n;}
+ostream& operator<<(ostream&, float n);
+ostream& operator<<(ostream&, double n);
+ostream& operator<<(ostream& os, __omanip func) { return (*func)(os); }
+ostream& operator<<(ostream&, streambuf*);
+
+class istream : public ios
+{
+    size_t _gcount;
+  public:
+    istream();
+    istream(streambuf* sb, ostream*tied=0 );
+    ~istream();
+    streambuf* istreambuf() const { return _strbuf; }
+    istream& get(char& c);
+    istream& get(unsigned char& c);
+    istream& read(char *ptr, int n);
+    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
+    int get() { return _strbuf->sbumpc(); }
+    istream& getline(char* ptr, int len, char delim = '\n');
+    istream& get(char* ptr, int len, char delim = '\n');
+    istream& gets(char **s, char delim = '\n');
+    int ipfx(int need) {
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && (need == 0 || rdbuf()->in_avail())) ; /* THIS IS BAD */
+	if (!need && (flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx0() { // Optimized version of ipfx(0).
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie) _tie->flush();
+	if ((flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx1() { // Optimized version of ipfx(1).
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
+	return 1;
+    }
+    size_t gcount() { return _gcount; }
+    istream& seekg(streampos);
+    istream& seekg(streamoff, _seek_dir);
+    streampos tellg();
+    istream& putback(char ch) {
+	if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& unget() {
+	if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
+	return *this;}
+
+    istream& unget(char ch) { return putback(ch); }
+    int skip(int i);
+
+};
+
+istream& operator>>(istream&, char*);
+istream& operator>>(istream& is, unsigned char* p) { return is >> (char*)p; }
+//istream& operator>>(istream& is, signed char* p) { return is >> (char*)p; }
+istream& operator>>(istream&, char& c);
+istream& operator>>(istream&, unsigned char& c);
+//istream& operator>>(istream&, signed char& c);
+istream& operator>>(istream&, int&);
+istream& operator>>(istream&, long&);
+istream& operator>>(istream&, short&);
+istream& operator>>(istream&, unsigned int&);
+istream& operator>>(istream&, unsigned long&);
+istream& operator>>(istream&, unsigned short&);
+istream& operator>>(istream&, float&);
+istream& operator>>(istream&, double&);
+istream& operator>>(istream& is, __imanip func) { return (*func)(is); }
+
+class iostream : public ios {
+    size_t _gcount;
+  public:
+    iostream();
+    operator istream&() { return *(istream*)this; }
+    operator ostream&() { return *(ostream*)this; }
+    ~iostream();
+    // NOTE: These duplicate istream methods.
+    istream& get(char& c) { return ((istream*)this)->get(c); }
+    istream& get(unsigned char& c) { return ((istream*)this)->get(c); }
+    istream& read(char *ptr, int n) { return ((istream*)this)->read(ptr, n); }
+    istream& read(unsigned char *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    istream& read(void *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    int get() { return _strbuf->sbumpc(); }
+    istream& getline(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->getline(ptr, len, delim); }
+    istream& get(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->get(ptr, len, delim); }
+    istream& gets(char **s, char delim = '\n')
+	{ return ((istream*)this)->gets(s, delim); }
+    int ipfx(int need) { return ((istream*)this)->ipfx(need); }
+    int ipfx0()  { return ((istream*)this)->ipfx0(); }
+    int ipfx1()  { return ((istream*)this)->ipfx1(); }
+    size_t gcount() { return _gcount; }
+    istream& putback(char ch) { return ((istream*)this)->putback(ch); }
+    istream& unget() { return ((istream*)this)->unget(); }
+    istream& seekg(streampos pos) { return ((istream*)this)->seekg(pos); }
+    istream& seekg(streamoff off, _seek_dir dir)
+	{ return ((istream*)this)->seekg(off, dir); }
+    streampos tellg() { return ((istream*)this)->tellg(); }
+
+    istream& unget(char ch) { return putback(ch); }
+
+
+    // NOTE: These duplicate ostream methods.
+    int opfx() { return ((ostream*)this)->opfx(); }
+    void osfx() { ((ostream*)this)->osfx(); }
+    ostream& flush() { return ((ostream*)this)->flush(); }
+    ostream& put(char c) { return ((ostream*)this)->put(c); }
+    ostream& write(const char *s, int n)
+	{ return ((ostream*)this)->write(s, n); }
+    ostream& write(const unsigned char *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& write(const void *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args)
+	{ return ((ostream*)this)->vform(format, args); }
+    ostream& seekp(streampos pos) { return ((ostream*)this)->seekp(pos); }
+    ostream& seekp(streamoff off, _seek_dir dir)
+	{ return ((ostream*)this)->seekp(off, dir); }
+    streampos tellp() { return ((ostream*)this)->tellp(); }
+};
+
+extern istream cin;
+extern ostream cout, cerr, clog; // clog->rdbuf() == cerr->rdbuf()
+
+inline ostream& ostream::put(char c) { _strbuf->sputc(c); return *this; }
+
+struct Iostream_init { } ;  // Compatibility hack for AT&T libraray.
+
+
+//# 7 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/stream.h" 2
+
+
+extern char* form(char*, ...);
+
+extern char* dec(long, int=0);
+extern char* dec(int, int=0);
+extern char* dec(unsigned long, int=0);
+extern char* dec(unsigned int, int=0);
+
+extern char* hex(long, int=0);
+extern char* hex(int, int=0);
+extern char* hex(unsigned long, int=0);
+extern char* hex(unsigned int, int=0);
+
+extern char* oct(long, int=0);
+extern char* oct(int, int=0);
+extern char* oct(unsigned long, int=0);
+extern char* oct(unsigned int, int=0);
+
+inline istream& WS(istream& str) { return ws(str); }
+
+
+//# 26 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Regex.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+
+
+//#pragma interface
+
+
+
+
+
+
+
+
+
+struct re_pattern_buffer;       // defined elsewhere
+struct re_registers;
+
+class Regex
+{
+private:
+
+                     Regex(const Regex&) {}  // no X(X&)
+  void               operator = (const Regex&) {} // no assignment
+
+protected:
+  re_pattern_buffer* buf;
+  re_registers*      reg;
+
+public:
+                     Regex(const char* t,
+                           int fast = 0,
+                           int bufsize = 40,
+                           const char* transtable = 0);
+
+                    ~Regex();
+
+  int                match(const char* s, int len, int pos = 0) const;
+  int                search(const char* s, int len,
+                            int& matchlen, int startpos = 0) const;
+  int                match_info(int& start, int& length, int nth = 0) const;
+
+  int                OK() const;  // representation invariant
+};
+
+// some built in regular expressions
+
+extern const Regex RXwhite;          // = "[ \n\t\r\v\f]+"
+extern const Regex RXint;            // = "-?[0-9]+"
+extern const Regex RXdouble;         // = "-?\\(\\([0-9]+\\.[0-9]*\\)\\|
+                                     //    \\([0-9]+\\)\\|\\(\\.[0-9]+\\)\\)
+                                     //    \\([eE][---+]?[0-9]+\\)?"
+extern const Regex RXalpha;          // = "[A-Za-z]+"
+extern const Regex RXlowercase;      // = "[a-z]+"
+extern const Regex RXuppercase;      // = "[A-Z]+"
+extern const Regex RXalphanum;       // = "[0-9A-Za-z]+"
+extern const Regex RXidentifier;     // = "[A-Za-z_][A-Za-z0-9_]*"
+
+
+
+//# 27 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h" 2
+
+
+struct StrRep                     // internal String representations
+{
+  unsigned short    len;         // string length
+  unsigned short    sz;          // allocated space
+  char              s[1];        // the string starts here
+                                 // (at least 1 char for trailing null)
+                                 // allocated & expanded via non-public fcts
+};
+
+// primitive ops on StrReps -- nearly all String fns go through these.
+
+StrRep*     Salloc(StrRep*, const char*, int, int);
+StrRep*     Scopy(StrRep*, StrRep*);
+StrRep*     Sresize(StrRep*, int);
+StrRep*     Scat(StrRep*, const char*, int, const char*, int);
+StrRep*     Scat(StrRep*, const char*, int,const char*,int, const char*,int);
+StrRep*     Sprepend(StrRep*, const char*, int);
+StrRep*     Sreverse(StrRep*, StrRep*);
+StrRep*     Supcase(StrRep*, StrRep*);
+StrRep*     Sdowncase(StrRep*, StrRep*);
+StrRep*     Scapitalize(StrRep*, StrRep*);
+
+// These classes need to be defined in the order given
+
+class String;
+class SubString;
+
+class SubString
+{
+  friend class      String;
+protected:
+
+  String&           S;        // The String I'm a substring of
+  unsigned short    pos;      // starting position in S's rep
+  unsigned short    len;      // length of substring
+
+  void              assign(StrRep*, const char*, int = -1);
+                    SubString(String& x, int p, int l);
+                    SubString(const SubString& x);
+
+public:
+
+// Note there are no public constructors. SubStrings are always
+// created via String operations
+
+                   ~SubString();
+
+  void              operator =  (const String&     y);
+  void              operator =  (const SubString&  y);
+  void              operator =  (const char* t);
+  void              operator =  (char        c);
+
+// return 1 if target appears anywhere in SubString; else 0
+
+  int               contains(char        c) const;
+  int               contains(const String&     y) const;
+  int               contains(const SubString&  y) const;
+  int               contains(const char* t) const;
+  int               contains(const Regex&       r) const;
+
+// return 1 if target matches entire SubString
+
+  int               matches(const Regex&  r) const;
+
+// IO
+
+  friend ostream&   operator<<(ostream& s, const SubString& x);
+
+// status
+
+  unsigned int      length() const;
+  int               empty() const;
+  const char*       chars() const;
+
+  int               OK() const;
+
+};
+
+
+class String
+{
+  friend class      SubString;
+
+protected:
+  StrRep*           rep;   // Strings are pointers to their representations
+
+// some helper functions
+
+  int               search(int, int, const char*, int = -1) const;
+  int               search(int, int, char) const;
+  int               match(int, int, int, const char*, int = -1) const;
+  int               _gsub(const char*, int, const char* ,int);
+  int               _gsub(const Regex&, const char*, int);
+  SubString         _substr(int, int);
+
+public:
+
+// constructors & assignment
+
+                    String();
+                    String(const String& x);
+                    String(const SubString&  x);
+                    String(const char* t);
+                    String(const char* t, int len);
+                    String(char c);
+
+                    ~String();
+
+  void              operator =  (const String&     y);
+  void              operator =  (const char* y);
+  void              operator =  (char        c);
+  void              operator =  (const SubString&  y);
+
+// concatenation
+
+  void              operator += (const String&     y);
+  void              operator += (const SubString&  y);
+  void              operator += (const char* t);
+  void              operator += (char        c);
+
+  void              prepend(const String&     y);
+  void              prepend(const SubString&  y);
+  void              prepend(const char* t);
+  void              prepend(char        c);
+
+
+// procedural versions:
+// concatenate first 2 args, store result in last arg
+
+  friend void     cat(const String&, const String&, String&);
+  friend void     cat(const String&, const SubString&, String&);
+  friend void     cat(const String&, const char*, String&);
+  friend void     cat(const String&, char, String&);
+
+  friend void     cat(const SubString&, const String&, String&);
+  friend void     cat(const SubString&, const SubString&, String&);
+  friend void     cat(const SubString&, const char*, String&);
+  friend void     cat(const SubString&, char, String&);
+
+  friend void     cat(const char*, const String&, String&);
+  friend void     cat(const char*, const SubString&, String&);
+  friend void     cat(const char*, const char*, String&);
+  friend void     cat(const char*, char, String&);
+
+// double concatenation, by request. (yes, there are too many versions,
+// but if one is supported, then the others should be too...)
+// Concatenate first 3 args, store in last arg
+
+  friend void     cat(const String&,const String&, const String&,String&);
+  friend void     cat(const String&,const String&,const SubString&,String&);
+  friend void     cat(const String&,const String&, const char*, String&);
+  friend void     cat(const String&,const String&, char, String&);
+  friend void     cat(const String&,const SubString&,const String&,String&);
+  friend void     cat(const String&,const SubString&,const SubString&,String&);
+  friend void     cat(const String&,const SubString&, const char*, String&);
+  friend void     cat(const String&,const SubString&, char, String&);
+  friend void     cat(const String&,const char*, const String&,    String&);
+  friend void     cat(const String&,const char*, const SubString&, String&);
+  friend void     cat(const String&,const char*, const char*, String&);
+  friend void     cat(const String&,const char*, char, String&);
+
+  friend void     cat(const char*, const String&, const String&,String&);
+  friend void     cat(const char*,const String&,const SubString&,String&);
+  friend void     cat(const char*,const String&, const char*, String&);
+  friend void     cat(const char*,const String&, char, String&);
+  friend void     cat(const char*,const SubString&,const String&,String&);
+  friend void     cat(const char*,const SubString&,const SubString&,String&);
+  friend void     cat(const char*,const SubString&, const char*, String&);
+  friend void     cat(const char*,const SubString&, char, String&);
+  friend void     cat(const char*,const char*, const String&,    String&);
+  friend void     cat(const char*,const char*, const SubString&, String&);
+  friend void     cat(const char*,const char*, const char*, String&);
+  friend void     cat(const char*,const char*, char, String&);
+
+
+// searching & matching
+
+// return position of target in string or -1 for failure
+
+  int               index(char        c, int startpos = 0) const;
+  int               index(const String&     y, int startpos = 0) const;
+  int               index(const SubString&  y, int startpos = 0) const;
+  int               index(const char* t, int startpos = 0) const;
+  int               index(const Regex&      r, int startpos = 0) const;
+
+// return 1 if target appears anyhere in String; else 0
+
+  int               contains(char        c) const;
+  int               contains(const String&     y) const;
+  int               contains(const SubString&  y) const;
+  int               contains(const char* t) const;
+  int               contains(const Regex&      r) const;
+
+// return 1 if target appears anywhere after position pos
+// (or before, if pos is negative) in String; else 0
+
+  int               contains(char        c, int pos) const;
+  int               contains(const String&     y, int pos) const;
+  int               contains(const SubString&  y, int pos) const;
+  int               contains(const char* t, int pos) const;
+  int               contains(const Regex&      r, int pos) const;
+
+// return 1 if target appears at position pos in String; else 0
+
+  int               matches(char        c, int pos = 0) const;
+  int               matches(const String&     y, int pos = 0) const;
+  int               matches(const SubString&  y, int pos = 0) const;
+  int               matches(const char* t, int pos = 0) const;
+  int               matches(const Regex&      r, int pos = 0) const;
+
+//  return number of occurences of target in String
+
+  int               freq(char        c) const;
+  int               freq(const String&     y) const;
+  int               freq(const SubString&  y) const;
+  int               freq(const char* t) const;
+
+// SubString extraction
+
+// Note that you can't take a substring of a const String, since
+// this leaves open the possiblility of indirectly modifying the
+// String through the SubString
+
+  SubString         at(int         pos, int len);
+  SubString         operator () (int         pos, int len); // synonym for at
+
+  SubString         at(const String&     x, int startpos = 0);
+  SubString         at(const SubString&  x, int startpos = 0);
+  SubString         at(const char* t, int startpos = 0);
+  SubString         at(char        c, int startpos = 0);
+  SubString         at(const Regex&      r, int startpos = 0);
+
+  SubString         before(int          pos);
+  SubString         before(const String&      x, int startpos = 0);
+  SubString         before(const SubString&   x, int startpos = 0);
+  SubString         before(const char*  t, int startpos = 0);
+  SubString         before(char         c, int startpos = 0);
+  SubString         before(const Regex&       r, int startpos = 0);
+
+  SubString         through(int          pos);
+  SubString         through(const String&      x, int startpos = 0);
+  SubString         through(const SubString&   x, int startpos = 0);
+  SubString         through(const char*  t, int startpos = 0);
+  SubString         through(char         c, int startpos = 0);
+  SubString         through(const Regex&       r, int startpos = 0);
+
+  SubString         from(int          pos);
+  SubString         from(const String&      x, int startpos = 0);
+  SubString         from(const SubString&   x, int startpos = 0);
+  SubString         from(const char*  t, int startpos = 0);
+  SubString         from(char         c, int startpos = 0);
+  SubString         from(const Regex&       r, int startpos = 0);
+
+  SubString         after(int         pos);
+  SubString         after(const String&     x, int startpos = 0);
+  SubString         after(const SubString&  x, int startpos = 0);
+  SubString         after(const char* t, int startpos = 0);
+  SubString         after(char        c, int startpos = 0);
+  SubString         after(const Regex&      r, int startpos = 0);
+
+
+// deletion
+
+// delete len chars starting at pos
+  void              del(int         pos, int len);
+
+// delete the first occurrence of target after startpos
+
+  void              del(const String&     y, int startpos = 0);
+  void              del(const SubString&  y, int startpos = 0);
+  void              del(const char* t, int startpos = 0);
+  void              del(char        c, int startpos = 0);
+  void              del(const Regex&      r, int startpos = 0);
+
+// global substitution: substitute all occurrences of pat with repl
+
+  int               gsub(const String&     pat, const String&     repl);
+  int               gsub(const SubString&  pat, const String&     repl);
+  int               gsub(const char* pat, const String&     repl);
+  int               gsub(const char* pat, const char* repl);
+  int               gsub(const Regex&      pat, const String&     repl);
+
+// friends & utilities
+
+// split string into array res at separators; return number of elements
+
+  friend int        split(const String& x, String res[], int maxn,
+                          const String& sep);
+  friend int        split(const String& x, String res[], int maxn,
+                          const Regex&  sep);
+
+  friend String     common_prefix(const String& x, const String& y,
+                                  int startpos = 0);
+  friend String     common_suffix(const String& x, const String& y,
+                                  int startpos = -1);
+  friend String     replicate(char        c, int n);
+  friend String     replicate(const String&     y, int n);
+  friend String     join(String src[], int n, const String& sep);
+
+// simple builtin transformations
+
+  friend String     reverse(const String& x);
+  friend String     upcase(const String& x);
+  friend String     downcase(const String& x);
+  friend String     capitalize(const String& x);
+
+// in-place versions of above
+
+  void              reverse();
+  void              upcase();
+  void              downcase();
+  void              capitalize();
+
+// element extraction
+
+  char&             operator [] (int i);
+  char              elem(int i) const;
+  char              firstchar() const;
+  char              lastchar() const;
+
+// conversion
+
+                    operator const char*() const;
+  const char*       chars() const;
+
+
+// IO
+
+  friend ostream&   operator<<(ostream& s, const String& x);
+  friend ostream&   operator<<(ostream& s, const SubString& x);
+  friend istream&   operator>>(istream& s, String& x);
+
+  friend int        readline(istream& s, String& x,
+                             char terminator = '\n',
+                             int discard_terminator = 1);
+
+// status
+
+  unsigned int      length() const;
+  int               empty() const;
+
+// preallocate some space for String
+  void              alloc(int newsize);
+
+// report current allocation (not length!)
+
+  int               allocation() const;
+
+
+  volatile void     error(const char* msg) const;
+
+  int               OK() const;
+};
+
+typedef String StrTmp; // for backward compatibility
+
+// other externs
+
+int        compare(const String&    x, const String&     y);
+int        compare(const String&    x, const SubString&  y);
+int        compare(const String&    x, const char* y);
+int        compare(const SubString& x, const String&     y);
+int        compare(const SubString& x, const SubString&  y);
+int        compare(const SubString& x, const char* y);
+int        fcompare(const String&   x, const String&     y); // ignore case
+
+extern StrRep  _nilStrRep;
+extern String _nilString;
+
+// other inlines
+
+String operator + (const String& x, const String& y);
+String operator + (const String& x, const SubString& y);
+String operator + (const String& x, const char* y);
+String operator + (const String& x, char y);
+String operator + (const SubString& x, const String& y);
+String operator + (const SubString& x, const SubString& y);
+String operator + (const SubString& x, const char* y);
+String operator + (const SubString& x, char y);
+String operator + (const char* x, const String& y);
+String operator + (const char* x, const SubString& y);
+
+int operator==(const String& x, const String& y);
+int operator!=(const String& x, const String& y);
+int operator> (const String& x, const String& y);
+int operator>=(const String& x, const String& y);
+int operator< (const String& x, const String& y);
+int operator<=(const String& x, const String& y);
+int operator==(const String& x, const SubString&  y);
+int operator!=(const String& x, const SubString&  y);
+int operator> (const String& x, const SubString&  y);
+int operator>=(const String& x, const SubString&  y);
+int operator< (const String& x, const SubString&  y);
+int operator<=(const String& x, const SubString&  y);
+int operator==(const String& x, const char* t);
+int operator!=(const String& x, const char* t);
+int operator> (const String& x, const char* t);
+int operator>=(const String& x, const char* t);
+int operator< (const String& x, const char* t);
+int operator<=(const String& x, const char* t);
+int operator==(const SubString& x, const String& y);
+int operator!=(const SubString& x, const String& y);
+int operator> (const SubString& x, const String& y);
+int operator>=(const SubString& x, const String& y);
+int operator< (const SubString& x, const String& y);
+int operator<=(const SubString& x, const String& y);
+int operator==(const SubString& x, const SubString&  y);
+int operator!=(const SubString& x, const SubString&  y);
+int operator> (const SubString& x, const SubString&  y);
+int operator>=(const SubString& x, const SubString&  y);
+int operator< (const SubString& x, const SubString&  y);
+int operator<=(const SubString& x, const SubString&  y);
+int operator==(const SubString& x, const char* t);
+int operator!=(const SubString& x, const char* t);
+int operator> (const SubString& x, const char* t);
+int operator>=(const SubString& x, const char* t);
+int operator< (const SubString& x, const char* t);
+int operator<=(const SubString& x, const char* t);
+
+
+
+
+// status reports, needed before defining other things
+
+inline unsigned int String::length() const {  return rep->len; }
+inline int         String::empty() const { return rep->len == 0; }
+inline const char* String::chars() const { return &(rep->s[0]); }
+inline int         String::allocation() const { return rep->sz; }
+inline void        String::alloc(int newsize) { rep = Sresize(rep, newsize); }
+
+inline unsigned int SubString::length() const { return len; }
+inline int         SubString::empty() const { return len == 0; }
+inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
+
+
+// constructors
+
+inline String::String()
+  : rep(&_nilStrRep) {}
+inline String::String(const String& x)
+  : rep(Scopy(0, x.rep)) {}
+inline String::String(const char* t)
+  : rep(Salloc(0, t, -1, -1)) {}
+inline String::String(const char* t, int tlen)
+  : rep(Salloc(0, t, tlen, tlen)) {}
+inline String::String(const SubString& y)
+  : rep(Salloc(0, y.chars(), y.length(), y.length())) {}
+inline String::String(char c)
+  : rep(Salloc(0, &c, 1, 1)) {}
+
+inline String::~String() { if (rep != &_nilStrRep) delete rep; }
+
+inline SubString::SubString(const SubString& x)
+  :S(x.S), pos(x.pos), len(x.len) {}
+inline SubString::SubString(String& x, int first, int l)
+  :S(x), pos(first), len(l) {}
+
+inline SubString::~SubString() {}
+
+// assignment
+
+inline void String::operator =  (const String& y)
+{
+  rep = Scopy(rep, y.rep);
+}
+
+inline void String::operator=(const char* t)
+{
+  rep = Salloc(rep, t, -1, -1);
+}
+
+inline void String::operator=(const SubString&  y)
+{
+  rep = Salloc(rep, y.chars(), y.length(), y.length());
+}
+
+inline void String::operator=(char c)
+{
+  rep = Salloc(rep, &c, 1, 1);
+}
+
+
+inline void SubString::operator = (const char* ys)
+{
+  assign(0, ys);
+}
+
+inline void SubString::operator = (char ch)
+{
+  assign(0, &ch, 1);
+}
+
+inline void SubString::operator = (const String& y)
+{
+  assign(y.rep, y.chars(), y.length());
+}
+
+inline void SubString::operator = (const SubString& y)
+{
+  assign(y.S.rep, y.chars(), y.length());
+}
+
+// Zillions of cats...
+
+inline void cat(const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, y, -1);
+}
+
+inline void cat(const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, x, -1, &y, 1);
+}
+
+inline void cat(const String& a, const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& a, const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const String& a, const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const String& a, const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const String& a, const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const String& a, const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
+}
+
+inline void cat(const String& a, const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y.chars(), y.length());
+}
+
+inline void cat(const String& a, const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, y, -1);
+}
+
+inline void cat(const String& a, const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a.chars(), a.length(), x, -1, &y, 1);
+}
+
+
+inline void cat(const char* a, const String& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const String& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const String& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const char* a, const String& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* a, const SubString& x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const SubString& x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y.chars(), y.length());
+}
+
+inline void cat(const char* a, const SubString& x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), y, -1);
+}
+
+inline void cat(const char* a, const SubString& x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x.chars(), x.length(), &y, 1);
+}
+
+inline void cat(const char* a, const char* x, const String& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* a, const char* x, const SubString& y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y.chars(), y.length());
+}
+
+inline void cat(const char* a, const char* x, const char* y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, y, -1);
+}
+
+inline void cat(const char* a, const char* x, char y, String& r)
+{
+  r.rep = Scat(r.rep, a, -1, x, -1, &y, 1);
+}
+
+
+// operator versions
+
+inline void String::operator +=(const String& y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String::operator +=(const SubString& y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String::operator += (const char* y)
+{
+  cat(*this, y, *this);
+}
+
+inline void String:: operator +=(char y)
+{
+  cat(*this, y, *this);
+}
+
+// constructive concatenation
+
+
+
+inline String operator + (const String& x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, const char* y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const String& x, char y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, const char* y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const SubString& x, char y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const char* x, const String& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String operator + (const char* x, const SubString& y) return r;
+{
+  cat(x, y, r);
+}
+
+inline String reverse(const String& x) return r;
+{
+  r.rep = Sreverse(x.rep, r.rep);
+}
+
+inline String upcase(const String& x) return r;
+{
+  r.rep = Supcase(x.rep, r.rep);
+}
+
+inline String downcase(const String& x) return r;
+{
+  r.rep = Sdowncase(x.rep, r.rep);
+}
+
+inline String capitalize(const String& x) return r;
+{
+  r.rep = Scapitalize(x.rep, r.rep);
+}
+
+//# 883 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/String.h"
+
+
+// prepend
+
+inline void String::prepend(const String& y)
+{
+  rep = Sprepend(rep, y.chars(), y.length());
+}
+
+inline void String::prepend(const char* y)
+{
+  rep = Sprepend(rep, y, -1);
+}
+
+inline void String::prepend(char y)
+{
+  rep = Sprepend(rep, &y, 1);
+}
+
+inline void String::prepend(const SubString& y)
+{
+  rep = Sprepend(rep, y.chars(), y.length());
+}
+
+// misc transformations
+
+
+inline void String::reverse()
+{
+  rep = Sreverse(rep, rep);
+}
+
+
+inline void String::upcase()
+{
+  rep = Supcase(rep, rep);
+}
+
+
+inline void String::downcase()
+{
+  rep = Sdowncase(rep, rep);
+}
+
+
+inline void String::capitalize()
+{
+  rep = Scapitalize(rep, rep);
+}
+
+// element extraction
+
+inline char&  String::operator [] (int i)
+{
+  if (((unsigned)i) >= length()) error("invalid index");
+  return rep->s[i];
+}
+
+inline char  String::elem (int i) const
+{
+  if (((unsigned)i) >= length()) error("invalid index");
+  return rep->s[i];
+}
+
+inline char  String::firstchar() const
+{
+  return elem(0);
+}
+
+inline char  String::lastchar() const
+{
+  return elem(length() - 1);
+}
+
+// searching
+
+inline int String::index(char c, int startpos) const
+{
+  return search(startpos, length(), c);
+}
+
+inline int String::index(const char* t, int startpos) const
+{
+  return search(startpos, length(), t);
+}
+
+inline int String::index(const String& y, int startpos) const
+{
+  return search(startpos, length(), y.chars(), y.length());
+}
+
+inline int String::index(const SubString& y, int startpos) const
+{
+  return search(startpos, length(), y.chars(), y.length());
+}
+
+inline int String::index(const Regex& r, int startpos) const
+{
+  int unused;  return r.search(chars(), length(), unused, startpos);
+}
+
+inline int String::contains(char c) const
+{
+  return search(0, length(), c) >= 0;
+}
+
+inline int String::contains(const char* t) const
+{
+  return search(0, length(), t) >= 0;
+}
+
+inline int String::contains(const String& y) const
+{
+  return search(0, length(), y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const SubString& y) const
+{
+  return search(0, length(), y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(char c, int p) const
+{
+  return match(p, length(), 0, &c, 1) >= 0;
+}
+
+inline int String::contains(const char* t, int p) const
+{
+  return match(p, length(), 0, t) >= 0;
+}
+
+inline int String::contains(const String& y, int p) const
+{
+  return match(p, length(), 0, y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const SubString& y, int p) const
+{
+  return match(p, length(), 0, y.chars(), y.length()) >= 0;
+}
+
+inline int String::contains(const Regex& r) const
+{
+  int unused;  return r.search(chars(), length(), unused, 0) >= 0;
+}
+
+inline int String::contains(const Regex& r, int p) const
+{
+  return r.match(chars(), length(), p) >= 0;
+}
+
+
+inline int String::matches(const SubString& y, int p) const
+{
+  return match(p, length(), 1, y.chars(), y.length()) >= 0;
+}
+
+inline int String::matches(const String& y, int p) const
+{
+  return match(p, length(), 1, y.chars(), y.length()) >= 0;
+}
+
+inline int String::matches(const char* t, int p) const
+{
+  return match(p, length(), 1, t) >= 0;
+}
+
+inline int String::matches(char c, int p) const
+{
+  return match(p, length(), 1, &c, 1) >= 0;
+}
+
+inline int String::matches(const Regex& r, int p) const
+{
+  int l = (p < 0)? -p : length() - p;
+  return r.match(chars(), length(), p) == l;
+}
+
+
+inline int SubString::contains(const char* t) const
+{
+  return S.search(pos, pos+len, t) >= 0;
+}
+
+inline int SubString::contains(const String& y) const
+{
+  return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
+}
+
+inline int SubString::contains(const SubString&  y) const
+{
+  return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
+}
+
+inline int SubString::contains(char c) const
+{
+  return S.search(pos, pos+len, 0, c) >= 0;
+}
+
+inline int SubString::contains(const Regex& r) const
+{
+  int unused;  return r.search(chars(), len, unused, 0) >= 0;
+}
+
+inline int SubString::matches(const Regex& r) const
+{
+  return r.match(chars(), len, 0) == len;
+}
+
+
+inline int String::gsub(const String& pat, const String& r)
+{
+  return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
+}
+
+inline int String::gsub(const SubString&  pat, const String& r)
+{
+  return _gsub(pat.chars(), pat.length(), r.chars(), r.length());
+}
+
+inline int String::gsub(const Regex& pat, const String& r)
+{
+  return _gsub(pat, r.chars(), r.length());
+}
+
+inline int String::gsub(const char* pat, const String& r)
+{
+  return _gsub(pat, -1, r.chars(), r.length());
+}
+
+inline int String::gsub(const char* pat, const char* r)
+{
+  return _gsub(pat, -1, r, -1);
+}
+
+
+
+inline  ostream& operator<<(ostream& s, const String& x)
+{
+   s << x.chars(); return s;
+}
+
+// a zillion comparison operators
+
+inline int operator==(const String& x, const String& y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const String& x, const String& y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const String& x, const String& y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const String& x, const String& y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const String& x, const String& y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const String& x, const String& y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const String& x, const SubString&  y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const String& x, const SubString&  y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const String& x, const SubString&  y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const String& x, const SubString&  y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const String& x, const SubString&  y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const String& x, const SubString&  y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const String& x, const char* t)
+{
+  return compare(x, t) == 0;
+}
+
+inline int operator!=(const String& x, const char* t)
+{
+  return compare(x, t) != 0;
+}
+
+inline int operator>(const String& x, const char* t)
+{
+  return compare(x, t) > 0;
+}
+
+inline int operator>=(const String& x, const char* t)
+{
+  return compare(x, t) >= 0;
+}
+
+inline int operator<(const String& x, const char* t)
+{
+  return compare(x, t) < 0;
+}
+
+inline int operator<=(const String& x, const char* t)
+{
+  return compare(x, t) <= 0;
+}
+
+inline int operator==(const SubString& x, const String& y)
+{
+  return compare(y, x) == 0;
+}
+
+inline int operator!=(const SubString& x, const String& y)
+{
+  return compare(y, x) != 0;
+}
+
+inline int operator>(const SubString& x, const String& y)
+{
+  return compare(y, x) < 0;
+}
+
+inline int operator>=(const SubString& x, const String& y)
+{
+  return compare(y, x) <= 0;
+}
+
+inline int operator<(const SubString& x, const String& y)
+{
+  return compare(y, x) > 0;
+}
+
+inline int operator<=(const SubString& x, const String& y)
+{
+  return compare(y, x) >= 0;
+}
+
+inline int operator==(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) == 0;
+}
+
+inline int operator!=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) != 0;
+}
+
+inline int operator>(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) > 0;
+}
+
+inline int operator>=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) >= 0;
+}
+
+inline int operator<(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) < 0;
+}
+
+inline int operator<=(const SubString& x, const SubString&  y)
+{
+  return compare(x, y) <= 0;
+}
+
+inline int operator==(const SubString& x, const char* t)
+{
+  return compare(x, t) == 0;
+}
+
+inline int operator!=(const SubString& x, const char* t)
+{
+  return compare(x, t) != 0;
+}
+
+inline int operator>(const SubString& x, const char* t)
+{
+  return compare(x, t) > 0;
+}
+
+inline int operator>=(const SubString& x, const char* t)
+{
+  return compare(x, t) >= 0;
+}
+
+inline int operator<(const SubString& x, const char* t)
+{
+  return compare(x, t) < 0;
+}
+
+inline int operator<=(const SubString& x, const char* t)
+{
+  return compare(x, t) <= 0;
+}
+
+
+// a helper needed by at, before, etc.
+
+inline SubString String::_substr(int first, int l)
+{
+  if (first  >= length() )
+    return SubString(_nilString, 0, 0) ;
+  else
+    return SubString(*this, first, l);
+}
+
+
+
+
+
+//# 26 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 27 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 1
+// -*- C++ -*-
+
+
+
+//
+// Fake up a libstuff++
+//
+// This is done as a complete and utter hack; this library has no function
+// at all being in the boot area; it is here solely in order to provide a
+// libstuff++ against which the Makefiles can resolve link lines.
+//
+// The only reason that this is done is to allow the STANDARD_C++_LIBRARIES
+// as provided by the Makefile templates in the boot area to be the same
+// ones that are used by the tools outside this hierarchy.
+//
+// The tools outside this hierarchy use a different libstuff++; one that is
+// written in C++.  This one is not written in C++ in order to be simpler.
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+extern "C" {
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 1
+
+
+
+/*
+ * Useful stuff
+ */
+
+/*
+ * $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+ * $Revision: 1.8 $
+ * $Author: jason $
+ * $Date: 1995/05/07 18:57:48 $
+ */
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/ansi.h" 1
+
+
+
+
+/*
+ * ANSI Compiler Support
+ *
+ * David Harrison
+ * University of California, Berkeley
+ * 1988
+ *
+ * ANSI compatible compilers are supposed to define the preprocessor
+ * directive __STDC__.  Based on this directive, this file defines
+ * certain ANSI specific macros.
+ *
+ * ARGS:
+ *   Used in function prototypes.  Example:
+ *   extern int foo
+ *     ARGS((char *blah, double threshold));
+ */
+
+/*
+ * $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+ * $Author: jason $
+ * $Revision: 1.8 $
+ * $Date: 1995/05/07 18:57:48 $
+ *
+ * Modifications
+ * Wendell C Baker
+ * University of California, Berkeley
+ */
+
+/* Function prototypes */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 15 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
+
+
+
+/*
+ * If g++, then we stub out part of this thing and let the C++ types take
+ * over and do the same job; some compatibility must be given however
+ */
+
+/*
+ *    Use the GNU libg++ definition
+ */
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 26 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h" 2
+
+//# 35 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
+
+
+/*
+ * Make various pieces of C code that use the old ``Boolean''
+ * be compatible by faking up the definition of Boolean using
+ * the new bool type.
+ */
+
+
+//# 58 "/sandbox/wbaker/wbaker0/source/mips/include/stuff.h"
+
+
+typedef long FitAny;		/* can fit any integral type */
+
+/*
+ * typedef char *String;	- DO NOT USE THIS - it conflicts with C++
+ * typedef char **Stringv;	- just use char* and char** instead.
+ * 				- void* can be used for arbitrary pointers
+ */
+
+
+
+
+extern int nocase_strcmp (char *, char *)		;
+extern int nocase_strncmp (char *, char *, int)		;
+
+extern bool	 nocase_strequal (char *, char *)		;
+extern bool	 nocase_strnequal (char *, char *, int)		;
+
+extern bool	 lead_strequal (char *, char *)		;
+extern bool	 nocase_lead_strequal (char *, char *)		;
+
+extern int strhash (char *, int)		;
+extern int nocase_strhash (char *, int)		;
+
+extern int sign (int)		;
+
+/*
+ *    Some useful macros.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 33 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+}
+
+//
+// This is here because we wish to provide externs for the two
+// functions btoa(bool, unsigned = 0) and operator<<(ostream&, bool)
+// because they are not provided in bool.h.
+//
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 41 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+extern const char *stringify(bool b);
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 43 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+extern ostream& operator<<(ostream&, bool);
+
+// Should this be kept separate?   bool isn't, but then  is
+// included here only to define ostream& operator<<(ostream&, bool)
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 1
+// -*- C++ -*-
+
+
+
+//
+// unit enum
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//
+// unit enum
+//
+// This _looks_ silly, but it has an important theoretical basis in category
+// theory.  For the pragmatic reason for its existence, see the example below.
+//
+enum unit {
+    UNIT = 1,
+};
+
+extern const char *stringify(unit u);
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/unit.h" 2
+
+extern ostream& operator<<(ostream&, unit);
+
+//
+// A unit is used in cases where the type signature of an overloaded
+// function must be differentiated in some stronger way than can be
+// denoted unambiguously in the C++ syntax.  This enum is used to give
+// one of the functions a different type signature, thereby allowing
+// the overloading.
+//
+// The use of ``unit'' instead of int or bool is important because a unit
+// has only one possible value; therefore it adds no more information to
+// the code.   For example, say a bool was used instead, then in the testing
+// phase, would have to ask: what if TRUE was given, what if FALSE was given.
+// The problem is compounded if char or int is used.
+//
+// Example:
+//
+//     class ID {
+//     public:
+//         ID();		// construct a null ID
+//         ID(unit);		// alloc a ID with a new id
+//     private:
+//         static unsigned high_water;
+//         unsigned id;
+//     };
+//
+// Try working this example save that ID implements all of the generic
+// features of the identifier object, but the high_water is stored
+// in the heir.  That is what originally motivated the creation of unit.
+//
+
+
+//# 48 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 2
+
+
+//
+// In the spirit of the standard GNU error handler functions
+// as described in
+//     typedef void (*one_arg_error_handler_t)(const char*);
+//         a one argument error handler function pointer
+//     typedef void (*two_arg_error_handler_t)(const char*, const char*);
+//         a two argument error handler function pointer
+//
+// And now the NEW
+//
+// typedef void (*zero_arg_error_handler_t)();
+//     a zero argument error handler function pointer
+//
+typedef void (*zero_arg_error_handler_t)();
+
+//
+// In the spirit of the default GNU error handler functions
+// as described in
+//     extern void default_one_arg_error_handler(const char *message);
+//         print out message on stderr, and do the default thing (abort)
+//     extern void default_two_arg_error_handler(const char *kind, const char *message);
+//         print out kind and message on stderr, and do the default thing (abort)
+//
+// And now the NEW
+//
+// extern void default_zero_arg_error_handler(const char *message);
+//     do the default thing (abort)
+//
+extern void default_zero_arg_error_handler();
+
+// Guaranteed to exit (1)
+extern void exit_zero_arg_error_handler();
+extern void exit_one_arg_error_handler(const char *message);
+extern void exit_two_arg_error_handler(const char *kind, const char *message);
+
+// Guaranteed to abort()
+extern void abort_zero_arg_error_handler();
+extern void abort_one_arg_error_handler(const char *message);
+extern void abort_two_arg_error_handler(const char *kind, const char *message);
+
+//
+// In the spirit of the standard GNU error handlers
+// as described in
+//     extern void  verbose_File_error_handler(const char*);
+//         perror and set errno = 0
+//     extern void  quiet_File_error_handler(const char*);
+//         set errno = 0
+//     extern void  fatal_File_error_handler(const char*);
+//         perror and exit 1
+//
+// And now the NEW
+//
+// extern void preserve_File_error_handler(const char *message);
+//     no perror, no assignment to errno.
+//
+extern void preserve_File_error_handler(const char *message);
+
+
+//# 29 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+
+
+
+//
+// tostrstream class
+//
+// A terminated oststream - an ostsrstream that auto-terminates on str()
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 1
+//    This is part of the iostream library, providing input/output for C++.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+
+//#pragma interface
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 23 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/strstream.h" 2
+
+
+class strstreambuf : public streambuf {
+    size_t *lenp; /* current (logical) length (i.e. valid data bytes) */
+    size_t *sizep; /* allocated (physical) buffer size */
+    char **bufp;
+    size_t _len;
+    size_t _size;
+    char *buf;
+    int _frozen;
+  protected:
+    virtual int overflow(int = (-1) );
+  public:
+    strstreambuf();
+    strstreambuf(int initial);
+    strstreambuf(char *ptr, int size, char *pstart = 0 );
+    ~strstreambuf();
+    int frozen() { return _frozen; }
+    void freeze(int n=1) { _frozen = n != 0; }
+    size_t pcount();
+    char *str();
+};
+
+class istrstream : public istream {
+  public:
+    istrstream(char*);
+    istrstream(char*, int);
+    strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
+};
+
+class ostrstream : public ostream {
+  public:
+    ostrstream();
+    ostrstream(char *cp, int n, int mode=ios::out);
+    size_t pcount() { return ((strstreambuf*)_strbuf)->pcount(); }
+    char *str() { return ((strstreambuf*)_strbuf)->str(); }
+    void freeze(int n = 1) { ((strstreambuf*)_strbuf)->freeze(n); }
+    int frozen() { return ((strstreambuf*)_strbuf)->frozen(); }
+    strstreambuf* rdbuf() { return (strstreambuf*)_strbuf; }
+};
+
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 2
+
+
+//
+// tostrstream class
+//
+// An isteam class that doesn't have that nasty skipws parameter that
+// you have to remember to set.  This class simply provides the istream
+// functionality with a set of constructors which defaults skipws to
+// FALSE (instead of defaulting to TRUE as is the case with plain istream).
+//
+class tostrstream: public ostrstream {
+public:
+    tostrstream(): ostrstream()
+	{ }
+    // This constructor defines cp as the buffer to use for the
+    // stream (instead of one of its own devising); it does NOT
+    // initialize the ostrstream to contain cp (of length n).
+    tostrstream(char *cp, int n, int mode=ios::out): ostrstream(cp, n, mode)
+	{ }
+    char *str()
+	{
+	    char *s = ostrstream::str();
+	    s[ostrstream::pcount()] = '\0';
+	    return s;
+	}
+};
+
+
+//# 30 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GttObject class (is abstract)
+//
+// Expects to be included where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GttErrorHandler class
+//
+// Expects to be included by Gtt.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h" 1
+// -*- C++ -*-
+//# 107 "/sandbox/wbaker/wbaker0/source/mips/include/stuff++.h"
+
+//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 28 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttErrorHandler.h" 2
+
+
+//
+// It is expected that this will be virtually multiply inherited
+// into all of the classes that need error reporting services.
+//
+// The typical way to have that done is by inheriting the GttObject
+// as a virtual base class.
+//
+
+//
+// GttErrorHandler class
+//
+class GttErrorHandler {
+public:
+    GttErrorHandler();
+    GttErrorHandler(const char *program);
+    virtual ~GttErrorHandler();
+
+    //
+    // Error messages
+    //     - an unacceptable, but expected and recoverable condition
+    //       was was detected (but the test fails)
+    //     - errors are for ``the expected environment was not found''
+    //       rather than for ``file couldn't be opened''
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void error(const char *message);
+    static void error(tostrstream& message);
+
+    static void error(const char *function, const char *message);
+    static void error(const char *function, tostrstream& message);
+
+    static void error(const char *class_name, const char *method, const char *message);
+    static void error(const char *class_name, const char *method, tostrstream& message);
+
+    //
+    // Fatal messages
+    //     - an unacceptable and unexpected error was detected
+    //       the data invariants were violated, there is no recovery
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void fatal(const char *message);
+    static void fatal(tostrstream& message);
+
+    static void fatal(const char *function, const char *message);
+    static void fatal(const char *function, tostrstream& message);
+
+    static void fatal(const char *class_name, const char *method, const char *message);
+    static void fatal(const char *class_name, const char *method, tostrstream& message);
+private:
+    //
+    // Two underscores are used here in order to prevent confusion of these
+    // private variables with any of the heir's private variables.  Note that
+    // access control is different than visibility in C++, so all the variable
+    // names in a class hierarchy must be unique.
+    //
+
+    static bool __partial_init;
+    static void __partial_initialize();
+    static bool __full_init;
+    static void __full_initialize(const char *program);
+    static char *__program;
+
+    static void __handle_error();
+    static void __handle_fatal();
+    static void __add_newline(const char *message);
+
+    static bool __output_valid();
+    static ostream *__output;
+};
+
+
+//# 27 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+
+//
+// GttObject class (is abstract)
+//
+class GttObject: virtual public GttErrorHandler {
+protected:
+    GttObject();
+    GttObject(const GttObject&);
+    virtual ~GttObject();	// ensure descendants have virtual destructors
+
+public:
+    //
+    // I/O Support
+    //
+    // The value typically persists only long enough for an i/o operation
+    // to be performed (see the defintion of output via operator<<(... ) below)
+    virtual const char *stringify();
+protected:
+    // This is the buffer into which the printed representation of this
+    // object will be put when the time comes.  It is associated with the
+    // object so it will never go away (so long as the object exists).
+    // Use a pointer so that you only pay for the space when I/O is used
+    tostrstream *stringbuf;
+    void clear_stringbuf();
+
+public:
+    //
+    // Consistency
+    //
+    // The global data invariant for the whole object (heirs included).
+    // This OK function will call the local invariant function ok() if
+    // necessary and in addition the OK functions of the heirs
+    // This is expected to compute the data invariant of the object.
+    // It will execute GctErrorHandler::fatal if there is wrong.
+    virtual void OK() const;
+
+protected:
+    //
+    // consistency
+    //
+    // This function computes the invariant which is local to this object.
+    // It does not call any of the ancestor's OK() or ok() functions.
+    // It is not a virtual function so that it can be called from within a
+    // constructor with impunity.  Thus this function MUST NOT call any
+    // virtual functions either; it should call them by their full name if
+    // that is necessary.  The global OK() function will call this function
+    // as necessary.
+    //
+    // This function must NOT NEVER EVER be made virtual.
+    void ok() const;
+
+protected:
+    //
+    // Class Name
+    //
+    // This must return a static (constant) string which is the name
+    // of the class being declared.  By convention, not all classes
+    // must have one of these, but the major root abstract class must
+    // have one in order to allow the stringify() to work approximately
+    // correctly.
+    virtual const char *class_name() const = 0;
+};
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 91 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 2
+
+extern ostream& operator<<(ostream&, GttObject&);
+
+// There may be other X& operator<<(X&, GttObject&) defined in the
+// packages defining class X.  For example see the definition of
+// GttUnitObject& operator<<(GttUnitObject&, GttObject&) in Unit.
+
+
+//# 32 "../../../../mips/include/Gct/GctErrorHandler.h" 2
+
+
+//
+// It is expected that this will be virtually multiply inherited
+// into all of the classes that need error reporting services.
+//
+// The typical way to have that done is by inheriting the GctObject
+// as a virtual base class.
+//
+
+//
+// GctErrorHandler class
+//
+// GPP_1_96_BUG
+// NOTE - virtual public GttObject should be MI into GctObject - but that
+// causes g++ 1.96 to segfault; so we must inherit GttObject here and use SI
+// GPP_1_96_BUG
+class GctErrorHandler: virtual public GttObject {
+public:
+    GctErrorHandler();
+    GctErrorHandler(const String& program);
+    virtual ~GctErrorHandler();
+
+    //
+    // Debugging messages
+    //     - these are turned off for production code.
+    //     - these messages can be shut off
+    //
+    static void debug(const char *message);
+    static void debug(tostrstream& message);
+
+    static void debug(const char *function, const char *message);
+    static void debug(const char *function, tostrstream& message);
+
+    static void debug(const char *class_name, const char *method, const char *message);
+    static void debug(const char *class_name, const char *method, tostrstream& message);
+
+    static bool debug();		// current debug switch
+    static void debug(bool value);	// change the debug switch
+
+    //
+    // Informational messages
+    //     - these correspond to a ``verbose'' mode
+    //     - these are not errors, just chatty progress reports
+    //     - these messages can be shut off
+    //
+    static void note(const char *message);
+    static void note(tostrstream& message);
+
+    static void note(const char *function, const char *message);
+    static void note(const char *function, tostrstream& message);
+
+    static void note(const char *class_name, const char *method, const char *message);
+    static void note(const char *class_name, const char *method, tostrstream& message);
+
+    static bool note();			// current note switch
+    static void note(bool value);	// change the note switch
+
+    //
+    // Warning messages
+    //     - warnings are system-recoverable errors
+    //     - the system has noticed something and taken some
+    //       corrective action
+    //     - these messages can be shut off
+    //
+    static void warning(const char *message);
+    static void warning(tostrstream& message);
+
+    static void warning(const char *function, const char *message);
+    static void warning(const char *function, tostrstream& message);
+
+    static void warning(const char *class_name, const char *method, const char *message);
+    static void warning(const char *class_name, const char *method, tostrstream& message);
+
+    static bool warning();		// current warning switch
+    static void warning(bool value);	// change the warning switch
+
+    //
+    // Error messages
+    //     - an unacceptable, but expected and recoverable
+    //       condition was was detected
+    //     - errors are for ``the expected environment was not found''
+    //       rather than for ``file couldn't be opened''
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void error(const char *message);
+    static void error(tostrstream& message);
+
+    static void error(const char *function, const char *message);
+    static void error(const char *function, tostrstream& message);
+
+    static void error(const char *class_name, const char *method, const char *message);
+    static void error(const char *class_name, const char *method, tostrstream& message);
+
+    // can't turn off errors - no ``static void error(bool value);''
+    static zero_arg_error_handler_t error();		// current error handler
+    static void error(zero_arg_error_handler_t handler);// change the error handler
+
+    static void error_is_lib_error_handler();		// change the error handler
+    static void error_is_exit();			// change the error handler
+
+    // Describes the fatal handler - WATCHOUT - implicitly uses AllocRing
+    static const char *error_handler_description();
+
+    //
+    // Fatal messages
+    //     - an unacceptable and unexpected error was detected
+    //       the data invariants were violated, there is no recovery
+    //     - these messages cannot be shut off
+    //     - the error handler determines the recovery action
+    //       TODO - one day exceptions will be used here
+    //
+    static void fatal(const char *message);
+    static void fatal(tostrstream& message);
+
+    static void fatal(const char *function, const char *message);
+    static void fatal(const char *function, tostrstream& message);
+
+    static void fatal(const char *class_name, const char *method, const char *message);
+    static void fatal(const char *class_name, const char *method, tostrstream& message);
+
+    // can't turn off fatals - no ``static void fatal(bool value);''
+    static zero_arg_error_handler_t fatal();			// return the fatal handler
+    static void fatal(zero_arg_error_handler_t handler);	// change the fatal handler
+
+    static void fatal_is_exit();	// change the fatal handler
+    static void fatal_is_abort();	// change the fatal handler
+
+    // Describes the fatal handler - WATCHOUT - implicitly uses AllocRing
+    static const char *fatal_handler_description();
+private:
+    //
+    // Two underscores are used here in order to prevent confusion of these
+    // private variables with any of the heir's private variables.  Note that
+    // access control is different than visibility in C++, so all the variable
+    // names in a class hierarchy must be unique.
+    //
+    static bool __debug;
+    static bool __note;
+    static bool __warning;
+    static void (*__error_handler)();	// can't turn off errors
+    static void (*__fatal_handler)();	// can't turn off fatals
+
+    static bool __partial_init;
+    static void __partial_initialize();
+    static bool __full_init;
+    static void __full_initialize(const char *program);
+    static char *__program;
+
+    static void __handle_error();
+    static void __handle_fatal();
+    static void __add_newline(const char *message);
+    static void __message_switch(bool value, bool& flag, const char *description);
+    static void __message_switch(bool value, bool& flag);
+    static const char *__describe_handler(zero_arg_error_handler_t handler);
+
+    static bool __output_valid();
+    static ostream *__output;
+
+    // GPP_1_96_BUG
+    const char *class_name() const;
+    // GPP_1_96_BUG
+};
+
+
+//# 27 "../../../../mips/include/Gct/Reference/GctReferenceCount.h" 2
+
+
+class GctReferenceCount: virtual public GctErrorHandler {
+public:
+    GctReferenceCount();
+
+    void inc();
+    void dec();
+    bool zero() const;
+private:
+    unsigned _count;
+};
+
+inline
+GctReferenceCount::GctReferenceCount()
+{
+    this->_count = 0;
+}
+
+inline void
+GctReferenceCount::inc()
+{
+    this->_count++;
+}
+
+inline void
+GctReferenceCount::dec()
+{
+    if (this->debug()) {
+	if (this->_count == 0)
+	    this->error("GctReferenceCount", "dec()",
+			"attempt to decrement a zero refcount");
+    }
+
+    // Protect against decrementing off zero in case
+    // this->debug() is not turned on to signal the error.
+    if (this->_count)
+	this->_count--;
+}
+
+inline bool
+GctReferenceCount::zero() const
+{
+    return (bool)(this->_count == 0);
+}
+
+
+//# 25 "../../../../mips/include/Gct/Reference.h" 2
+
+//# 1 "../../../../mips/include/Gct/Reference/GctReferenceObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctReferenceObject class
+//
+// Expects to be included by Gct/Reference.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "../../../../mips/include/Gct/Reference/GctReferenceObject.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/Object/GctHashObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctHashObject class (is abstract)
+//
+// Expects to be included by Object.h or where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "../../../../mips/include/Gct/Object/GctObject.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctObject class (is abstract)
+//
+// Expects to be included by Object.h or where needed explicitly.
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h" 1
+// -*- C++ -*-
+//# 52 "/sandbox/wbaker/wbaker0/source/mips/include/tostrstream.h"
+
+//# 25 "../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//# 1 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h" 1
+// -*- C++ -*-
+//# 98 "/sandbox/wbaker/wbaker0/source/mips/include/Gtt/GttObject.h"
+
+//# 27 "../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/GctErrorHandler.h" 1
+// -*- C++ -*-
+//# 198 "../../../../mips/include/Gct/GctErrorHandler.h"
+
+//# 29 "../../../../mips/include/Gct/Object/GctObject.h" 2
+
+
+//
+// GctObject class (is abstract)
+//
+class GctObject: virtual public GctErrorHandler /*, virtual public GttObject*/ {
+protected:
+    GctObject();
+    GctObject(const GctObject&);
+    virtual ~GctObject();	// ensure descendants have virtual destructors
+
+public:
+    //
+    // I/O Support
+    //
+    // The value typically persists only long enough for an i/o operation
+    // to be performed (see the defintion of output via operator<<(... ) below)
+    virtual const char *stringify();
+protected:
+    // This is the buffer into which the printed representation of this
+    // object will be put when the time comes.  It is associated with the
+    // object so it will never go away (so long as the object exists).
+    // Use a pointer so that you only pay for the space when I/O is used
+    tostrstream *stringbuf;
+    void clear_stringbuf();
+
+public:
+    //
+    // Consistency (global consistency)
+    //
+    // The global data invariant for the whole object (heirs included).
+    // This OK function will call the local invariant function ok() if
+    // necessary and in addition the OK functions of the heirs
+    // This is expected to compute the data invariant of the object.
+    // It will execute GctErrorHandler::fatal if there is wrong.
+    virtual void OK() const;
+
+protected:
+    //
+    // consistency (local consistency)
+    //
+    // This function computes the invariant which is local to this object.
+    // It does not call any of the ancestor's OK() or ok() functions.
+    // It is not a virtual function so that it can be called from within a
+    // constructor with impunity.  Thus this function MUST NOT call any
+    // virtual functions either; it should call them by their full name if
+    // that is necessary.  The global OK() function will call this function
+    // as necessary.
+    //
+    // This function must NOT NEVER EVER be made virtual.
+    void ok() const;
+protected:
+    //
+    // Class Name
+    //
+    // This must return a static (constant) string which is the name
+    // of the class being declared.  By convention, not all classes
+    // must have one of these, but the major root abstract class must
+    // have one in order to allow the stringify() to work approximately
+    // correctly.
+    virtual const char *class_name() const = 0;
+
+public:
+    //
+    // The ``id'' of this object
+    //
+    // NOTE - we explicitly allow the situation where this function
+    // can return the address of the object - the ``this'' pointer
+    // instead of a computed id field (the __object_id field below).
+    //
+    // This function is protected because we don't want too much dependence
+    // on this notion of object identity.  I want to be able to rip it
+    // out if it becomes to cumbersome.
+    unsigned objectId() const;
+private:
+    //
+    // Symbolic ID
+    //
+    // NOTE - Normally this would be implemented by the `this' pointer.
+    // TODO - remove this for production code
+    //
+    // However, in order to make the test suites run on all machines, we
+    // make this into a symbolic id that is maintained with each object.
+    // Thus the valid outputs are always consistent across all machines.
+    unsigned __object_id;
+    static unsigned __next_id;
+};
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 117 "../../../../mips/include/Gct/Object/GctObject.h" 2
+
+extern ostream& operator<<(ostream&, GctObject&);
+
+
+//# 25 "../../../../mips/include/Gct/Object/GctHashObject.h" 2
+
+
+//
+// GctHashObject class (is abstract)
+//
+class GctHashObject: virtual public GctObject {
+protected:
+    GctHashObject();
+    GctHashObject(const GctHashObject&);
+
+public:
+    //
+    // hash support
+    //
+    virtual unsigned hash() const;
+};
+
+
+//# 27 "../../../../mips/include/Gct/Reference/GctReferenceObject.h" 2
+
+
+class GctRef;
+
+//
+// GctReferenceObject class
+//
+class GctReferenceObject: virtual public GctHashObject {
+public:
+    // Aid in using operator new() to allocate dynamic
+    // instances of heirs to GctReferenceObject.
+    // An error is reported if result_of_new is nil.
+    static void ensure_new_succeeded(GctReferenceObject *result_of_new,
+				     const char *class_name,
+				     const char *args_supplied = "");
+
+    // the stringify() is standard
+    void OK() const;
+protected:
+    GctReferenceObject(const bool refcounting = FALSE);
+    GctReferenceObject(const GctReferenceObject&,
+		       const bool refcounting = FALSE);
+    virtual ~GctReferenceObject();
+
+    void operator=(const GctReferenceObject&);
+
+    void ok() const;
+
+    // Disallowed (create pointers to objects via new only)
+    // It is kept protected so that heirs can do *-cast-& tricks to work
+    // around the contravariance of abstract virtuals.  This operator should
+    // never be used to return an address of a GctReferenceObject.
+    GctReferenceObject *operator&() const;
+private:
+    const char *class_name() const;
+
+    bool _destructed;	// ensure no use of destructed objects
+    // this bit guards against the destruct-before-copy g++ bug
+
+    bool _refcounting;	// was allocated via operator new()
+    GctReferenceCount _refcount;
+
+    // TODO - these names can never be used again in a derived
+    // class; should they be obfuscated some to free up the
+    // names (these are good, commonly-used names).
+    void reference();
+    void dereference(GctReferenceObject *&);
+    void kill();
+
+    bool refcounted() const;
+    void refcounting();	// as if given in the constructor
+
+    // Using this scheme, only GctRef can manipulate the
+    // reference count via reference(), dereference().  The derived
+    // classes cannot do such, and the _refcount field is not
+    // available to be tweaked by GctRef in any way other
+    // way than the inc/dec/zero interface.
+    friend class GctRef;
+};
+
+
+//# 26 "../../../../mips/include/Gct/Reference.h" 2
+
+//# 1 "../../../../mips/include/Gct/Reference/GctRef.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctRef class
+//
+// Expects to be included by Gct/Reference.h
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/bool.h" 1
+
+
+
+
+
+
+
+//# 25 "../../../../mips/include/Gct/Reference/GctRef.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/Object/GctHashObject.h" 1
+// -*- C++ -*-
+//# 42 "../../../../mips/include/Gct/Object/GctHashObject.h"
+
+//# 27 "../../../../mips/include/Gct/Reference/GctRef.h" 2
+
+
+class GctReferenceObject;
+
+class GctRef: virtual public GctHashObject {
+public:
+    GctRef();
+    GctRef(const GctRef&);
+    virtual ~GctRef();
+
+    void operator=(GctRef&);
+
+    // Accessor functions
+    bool valid() const;			// the managed pointer is !null
+    bool null() const;			// the managed pointer is null
+
+    GctReferenceObject *ref() const;	// faults if not valid
+    operator void*() const;		// unchecked reference
+
+    void nullify();			// set the managed pointer to null
+    void invalidate();			// set the managed pointer to null
+
+    unsigned hash() const;
+
+    // the stringify() is standard
+    void OK() const;
+protected:
+    void ok() const;
+
+    // We want to make sure pointers do not float around for very long.
+    // This constructor is used by descendants of this class only; it is
+    // expected that such descendants will have friend functions which
+    // will call ``new MumbleObject()'' and return a GctRef to THAT.
+    // MumbleObject would be a descendant of GctReferenceObject
+    GctRef(GctReferenceObject *);
+    friend class GctReferenceObject;
+private:
+    const char *class_name() const;
+
+    GctReferenceObject *_pointer;	// may store 0
+
+    bool _destructed;	// ensure no use of destructed objects
+    // this bit guards against the destruct-before-copy g++ bug
+};
+
+inline
+GctRef::operator void*() const
+{ return this->_pointer; }
+
+inline bool
+GctRef::valid() const
+{ return (bool)(this->_pointer != 0); }
+
+inline bool
+GctRef::null() const
+{ return (bool)(this->_pointer == 0); }
+
+//
+// Required operations for the container classes
+//
+// NOTE: we can't use const here because the genclass code doesn't
+// That is the ONLY reason for not using const reference args here.
+//
+extern int operator==(GctRef&, GctRef&);
+extern int operator!=(GctRef&, GctRef&);
+
+extern int operator<=(GctRef&, GctRef&);
+extern int operator<(GctRef&, GctRef&);
+
+extern int operator>=(GctRef&, GctRef&);
+extern int operator>(GctRef&, GctRef&);
+
+extern unsigned hash(GctRef&);
+
+
+//# 27 "../../../../mips/include/Gct/Reference.h" 2
+
+
+
+//# 47 "../../../../mips/include/Gct/genclasses.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/Ast/GctAstRef.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctAstRef class
+//
+// Expects to be included by Gct/Ast.h
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "../../../../mips/include/Gct/Reference.h" 1
+// -*- C++ -*-
+//# 29 "../../../../mips/include/Gct/Reference.h"
+
+//# 25 "../../../../mips/include/Gct/Ast/GctAstRef.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/Ast/GctAstType.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctAstType enum
+//
+// Wendell Baker, Berkeley CAD Group, 1992 (wbaker@ic.Berkeley.EDU)
+//
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//
+// GctAstType enum
+//
+enum GctAstType {
+    Gct_Leaf,
+    Gct_Tree
+};
+
+extern const char *stringify(GctAstType a);
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 26 "../../../../mips/include/Gct/Ast/GctAstType.h" 2
+
+extern ostream& operator<<(ostream&, GctAstType);
+
+
+//# 27 "../../../../mips/include/Gct/Ast/GctAstRef.h" 2
+
+
+class GctAst;
+class GctTree;
+class GctLeaf;
+
+class GctAstRef: public GctRef {
+public:
+    GctAstRef();
+    GctAstRef(const GctAstRef&);
+
+    GctAst *ref() const;		// may return 0 (not requires valid)
+
+    GctAstType concrete_type() const;	// requires valid()
+    GctTree *tree() const;		// never return 0 - typechecked
+    GctLeaf *leaf() const;		// never return 0 - typechecked
+protected:
+    // We make sure pointers do not float around for very long.
+    // This constructor cooperates with Gct{Leaf,Tree}::New
+    // (all flavors) to allow for the creation of new dynamic structures.
+    GctAstRef(GctAst *);
+    friend class GctLeaf;
+    friend class GctTree;
+};
+
+
+//# 49 "../../../../mips/include/Gct/genclasses.h" 2
+
+
+
+//# 2 "GctNameRef.List.cc" 2
+
+//# 1 "../../../../mips/include/Gct/Name/GctNameRef.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctNameRef class
+//
+// Expects to be included by Gct/Name.h
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+
+
+
+
+//#pragma interface
+
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//# 1 "../../../../mips/include/Gct/Reference.h" 1
+// -*- C++ -*-
+//# 29 "../../../../mips/include/Gct/Reference.h"
+
+//# 25 "../../../../mips/include/Gct/Name/GctNameRef.h" 2
+
+
+//# 1 "../../../../mips/include/Gct/Name/GctNameType.h" 1
+// -*- C++ -*-
+
+
+
+//
+// GctNameType enum
+//
+// Wendell Baker, Berkeley CAD Group, 1991 (wbaker@ic.Berkeley.EDU)
+//
+
+// $Source: /cvs/cvsfiles/devo/gcc/testsuite/g++.old-deja/g++.mike/p785.C,v $
+// $Author: jason $
+// $Revision: 1.8 $
+// $Date: 1995/05/07 18:57:48 $
+
+//
+// GctNameType enum
+//
+enum GctNameType {
+    Gct_Identifier,
+    Gct_Signature,
+};
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h" 1
+//    This is part of the iostream library, providing -*- C++ -*- input/output.
+//    Copyright (C) 1991 Per Bothner.
+//
+//    This library is free software; you can redistribute it and/or
+//    modify it under the terms of the GNU Library General Public
+//    License as published by the Free Software Foundation; either
+//    version 2 of the License, or (at your option) any later version.
+//
+//    This library 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
+//    Library General Public License for more details.
+//
+//    You should have received a copy of the GNU Library General Public
+//    License along with this library; if not, write to the Free
+//    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+//# 210 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/iostream.h"
+
+//# 24 "../../../../mips/include/Gct/Name/GctNameType.h" 2
+
+
+extern char *ntoa(GctNameType n, unsigned width = 0);
+extern ostream& operator<<(ostream&, GctNameType);
+
+
+//# 27 "../../../../mips/include/Gct/Name/GctNameRef.h" 2
+
+
+class GctName;
+class GctIdentifier;
+class GctSignature;
+
+class GctNameRef: public GctRef {
+public:
+    GctNameRef();
+    GctNameRef(const GctNameRef&);
+
+    GctName *ref() const;		// may return 0 (not requires valid())
+
+    GctNameType concrete_type() const;	// requires valid()
+    GctIdentifier *identifier() const;	// never return 0 - typechecked
+    GctSignature *signature() const;	// never return 0 - typechecked
+protected:
+    // We make sure pointers do not float around for very long.
+    // This constructor cooperates with GctIdentifier::New and
+    // GctSignature::New  (all flavors) to allow for the creation of new
+    // dynamic structures.
+    GctNameRef(GctName *);
+    friend class GctIdentifier;
+    friend class GctSignature;
+
+private:
+    const char *class_name() const;
+};
+
+//
+// Required operations for use by genclass container classes
+//
+// These are more specific than the ones supplied by GctRef
+// because they use the name of the attribute as the key for
+// comparison instead of the pointer stored as a void* value.
+//
+// NOTE: we can't use const here because the genclass code doesn't
+// That is the ONLY reason for not using const reference args here.
+//
+extern int operator==(GctNameRef&, GctNameRef&);
+extern int operator!=(GctNameRef&, GctNameRef&);
+
+extern int operator<=(GctNameRef&, GctNameRef&);
+extern int operator<(GctNameRef&, GctNameRef&);
+
+extern int operator>=(GctNameRef&, GctNameRef&);
+extern int operator>(GctNameRef&, GctNameRef&);
+
+// extern unsigned hash(GctNameRef&)
+// is handled by the previous declaration of
+// extern unsigned hash(GctRef&);
+
+
+//# 3 "GctNameRef.List.cc" 2
+
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of GNU CC.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY.  No author or distributor
+accepts responsibility to anyone for the consequences of using it
+or for whether it serves any particular purpose or works at all,
+unless he says so in writing.  Refer to the GNU CC General Public
+License for full details.
+
+Everyone is granted permission to copy, modify and redistribute
+GNU CC, but only under the conditions described in the
+GNU CC General Public License.   A copy of this license is
+supposed to have been given to you along with GNU CC so you
+can know your rights and responsibilities.  It should be in a
+file named COPYING.  Among other things, the copyright notice
+and this notice must be preserved on all copies.
+*/
+
+
+//#pragma implementation
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h" 1
+// This may look like C code, but it is really -*- C++ -*-
+
+/*
+Copyright (C) 1988, 1992 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of the GNU C++ Library.  This library is free
+software; you can redistribute it and/or modify it under the terms of
+the GNU Library General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.  This library 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 Library General Public License for more details.
+You should have received a copy of the GNU Library General Public
+License along with this library; if not, write to the Free Software
+Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+  arithmetic, etc. functions on built in types
+*/
+
+
+//# 214 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/builtin.h"
+
+//# 30 "GctNameRef.List.cc" 2
+
+//# 1 "genclasses/GctNameRef.List.h" 1
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Pix.h" 1
+
+
+
+typedef void* Pix;
+
+//# 1 "genclasses/GctNameRef.List.h" 2
+
+// This may look like C code, but it is really -*- C++ -*-
+/*
+Copyright (C) 1988 Free Software Foundation
+    written by Doug Lea (dl@rocky.oswego.edu)
+
+This file is part of GNU CC.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY.  No author or distributor
+accepts responsibility to anyone for the consequences of using it
+or for whether it serves any particular purpose or works at all,
+unless he says so in writing.  Refer to the GNU CC General Public
+License for full details.
+
+Everyone is granted permission to copy, modify and redistribute
+GNU CC, but only under the conditions described in the
+GNU CC General Public License.   A copy of this license is
+supposed to have been given to you along with GNU CC so you
+can know your rights and responsibilities.  It should be in a
+file named COPYING.  Among other things, the copyright notice
+and this notice must be preserved on all copies.
+*/
+
+
+
+
+//#pragma once
+//#pragma interface
+
+
+
+
+
+typedef void (*GctNameRefProcedure)(GctNameRef&);
+typedef GctNameRef  (*GctNameRefMapper)(GctNameRef&);
+typedef GctNameRef  (*GctNameRefCombiner)(GctNameRef&, GctNameRef&);
+typedef int  (*GctNameRefPredicate)(GctNameRef&);
+typedef int  (*GctNameRefComparator)(GctNameRef&, GctNameRef&);
+
+
+//# 1 "/projects/gnu-cygnus/gnu-cygnus-8/common/g++-include/Pix.h" 1
+
+
+
+
+
+//# 42 "genclasses/GctNameRef.List.h" 2
+
+
+struct GctNameRefListNode
+{
+  GctNameRefListNode*          tl;
+  short                 ref;
+  GctNameRef                   hd;
+};
+
+extern GctNameRefListNode NilGctNameRefListNode;
+
+class GctNameRefList
+{
+protected:
+  GctNameRefListNode*          P;
+
+                        GctNameRefList(GctNameRefListNode* p);
+public:
+                        GctNameRefList();
+                        GctNameRefList(GctNameRef& head);
+                        GctNameRefList(GctNameRef& head, GctNameRefList& tl);
+                        GctNameRefList(GctNameRefList& a);
+                        GctNameRefList(Pix p);
+                        ~GctNameRefList();
+
+  GctNameRefList&              operator = (GctNameRefList& a);
+
+  int                   null();
+  int                   valid();
+                        operator const void* ();
+  int                   operator ! ();
+
+  int                   length() const;
+  int                   list_length();
+
+  GctNameRef&                  get();
+  GctNameRef&                  head();
+  GctNameRef&                  operator [] (int n);
+
+  GctNameRefList               nth(int n);
+  GctNameRefList               tail();
+  GctNameRefList               last() const;
+
+  GctNameRefList               find(GctNameRef& targ);
+  GctNameRefList               find(GctNameRefList& targ);
+  int                   contains(GctNameRef& targ) const;
+  int                   contains(GctNameRefList& targ) const;
+  int                   position(GctNameRef& targ);
+
+  friend GctNameRefList        copy(GctNameRefList& a);
+  friend GctNameRefList        concat(GctNameRefList& a, GctNameRefList& b);
+  friend GctNameRefList        append(GctNameRefList& a, GctNameRefList& b);
+  friend GctNameRefList        map(GctNameRefMapper f, GctNameRefList& a);
+  friend GctNameRefList        merge(GctNameRefList& a, GctNameRefList& b, GctNameRefComparator f);
+  friend GctNameRefList        combine(GctNameRefCombiner f, GctNameRefList& a, GctNameRefList& b);
+  friend GctNameRefList        reverse(GctNameRefList& a);
+  friend GctNameRefList        select(GctNameRefPredicate f, GctNameRefList& a);
+  friend GctNameRefList        remove(GctNameRef& targ, GctNameRefList& a);
+  friend GctNameRefList        remove(GctNameRefPredicate f, GctNameRefList& a);
+  friend GctNameRefList        subst(GctNameRef& old, GctNameRef& repl, GctNameRefList& a);
+
+  void                  push(GctNameRef& x);
+  GctNameRef                   pop();
+
+  void                  set_tail(GctNameRefList& p);
+  void                  append(GctNameRefList& p);
+  void                  prepend(GctNameRefList& p);
+  void                  del(GctNameRef& targ);
+  void                  del(GctNameRefPredicate f);
+  void                  select(GctNameRefPredicate f);
+  void                  subst(GctNameRef& old, GctNameRef& repl);
+  void                  reverse();
+  void                  sort(GctNameRefComparator f);
+
+  void                  apply(GctNameRefProcedure f);
+  GctNameRef                   reduce(GctNameRefCombiner f, GctNameRef& base);
+
+  friend int            operator == (GctNameRefList& a, GctNameRefList& b);
+  friend int            operator != (GctNameRefList& a, GctNameRefList& b);
+
+  Pix                   first() const;
+  void                  next(Pix& p) const;
+  Pix                   seek(GctNameRef& item) const;
+  GctNameRef&                  operator () (Pix p) const;
+  int                   owns(Pix p) const;
+
+  void                  error(const char*) const;
+  int                   OK() const;
+};
+
+
+
+inline void reference(GctNameRefListNode* p)
+{
+  if (p->ref >= 0) ++p->ref;
+}
+
+inline void dereference(GctNameRefListNode* p)
+{
+  while (p->ref > 0 && --p->ref == 0)
+  {
+    GctNameRefListNode* n = p->tl;
+    delete(p);
+    p = n;
+  }
+}
+
+
+inline GctNameRefListNode* newGctNameRefListNode(GctNameRef& h)
+{
+  GctNameRefListNode* p = new GctNameRefListNode;
+  p->ref = 1;
+  p->hd = h;
+  return p;
+}
+
+inline GctNameRefListNode* newGctNameRefListNode(GctNameRef& h, GctNameRefListNode* t)
+{
+  GctNameRefListNode* p = new GctNameRefListNode;
+  p->ref = 1;
+  p->hd = h;
+  p->tl = t;
+  return p;
+}
+
+
+inline GctNameRefList::~GctNameRefList()
+{
+  dereference(P);
+}
+
+inline GctNameRefList::GctNameRefList()
+{
+  P = &NilGctNameRefListNode;
+}
+
+inline GctNameRefList::GctNameRefList(GctNameRefListNode* p)
+{
+  P = p;
+}
+
+inline GctNameRefList::GctNameRefList(GctNameRef& head)
+{
+  P = newGctNameRefListNode(head);
+  P->tl = &NilGctNameRefListNode;
+}
+
+inline GctNameRefList::GctNameRefList(GctNameRef& head, GctNameRefList& tl)
+{
+  P = newGctNameRefListNode(head, tl.P);
+  reference(P->tl);
+}
+
+inline GctNameRefList::GctNameRefList(GctNameRefList& a)
+{
+  reference(a.P);
+  P = a.P;
+}
+
+
+inline GctNameRef& GctNameRefList::get()
+{
+  return P->hd;
+}
+
+inline GctNameRef& GctNameRefList::head()
+{
+  return P->hd;
+}
+
+
+inline GctNameRefList GctNameRefList::tail()
+{
+  reference(P->tl);
+  return GctNameRefList(P->tl);
+}
+
+
+
+inline int GctNameRefList::null()
+{
+  return P == &NilGctNameRefListNode;
+}
+
+inline int GctNameRefList::valid()
+{
+  return P != &NilGctNameRefListNode;
+}
+
+inline GctNameRefList::operator const void* ()
+{
+  return (P == &NilGctNameRefListNode)? 0 : this;
+}
+
+inline int GctNameRefList::operator ! ()
+{
+  return (P == &NilGctNameRefListNode);
+}
+
+
+inline void GctNameRefList::push(GctNameRef& head)
+{
+  GctNameRefListNode* oldp = P;
+  P = newGctNameRefListNode(head, oldp);
+}
+
+
+inline int operator != (GctNameRefList& x, GctNameRefList& y)
+{
+  return !(x == y);
+}
+
+inline Pix GctNameRefList::first() const
+{
+  return (P == &NilGctNameRefListNode)? 0 : Pix(P);
+}
+
+inline GctNameRef& GctNameRefList::operator () (Pix p) const
+{
+  return ((GctNameRefListNode*)p)->hd;
+}
+
+inline void GctNameRefList::next(Pix& p) const
+{
+  if (p != 0)
+  {
+    p = Pix(((GctNameRefListNode*)p)->tl);
+    if (p == &NilGctNameRefListNode) p = 0;
+  }
+}
+
+inline GctNameRefList::GctNameRefList(Pix p)
+{
+  P = (GctNameRefListNode*)p;
+  reference(P);
+}
+
+
+
+//# 31 "GctNameRef.List.cc" 2
+
+
+GctNameRefListNode NilGctNameRefListNode;
+
+class init_NilGctNameRefListNode
+{
+public:
+  inline init_NilGctNameRefListNode()
+  {
+    NilGctNameRefListNode.tl = &NilGctNameRefListNode;
+    NilGctNameRefListNode.ref = -1;
+  }
+};
+
+static init_NilGctNameRefListNode NilGctNameRefListNode_initializer;
+
+GctNameRefList& GctNameRefList::operator = (GctNameRefList& a)
+{
+  reference(a.P);
+  dereference(P);
+  P = a.P;
+  return *this;
+}
+
+GctNameRef GctNameRefList::pop()
+{
+  GctNameRef res = P->hd;
+  GctNameRefListNode* tail = P->tl;
+  reference(tail);
+  dereference(P);
+  P = tail;
+  return res;
+}
+
+void GctNameRefList::set_tail(GctNameRefList& a)
+{
+  reference(a.P);
+  dereference(P->tl);
+  P->tl = a.P;
+}
+
+GctNameRefList GctNameRefList::nth(int n)
+{
+  GctNameRefListNode* p;
+  for (p = P; n-- > 0; p = p->tl);
+  reference(p);
+  return GctNameRefList(p);
+}
+
+GctNameRefList GctNameRefList::last() const
+{
+  GctNameRefListNode* p = P;
+  if (p != &NilGctNameRefListNode) while (p->tl != &NilGctNameRefListNode) p = p->tl;
+  reference(p);
+  return GctNameRefList(p);
+}
+
+void GctNameRefList::append(GctNameRefList& l)
+{
+  GctNameRefListNode* p = P;
+  GctNameRefListNode* a = l.P;
+  reference(a);
+  if (p != &NilGctNameRefListNode)
+  {
+    while (p->tl != &NilGctNameRefListNode) p = p->tl;
+    p->tl = a;
+  }
+  else
+    P = a;
+}
+
+int GctNameRefList::length() const
+{
+  int l = 0;
+  for (GctNameRefListNode* p = P; p != &NilGctNameRefListNode; p = p->tl) ++l;
+  return l;
+}
+
+GctNameRef&  GctNameRefList::operator [] (int n)
+{
+  GctNameRefListNode* p;
+  for (p = P; n-- > 0; p = p->tl);
+  return (p->hd);
+}
+
+int operator == (GctNameRefList& x, GctNameRefList& y)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* b = y.P;
+
+  for (;;)
+  {
+    if (a == &NilGctNameRefListNode)
+      return b == &NilGctNameRefListNode;
+    else if (b == &NilGctNameRefListNode)
+      return 0;
+    else if (a->hd == b->hd)
+    {
+      a = a->tl;
+      b = b->tl;
+    }
+    else
+      return 0;
+  }
+}
+
+
+void GctNameRefList::apply(GctNameRefProcedure f)
+{
+  for(GctNameRefListNode* p = P; p != &NilGctNameRefListNode; p = p->tl)
+    (*f)((p->hd));
+}
+
+void GctNameRefList::subst(GctNameRef& old, GctNameRef& repl)
+{
+  for(GctNameRefListNode* p = P; p != &NilGctNameRefListNode; p = p->tl)
+    if (p->hd == old)
+      p->hd = repl;
+}
+
+GctNameRef GctNameRefList::reduce(GctNameRefCombiner f, GctNameRef& base)
+{
+  GctNameRef r = base;
+  for(GctNameRefListNode* p = P; p != &NilGctNameRefListNode; p = p->tl)
+    r = (*f)(r, (p->hd));
+  return r;
+}
+
+int GctNameRefList::position(GctNameRef& targ)
+{
+  int l = 0;
+  GctNameRefListNode* p = P;
+  for (;;)
+  {
+    if (p == &NilGctNameRefListNode)
+      return -1;
+    else if (p->hd == targ)
+      return l;
+    else
+    {
+      ++l;
+      p = p->tl;
+    }
+  }
+}
+
+int GctNameRefList::contains(GctNameRef& targ) const
+{
+  GctNameRefListNode* p = P;
+  for (;;)
+  {
+    if (p == &NilGctNameRefListNode)
+      return 0;
+    else if (p->hd == targ)
+      return 1;
+    else
+      p = p->tl;
+  }
+}
+
+GctNameRefList GctNameRefList::find(GctNameRef& targ)
+{
+  GctNameRefListNode* p;
+  for (p = P; p != &NilGctNameRefListNode && !(p->hd == targ); p=p->tl);
+  reference(p);
+  return GctNameRefList(p);
+}
+
+Pix GctNameRefList::seek(GctNameRef& targ) const
+{
+  GctNameRefListNode* p = P;
+  for (;;)
+  {
+    if (p == &NilGctNameRefListNode)
+      return 0;
+    else if (p->hd == targ)
+      return Pix(p);
+    else
+      p = p->tl;
+  }
+}
+
+int GctNameRefList::owns(Pix i) const
+{
+  GctNameRefListNode* p = P;
+  for (;;)
+  {
+    if (p == &NilGctNameRefListNode)
+      return 0;
+    else if (Pix(p) == i)
+      return 1;
+    else
+      p = p->tl;
+  }
+}
+
+GctNameRefList GctNameRefList::find(GctNameRefList& target)
+{
+  GctNameRefListNode* targ = target.P;
+  if (targ == &NilGctNameRefListNode)
+    return GctNameRefList(targ);
+
+  GctNameRefListNode* p = P;
+  while (p != &NilGctNameRefListNode)
+  {
+    if (p->hd == targ->hd)
+    {
+      GctNameRefListNode* a = p->tl;
+      GctNameRefListNode* t = targ->tl;
+      for(;;)
+      {
+        if (t == &NilGctNameRefListNode)
+        {
+          reference(p);
+          return GctNameRefList(p);
+        }
+        else if (a == &NilGctNameRefListNode || !(a->hd == t->hd))
+          break;
+        else
+        {
+          a = a->tl;
+          t = t->tl;
+        }
+      }
+    }
+    p = p->tl;
+  }
+  return GctNameRefList(&NilGctNameRefListNode);
+}
+
+int GctNameRefList::contains(GctNameRefList& target) const
+{
+  GctNameRefListNode* targ = target.P;
+  if (targ == &NilGctNameRefListNode)
+    return 0;
+
+  GctNameRefListNode* p = P;
+  while (p != &NilGctNameRefListNode)
+  {
+    if (p->hd == targ->hd)
+    {
+      GctNameRefListNode* a = p->tl;
+      GctNameRefListNode* t = targ->tl;
+      for(;;)
+      {
+        if (t == &NilGctNameRefListNode)
+          return 1;
+        else if (a == &NilGctNameRefListNode || !(a->hd == t->hd))
+          break;
+        else
+        {
+          a = a->tl;
+          t = t->tl;
+        }
+      }
+    }
+    p = p->tl;
+  }
+  return 0;
+}
+
+void GctNameRefList::del(GctNameRef& targ)
+{
+  GctNameRefListNode* h = P;
+
+  for (;;)
+  {
+    if (h == &NilGctNameRefListNode)
+    {
+      P = h;
+      return;
+    }
+    else if (h->hd == targ)
+    {
+      GctNameRefListNode* nxt = h->tl;
+      reference(nxt);
+      dereference(h);
+      h = nxt;
+    }
+    else
+      break;
+  }
+
+  GctNameRefListNode* trail = h;
+  GctNameRefListNode* p = h->tl;
+  while (p != &NilGctNameRefListNode)
+  {
+    if (p->hd == targ)
+    {
+      GctNameRefListNode* nxt = p->tl;
+      reference(nxt);
+      dereference(p);
+      trail->tl = nxt;
+      p = nxt;
+    }
+    else
+    {
+      trail = p;
+      p = p->tl;
+    }
+  }
+  P = h;
+}
+
+void GctNameRefList::del(GctNameRefPredicate f)
+{
+  GctNameRefListNode* h = P;
+  for (;;)
+  {
+    if (h == &NilGctNameRefListNode)
+    {
+      P = h;
+      return;
+    }
+    else if ((*f)(h->hd))
+    {
+      GctNameRefListNode* nxt = h->tl;
+      reference(nxt);
+      dereference(h);
+      h = nxt;
+    }
+    else
+      break;
+  }
+
+  GctNameRefListNode* trail = h;
+  GctNameRefListNode* p = h->tl;
+  while (p != &NilGctNameRefListNode)
+  {
+    if ((*f)(p->hd))
+    {
+      GctNameRefListNode* nxt = p->tl;
+      reference(nxt);
+      dereference(p);
+      trail->tl = nxt;
+      p = nxt;
+    }
+    else
+    {
+      trail = p;
+      p = p->tl;
+    }
+  }
+  P = h;
+}
+
+void GctNameRefList::select(GctNameRefPredicate f)
+{
+  GctNameRefListNode* h = P;
+  for (;;)
+  {
+    if (h == &NilGctNameRefListNode)
+    {
+      P = h;
+      return;
+    }
+    else if (!(*f)(h->hd))
+    {
+      GctNameRefListNode* nxt = h->tl;
+      reference(nxt);
+      dereference(h);
+      h = nxt;
+    }
+    else
+      break;
+  }
+  GctNameRefListNode* trail = h;
+  GctNameRefListNode* p = h->tl;
+  while (p != &NilGctNameRefListNode)
+  {
+    if (!(*f)(p->hd))
+    {
+      GctNameRefListNode* nxt = p->tl;
+      reference(nxt);
+      dereference(p);
+      trail->tl = nxt;
+      p = nxt;
+    }
+    else
+    {
+      trail = p;
+      p = p->tl;
+    }
+  }
+  P = h;
+}
+
+void GctNameRefList::reverse()
+{
+  GctNameRefListNode* l = &NilGctNameRefListNode;
+  GctNameRefListNode* p = P;
+  while (p != &NilGctNameRefListNode)
+  {
+    GctNameRefListNode* nxt = p->tl;
+    p->tl = l;
+    l = p;
+    p = nxt;
+  }
+  P = l;
+}
+
+
+GctNameRefList copy(GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  if (a == &NilGctNameRefListNode)
+    return GctNameRefList(a);
+  else
+  {
+    GctNameRefListNode* h = newGctNameRefListNode(a->hd);
+    GctNameRefListNode* trail = h;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = &NilGctNameRefListNode;
+    return GctNameRefList(h);
+  }
+}
+
+
+GctNameRefList subst(GctNameRef& old, GctNameRef& repl, GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  if (a == &NilGctNameRefListNode)
+    return GctNameRefList(a);
+  else
+  {
+    GctNameRefListNode* h = new GctNameRefListNode;
+    h->ref = 1;
+    if (a->hd == old)
+      h->hd = repl;
+    else
+      h->hd = a->hd;
+    GctNameRefListNode* trail = h;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = new GctNameRefListNode;
+      n->ref = 1;
+      if (a->hd == old)
+        n->hd = repl;
+      else
+        n->hd = a->hd;
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = &NilGctNameRefListNode;
+    return GctNameRefList(h);
+  }
+}
+
+GctNameRefList combine(GctNameRefCombiner f, GctNameRefList& x, GctNameRefList& y)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* b = y.P;
+  if (a == &NilGctNameRefListNode || b == &NilGctNameRefListNode)
+    return GctNameRefList(&NilGctNameRefListNode);
+  else
+  {
+    GctNameRefListNode* h = newGctNameRefListNode((*f)(a->hd, b->hd));
+    GctNameRefListNode* trail = h;
+    a = a->tl;
+    b = b->tl;
+    while (a != &NilGctNameRefListNode && b != &NilGctNameRefListNode)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode((*f)(a->hd, b->hd));
+      trail->tl = n;
+      trail = n;
+      a = a->tl;
+      b = b->tl;
+    }
+    trail->tl = &NilGctNameRefListNode;
+    return GctNameRefList(h);
+  }
+}
+
+GctNameRefList reverse(GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  if (a == &NilGctNameRefListNode)
+    return GctNameRefList(a);
+  else
+  {
+    GctNameRefListNode* l = newGctNameRefListNode(a->hd);
+    l->tl = &NilGctNameRefListNode;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+      n->tl = l;
+      l = n;
+    }
+    return GctNameRefList(l);
+  }
+}
+
+GctNameRefList append(GctNameRefList& x, GctNameRefList& y)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* b = y.P;
+  reference(b);
+  if (a != &NilGctNameRefListNode)
+  {
+    GctNameRefListNode* h = newGctNameRefListNode(a->hd);
+    GctNameRefListNode* trail = h;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = b;
+    return GctNameRefList(h);
+  }
+  else
+    return GctNameRefList(b);
+}
+
+void GctNameRefList::prepend(GctNameRefList& y)
+{
+  GctNameRefListNode* b = y.P;
+  if (b != &NilGctNameRefListNode)
+  {
+    GctNameRefListNode* h = newGctNameRefListNode(b->hd);
+    GctNameRefListNode* trail = h;
+    for(b = b->tl; b != &NilGctNameRefListNode; b = b->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(b->hd);
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = P;
+    P = h;
+  }
+}
+
+GctNameRefList concat(GctNameRefList& x, GctNameRefList& y)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* b = y.P;
+  if (a != &NilGctNameRefListNode)
+  {
+    GctNameRefListNode* h = newGctNameRefListNode(a->hd);
+    GctNameRefListNode* trail = h;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+      trail->tl = n;
+      trail = n;
+    };
+    for(;b != &NilGctNameRefListNode; b = b->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(b->hd);
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = &NilGctNameRefListNode;
+    return GctNameRefList(h);
+  }
+  else if (b != &NilGctNameRefListNode)
+  {
+    GctNameRefListNode* h = newGctNameRefListNode(b->hd);
+    GctNameRefListNode* trail = h;
+    for(b = b->tl; b != &NilGctNameRefListNode; b = b->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode(b->hd);
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = &NilGctNameRefListNode;
+    return GctNameRefList(h);
+  }
+  else
+    return GctNameRefList(&NilGctNameRefListNode);
+}
+
+GctNameRefList select(GctNameRefPredicate f, GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* h = &NilGctNameRefListNode;
+  while (a != &NilGctNameRefListNode)
+  {
+    if ((*f)(a->hd))
+    {
+      h = newGctNameRefListNode(a->hd);
+      GctNameRefListNode* trail = h;
+      for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+      {
+        if ((*f)(a->hd))
+        {
+          GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+          trail->tl = n;
+          trail = n;
+        }
+      }
+      trail->tl = &NilGctNameRefListNode;
+      break;
+    }
+    else
+      a = a->tl;
+  }
+  return GctNameRefList(h);
+}
+
+GctNameRefList remove(GctNameRefPredicate f, GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* h = &NilGctNameRefListNode;
+  while (a != &NilGctNameRefListNode)
+  {
+    if (!(*f)(a->hd))
+    {
+      h = newGctNameRefListNode(a->hd);
+      GctNameRefListNode* trail = h;
+      for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+      {
+        if (!(*f)(a->hd))
+        {
+          GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+          trail->tl = n;
+          trail = n;
+        }
+      }
+      trail->tl = &NilGctNameRefListNode;
+      break;
+    }
+    else
+      a = a->tl;
+  }
+  return GctNameRefList(h);
+}
+
+GctNameRefList remove(GctNameRef& targ, GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* h = &NilGctNameRefListNode;
+  while (a != &NilGctNameRefListNode)
+  {
+    if (!(a->hd == targ))
+    {
+      h = newGctNameRefListNode(a->hd);
+      GctNameRefListNode* trail = h;
+      for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+      {
+        if (!(a->hd == targ))
+        {
+          GctNameRefListNode* n = newGctNameRefListNode(a->hd);
+          trail->tl = n;
+          trail = n;
+        }
+      }
+      trail->tl = &NilGctNameRefListNode;
+      break;
+    }
+    else
+      a = a->tl;
+  }
+  return GctNameRefList(h);
+}
+
+GctNameRefList map(GctNameRefMapper f, GctNameRefList& x)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* h = &NilGctNameRefListNode;
+  if (a != &NilGctNameRefListNode)
+  {
+    h = newGctNameRefListNode((*f)(a->hd));
+    GctNameRefListNode* trail = h;
+    for(a = a->tl; a != &NilGctNameRefListNode; a = a->tl)
+    {
+      GctNameRefListNode* n = newGctNameRefListNode((*f)(a->hd));
+      trail->tl = n;
+      trail = n;
+    }
+    trail->tl = &NilGctNameRefListNode;
+  }
+  return GctNameRefList(h);
+}
+
+
+GctNameRefList merge(GctNameRefList& x, GctNameRefList& y, GctNameRefComparator f)
+{
+  GctNameRefListNode* a = x.P;
+  GctNameRefListNode* b = y.P;
+
+  if (a == &NilGctNameRefListNode)
+  {
+    if (b == &NilGctNameRefListNode)
+      return GctNameRefList(&NilGctNameRefListNode);
+    else
+      return copy(y);
+  }
+  else if (b == &NilGctNameRefListNode)
+    return copy(x);
+
+  GctNameRefListNode* h = new GctNameRefListNode;
+  h->ref = 1;
+  if ((*f)(a->hd, b->hd) <= 0)
+  {
+    h->hd = a->hd;
+    a = a->tl;
+  }
+  else
+  {
+    h->hd = b->hd;
+    b = b->tl;
+  }
+
+  GctNameRefListNode* r = h;
+
+  for(;;)
+  {
+    if (a == &NilGctNameRefListNode)
+    {
+      while (b != &NilGctNameRefListNode)
+      {
+        GctNameRefListNode* n = new GctNameRefListNode;
+        n->ref = 1;
+        n->hd = b->hd;
+        r->tl = n;
+        r = n;
+        b = b->tl;
+      }
+      r->tl = &NilGctNameRefListNode;
+      return GctNameRefList(h);
+    }
+    else if (b == &NilGctNameRefListNode)
+    {
+      while (a != &NilGctNameRefListNode)
+      {
+        GctNameRefListNode* n = new GctNameRefListNode;
+        n->ref = 1;
+        n->hd = a->hd;
+        r->tl = n;
+        r = n;
+        a = a->tl;
+      }
+      r->tl = &NilGctNameRefListNode;
+      return GctNameRefList(h);
+    }
+    else if ((*f)(a->hd, b->hd) <= 0)
+    {
+      GctNameRefListNode* n = new GctNameRefListNode;
+      n->ref = 1;
+      n->hd = a->hd;
+      r->tl = n;
+      r = n;
+      a = a->tl;
+    }
+    else
+    {
+      GctNameRefListNode* n = new GctNameRefListNode;
+      n->ref = 1;
+      n->hd = b->hd;
+      r->tl = n;
+      r = n;
+      b = b->tl;
+    }
+  }
+}
+
+void GctNameRefList::sort(GctNameRefComparator f)
+{
+  // strategy: place runs in queue, merge runs until done
+  // This is often very fast
+
+  if (P == &NilGctNameRefListNode || P->tl == &NilGctNameRefListNode)
+    return;
+
+  int qlen = 250;   // guess a good queue size, realloc if necessary
+
+  GctNameRefListNode** queue = (GctNameRefListNode**)malloc(qlen * sizeof(GctNameRefListNode*));
+
+  GctNameRefListNode* h = P;
+  GctNameRefListNode* a = h;
+  GctNameRefListNode* b = a->tl;
+  int qin = 0;
+
+  while (b != &NilGctNameRefListNode)
+  {
+    if ((*f)(a->hd, b->hd) > 0)
+    {
+      if (h == a)               // minor optimization: ensure runlen >= 2
+      {
+        h = b;
+        a->tl = b->tl;
+        b->tl = a;
+        b = a->tl;
+      }
+      else
+      {
+        if (qin >= qlen)
+        {
+          qlen *= 2;
+          queue = (GctNameRefListNode**)realloc(queue, qlen * sizeof(GctNameRefListNode*));
+        }
+        queue[qin++] = h;
+        a->tl = &NilGctNameRefListNode;
+        h = a = b;
+        b = b->tl;
+      }
+    }
+    else
+    {
+      a = b;
+      b = b->tl;
+    }
+  }
+
+  int count = qin;
+  queue[qin] = h;
+  if (++qin >= qlen) qin = 0;
+  int qout = 0;
+
+  while (count-- > 0)
+  {
+    a = queue[qout];
+    if (++qout >= qlen) qout = 0;
+    b = queue[qout];
+    if (++qout >= qlen) qout = 0;
+
+    if ((*f)(a->hd, b->hd) <= 0)
+    {
+      h = a;
+      a = a->tl;
+    }
+    else
+    {
+      h = b;
+      b = b->tl;
+    }
+    queue[qin] = h;
+    if (++qin >= qlen) qin = 0;
+
+    for (;;)
+    {
+      if (a == &NilGctNameRefListNode)
+      {
+        h->tl = b;
+        break;
+      }
+      else if (b == &NilGctNameRefListNode)
+      {
+        h->tl = a;
+        break;
+      }
+      else if ((*f)(a->hd, b->hd) <= 0)
+      {
+        h->tl = a;
+        h = a;
+        a = a->tl;
+      }
+      else
+      {
+        h->tl = b;
+        h = b;
+        b = b->tl;
+      }
+    }
+  }
+  P = queue[qout];
+  free(queue);
+}
+
+int GctNameRefList::list_length()
+{
+  GctNameRefListNode* fast = P;
+  if (fast == &NilGctNameRefListNode)
+    return 0;
+
+  GctNameRefListNode* slow = fast->tl;
+  if (slow == &NilGctNameRefListNode)
+    return 1;
+
+  fast = slow->tl;
+  int n = 2;
+
+  for (;;)
+  {
+    if (fast == &NilGctNameRefListNode)
+      return n;
+    else if (fast->tl == &NilGctNameRefListNode)
+      return n+1;
+    else if (fast == slow)
+      return -1;
+    else
+    {
+      n += 2;
+      fast = fast->tl->tl;
+      slow = slow->tl;
+    }
+  }
+}
+
+void GctNameRefList::error(const char* msg) const
+{
+  (*lib_error_handler)("List", msg);
+}
+
+int GctNameRefList::OK() const
+{
+  int v = P != 0;               // have a node
+  // check that all nodes OK, even if circular:
+
+  GctNameRefListNode* fast = P;
+  if (fast != &NilGctNameRefListNode)
+  {
+    v &= fast->ref != 0;
+    GctNameRefListNode* slow = fast->tl;
+    v &= slow->ref != 0;
+    if (v && slow != &NilGctNameRefListNode)
+    {
+      fast = slow->tl;
+      v &= fast->ref != 0;
+      while (v)
+      {
+        if (fast == &NilGctNameRefListNode)
+          break;
+        else if (fast->tl == &NilGctNameRefListNode)
+          break;
+        else if (fast == slow)
+          break;
+        else
+        {
+          v &= fast->ref != 0 && slow->ref != 0;
+          fast = fast->tl->tl;
+          slow = slow->tl;
+        }
+      }
+    }
+  }
+  if (!v) error ("invariant failure");
+  return v;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p786.C b/gcc/testsuite/g++.old-deja/g++.mike/p786.C
new file mode 100644
index 00000000000..258c36511de
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p786.C
@@ -0,0 +1,35 @@
+// prms-id: 786
+
+extern "C" void printf (char *, ...);
+extern "C" void exit(int);
+class C
+   {
+   int a;
+public:
+   C() {a = 1;}
+   };
+
+void func(const C& a, C& b)
+{
+   printf ("in const func\n");
+   exit(1);
+}
+
+void func(C& a, C& b)
+{
+   printf ("in non-const func\n");
+}
+
+void testit(const C& a, C& b)
+{
+   func(a,b);
+}
+
+main()
+{
+   C a;
+   C b;
+
+   func(a,b);
+   return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7865.C b/gcc/testsuite/g++.old-deja/g++.mike/p7865.C
new file mode 100644
index 00000000000..d9a611889b1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7865.C
@@ -0,0 +1,28 @@
+// prms-id: 7865
+
+int count;
+
+struct A {
+  A() { ++count; }
+  ~A() { --count; }
+};
+
+int foo() { return 1; }
+
+int bar()
+{
+  A a;
+  for (;;) {
+    A b;
+    if (foo())
+      return 0;
+    if (foo())
+      return 0;
+  }
+  return 0;
+}
+
+main() {
+  bar();
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7868.C b/gcc/testsuite/g++.old-deja/g++.mike/p7868.C
new file mode 100644
index 00000000000..d8ce95d3c66
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7868.C
@@ -0,0 +1,21 @@
+// Build don't link:
+// prms-id: 7868
+
+struct DIAGTYP {
+};
+struct DIAGTYP1 {
+  struct DIAGTYP;
+  void bar() { new struct DIAGTYP; }	// ERROR - undefined
+  void foo() { new struct DIAGTYP1; }
+};
+
+int main () {
+  struct DIAGTYP;
+  struct DIAGTYP  *lerror_desc;
+  lerror_desc= new struct DIAGTYP;	// ERROR - undefined
+}
+
+void foo () {
+  struct DIAGTYP  *lerror_desc;
+  lerror_desc= new struct DIAGTYP;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p789.C b/gcc/testsuite/g++.old-deja/g++.mike/p789.C
new file mode 100644
index 00000000000..09815989d5b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p789.C
@@ -0,0 +1,28 @@
+// prms-id: 789
+
+extern "C" void printf (char *, ...);
+struct foo
+{
+  static int count;
+  virtual void print (int i, int j) { printf ("foo[%d][%d] = %d\n", i, j, x); }
+  int x;
+  foo () { x = count++; }
+};
+int foo::count;
+struct bar : virtual public foo
+{
+  virtual void print (int i, int j) { printf ("bar[%d][%d] = %d\n", i, j, x); }
+};
+
+// bar array[3][3];
+foo array[3][3];
+
+main ()
+{
+  for (int i = 0; i < 3; i++)
+    for (int j = 0; j < 3; j++) {
+//      printf("&a[%d][%d] = %x\n", i, j, (void *)&array[i][j]);
+      array[i][j].print (i, j);
+    }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p789a.C b/gcc/testsuite/g++.old-deja/g++.mike/p789a.C
new file mode 100644
index 00000000000..9086ff54cfe
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p789a.C
@@ -0,0 +1,43 @@
+// global and local multidimensional array objects are not getting
+// constructors called on any dimension, other than the first.  Also,
+// the destructors are not being called.  Seems odd, they probably
+// used to work. :-(
+// prms-id: 789
+
+extern "C" void printf (char *, ...);
+struct foo
+{
+  static int count;
+  void print (int i, int j) { printf ("foo[%d][%d] = %d\n", i, j, x); }
+  int x;
+  foo () {
+    x = count++;
+    printf("this %d = %x\n", x, (void *)this);
+  }
+  virtual ~foo () {
+    printf("this %d = %x\n", x, (void *)this);
+    --count;
+  }
+};
+int foo::count;
+
+
+main ()
+{
+  {
+    foo array[3][3];
+    for (int i = 0; i < 3; i++)
+      {
+	for (int j = 0; j < 3; j++)
+	  {
+	    printf("&a[%d][%d] = %x\n", i, j, (void *)&array[i][j]);
+	  }
+      }
+      // The count should be nine, if not, fail the test.
+      if (foo::count != 9)
+	return 1;
+  }
+  if (foo::count != 0)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p7912.C b/gcc/testsuite/g++.old-deja/g++.mike/p7912.C
new file mode 100644
index 00000000000..40f45c48c12
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p7912.C
@@ -0,0 +1,23 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+// prms-id: 7912
+
+int count = 0;
+
+class Foo {
+public:
+  Foo() { ++count; };
+  Foo(const Foo&) { ++count; };
+  ~Foo() { --count; };
+};
+
+
+main()
+{
+  try {
+    throw Foo();
+  }
+  catch (Foo object) {
+  }
+  return count;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8009.C b/gcc/testsuite/g++.old-deja/g++.mike/p8009.C
new file mode 100644
index 00000000000..e8a124b40cf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8009.C
@@ -0,0 +1,12 @@
+// prms-id: 8009
+
+class A {
+public:
+  int i;
+};
+
+class B : public A {
+  B();
+};
+
+B::B() : i (-1) {}		// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8018.C b/gcc/testsuite/g++.old-deja/g++.mike/p8018.C
new file mode 100644
index 00000000000..37035bcd591
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8018.C
@@ -0,0 +1,85 @@
+// prms-id: 8018
+
+class RefCount {
+private:
+  int nref;
+
+public:
+  RefCount() : nref(0) {}
+  ~RefCount() {}
+
+  int nrefs() const { return nref; }
+  int reference() {
+    nref++;
+    return nref;
+  }
+  int unreference() {
+    nref--;
+    return nref;
+  }
+};
+
+class A : public RefCount {
+public:
+  A() {}
+  ~A() {}
+};
+
+class RefA {
+private:
+  A *p;
+
+  void clear() {
+    if (p) {
+      p->unreference();
+      if (!p->nrefs())
+	delete p;
+    }
+  }
+
+public:
+  RefA(A* a) : p(a) { if (p) p->reference(); }
+  RefA(const RefA& a) : p(a.p) { if (p) p->reference(); }
+  ~RefA() { clear(); }
+
+  A* operator->() { return p; }
+
+  RefA& operator=(const RefA& a) {
+    clear();
+    p=a.p;
+    if (p)
+      p->reference();
+    return *this;
+  }
+
+  RefA& operator=(A* a) {
+    clear();
+    p=a;
+    if (p)
+      p->reference();
+    return *this;
+  }
+};
+
+class AccRefA {
+private:
+  RefA a;
+
+public:
+  AccRefA(A* ap) : a(ap) {}
+  AccRefA(const RefA& ar) : a(ar) {}
+  ~AccRefA() {}
+
+  operator RefA&() { return a; }
+  RefA& result() { return a; }
+};
+
+int
+main() {
+  RefA a1 = new A;
+  AccRefA aa1(a1);
+  RefA a3 = aa1;
+
+  if (a1->nrefs() != 3)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8039.C b/gcc/testsuite/g++.old-deja/g++.mike/p8039.C
new file mode 100644
index 00000000000..73defeccd97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8039.C
@@ -0,0 +1,14 @@
+// prms-id: 8039
+
+class C {
+public:
+  int func ();
+};
+
+extern void bar(int*);
+
+main()
+{
+  int (C::*mfp)() = &C::func;
+  bar((int*)mfp);		// ERROR - no clear semantics
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p807.C b/gcc/testsuite/g++.old-deja/g++.mike/p807.C
new file mode 100644
index 00000000000..59df08e5149
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p807.C
@@ -0,0 +1,34 @@
+// prms-id: 807
+
+extern "C" int printf(const char*, ...);
+
+class B;
+
+class AX
+{
+ protected:
+   int x;
+
+ public:
+   operator B();
+};
+
+
+class B
+{
+ private:
+   int x;
+ public:
+   B(const AX&);
+};
+
+
+int foo(B& b);			// ERROR - referenced below
+
+
+main()
+{
+   AX a;
+   foo(a);  // ERROR - Ambiguous B(a) or a.operator B()  //  See ARM 12.3.2
+
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p807a.C b/gcc/testsuite/g++.old-deja/g++.mike/p807a.C
new file mode 100644
index 00000000000..d7b797af8e0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p807a.C
@@ -0,0 +1,22 @@
+// Build don't link:
+// prms-id: 807
+
+// See ARM page 275 Section 12.3.2
+
+extern "C" void printf (char *, ...);
+extern "C" void exit(int);
+
+class B;
+
+class A {
+public:
+	A(B&);			// ERROR - fn ref in err msg
+};
+
+class B {
+public:
+	operator A();		// ERROR - fn ref in err msg
+};
+
+B b;
+A a = b;  // ERROR - should fail as it is ambigious.
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p811.C b/gcc/testsuite/g++.old-deja/g++.mike/p811.C
new file mode 100644
index 00000000000..59b15d19823
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p811.C
@@ -0,0 +1,549 @@
+// This test case caused the compiler to abort at one point in time.
+// Build don't link:
+// Special g++ Options:
+// prms-id: 811
+
+class ostream; class streambuf;
+
+typedef long streamoff, streampos;
+
+struct _ios_fields {  
+    streambuf *_strbuf;
+    ostream* _tie;
+    int _width;
+    unsigned long _flags;
+    char _fill;
+    unsigned char _state;
+    unsigned short _precision;
+};
+
+
+enum state_value { _good = 0, _eof = 1,  _fail = 2, _bad  = 4 };
+enum open_mode { input=1, output=2, append=8 };
+
+
+class ios : public _ios_fields {
+  public:
+    enum io_state { goodbit=0, eofbit=1, failbit=2, badbit=4 };
+    enum open_mode {
+	in=1,
+	out=2,
+	ate=4,
+	app=8,
+	trunc=16,
+	nocreate=32,
+	noreplace=64 };
+    enum seek_dir { beg, cur, end};
+    enum { skipws=01, left=02, right=04, internal=010,
+	   dec=020, oct=040, hex=0100,
+	   showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
+	   scientific=04000, fixed=0100000, unitbuf=020000, stdio=040000,
+	   dont_close=0x80000000  
+	   };
+
+    ostream* tie() const { return _tie; }
+    ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
+
+     
+    char fill() const { return _fill; }
+    char fill(char newf) { char oldf = _fill; _fill = newf; return oldf; }
+    unsigned long flags() const { return _flags; }
+    unsigned long flags(unsigned long new_val) {
+	unsigned long old_val = _flags; _flags = new_val; return old_val; }
+    unsigned short precision() const { return _precision; }
+    unsigned short precision(int newp) {
+	unsigned short oldp = _precision; _precision = (unsigned short)newp;
+	return oldp; }
+    unsigned long setf(unsigned long val) {
+	unsigned long oldbits = _flags;
+	_flags |= val; return oldbits; }
+    unsigned long setf(unsigned long val, unsigned long mask) {
+	unsigned long oldbits = _flags;
+	_flags = (_flags & ~mask) | (val & mask); return oldbits; }
+    unsigned long unsetf(unsigned long mask) {
+	unsigned long oldbits = _flags & mask;
+	_flags &= ~mask; return oldbits; }
+    int width() const { return _width; }
+    int width(long val) { long save = _width; _width = val; return save; }
+
+    static const unsigned long basefield;
+    static const unsigned long adjustfield;
+    static const unsigned long floatfield;
+
+    streambuf* rdbuf() const { return _strbuf; }
+    void clear(int state = 0) { _state = state; }
+    int good() const { return _state == 0; }
+    int eof() const { return _state & ios::eofbit; }
+    int fail() const { return _state & (ios::badbit|ios::failbit); }
+    int bad() const { return _state & ios::badbit; }
+    int rdstate() const { return _state; }
+    void set(int flag) { _state |= flag; }
+    operator void*() const { return fail() ? (void*)0 : (void*)this; }
+    int operator!() const { return fail(); }
+
+
+    void unset(state_value flag) { _state &= ~flag; }
+    void close();
+    int is_open();
+    int readable();
+    int writable();
+
+
+  protected:
+    ios(streambuf*sb) { _strbuf=sb; _state=0; _width=0; _fill=' ';
+			_flags=ios::skipws; _precision=6; }
+};
+
+
+
+
+typedef ios::seek_dir _seek_dir;
+
+
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//# 168 "/usr/latest/lib/g++-include/streambuf.h" 3
+
+
+struct __streambuf {
+     
+    int _flags;		 
+    char* _gptr;	 
+    char* _egptr;	 
+    char* _eback;	 
+    char* _pbase;	 
+    char* _pptr;	 
+    char* _epptr;	 
+    char* _base;	 
+    char* _ebuf;	 
+    struct streambuf *_chain;
+
+
+
+
+};
+
+struct streambuf : private __streambuf {
+    friend class ios;
+    friend class istream;
+    friend class ostream;
+  protected:
+    static streambuf* _list_all;  
+    streambuf*& xchain() { return _chain; }
+    void _un_link();
+    void _link_in();
+    char* gptr() const { return _gptr; }
+    char* pptr() const { return _pptr; }
+    char* egptr() const { return _egptr; }
+    char* epptr() const { return _epptr; }
+    char* pbase() const { return _pbase; }
+    char* eback() const { return _eback; }
+    char* ebuf() const { return _ebuf; }
+    char* base() const { return _base; }
+    void xput_char(char c) { *_pptr++ = c; }
+    int xflags() { return _flags; }
+    int xflags(int f) { int fl = _flags; _flags = f; return fl; }
+    void xsetflags(int f) { _flags |= f; }
+    void gbump(int n) { _gptr += n; }
+    void pbump(int n) { _pptr += n; }
+    void setb(char* b, char* eb, int a=0);
+    void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
+    void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
+  public:
+    static int flush_all();
+    static void flush_all_linebuffered();  
+    virtual int underflow();  
+    virtual int overflow(int c = (-1) );  
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
+    int sputbackc(char c);
+    int sungetc();
+    streambuf();
+    virtual ~streambuf();
+    int unbuffered() { return _flags & 2  ? 1 : 0; }
+    int linebuffered() { return _flags & 0x4000  ? 1 : 0; }
+    void unbuffered(int i)
+	{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
+    void linebuffered(int i)
+	{ if (i) _flags |= 0x4000 ; else _flags &= ~0x4000 ; }
+    int allocate() {
+	if (base() || unbuffered()) return 0;
+	else return doallocate(); }
+    virtual int sync();
+    virtual int pbackfail(int c);
+    virtual int ungetfail();
+    virtual streambuf* setbuf(char* p, int len);
+    int in_avail() { return _egptr - _gptr; }
+    int out_waiting() { return _pptr - _pbase; }
+    virtual int sputn(const char* s, int n);
+    virtual int sgetn(char* s, int n);
+    long sgetline(char* buf, int  n, char delim, int putback_delim);
+    int sbumpc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr++; }
+    int sgetc() {
+	if (_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int snextc() {
+	if (++_gptr >= _egptr && underflow() == (-1) ) return (-1) ;
+	else return *(unsigned char*)_gptr; }
+    int sputc(int c) {
+	if (_pptr >= _epptr) return overflow(c);
+	return *_pptr++ = c, (unsigned char)c; }
+    int vscan(char const *fmt0, char*  ap);
+    int vform(char const *fmt0, char*  ap);
+
+
+
+
+
+
+};
+
+struct __file_fields {
+    char _fake;
+    char _shortbuf[1];
+    short _fileno;
+    int _blksize;
+    char* _save_gptr;
+    char* _save_egptr;
+    long   _offset;
+};
+
+class filebuf : public streambuf {
+    struct __file_fields _fb;
+    void init();
+  public:
+    filebuf();
+    filebuf(int fd);
+    filebuf(int fd, char* p, int len);
+    ~filebuf();
+    filebuf* attach(int fd);
+    filebuf* open(const char *filename, const char *mode);
+    filebuf* open(const char *filename, int mode, int prot = 0664);
+    virtual int underflow();
+    virtual int overflow(int c = (-1) );
+    int is_open() { return _fb._fileno >= 0; }
+    int fd() { return is_open() ? _fb._fileno : (-1) ; }
+    filebuf* close();
+    virtual int doallocate();
+    virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
+    int sputn(const char* s, int n);
+    int sgetn(char* s, int n);
+    virtual int sync();
+  protected:  
+    virtual int pbackfail(int c);
+    int is_reading() { return eback() != egptr(); }
+    char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
+     
+    char* file_ptr() { return _fb._save_gptr ? _fb._save_egptr : egptr(); }
+    int do_flush();
+     
+    virtual int sys_read(char* buf, int  size);
+    virtual long   sys_seek(long  , _seek_dir);
+    virtual long sys_write(const void*, long);
+    virtual int sys_stat(void*);  
+    virtual int sys_close();
+};
+
+
+inline int ios::readable() { return rdbuf()->_flags & 4 ; }
+inline int ios::writable() { return rdbuf()->_flags & 8 ; }
+inline int ios::is_open() {return rdbuf()->_flags & 4 +8 ;}
+
+
+
+
+//# 25 "/usr/latest/lib/g++-include/iostream.h" 2 3
+
+
+class istream; class ostream;
+typedef istream& (*__imanip)(istream&);
+typedef ostream& (*__omanip)(ostream&);
+
+extern istream& ws(istream& ins);
+extern ostream& flush(ostream& outs);
+extern ostream& endl(ostream& outs);
+extern ostream& ends(ostream& outs);
+
+class ostream : public ios
+{
+    void do_osfx();
+  public:
+    ostream();
+    ostream(streambuf* sb, ostream* tied=((void*)0) );
+    ~ostream();
+
+    int opfx() { if (!good()) return 0; if (_tie) _tie->flush(); return 1; }
+    void osfx() { if (flags() & (ios::unitbuf|ios::stdio))
+		      do_osfx(); }
+    streambuf* ostreambuf() const { return _strbuf; }
+    ostream& flush();
+    ostream& put(char c);
+    ostream& write(const char *s, int n);
+    ostream& write(const unsigned char *s, int n) { return write((char*)s, n);}
+    ostream& write(const void *s, int n) { return write((char*)s, n);}
+    ostream& seekp(streampos);
+    ostream& seekp(streamoff, _seek_dir);
+    streampos tellp();
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args);
+};
+
+extern ostream& operator<<(ostream&, char c);
+inline ostream& operator<<(ostream& os, unsigned char c)
+{ return os << (char)c; }
+ 
+extern ostream& operator<<(ostream&, const char *s);
+inline ostream& operator<<(ostream& os, const unsigned char *s)
+{ return os << (const char*)s; }
+ 
+ 
+extern ostream& operator<<(ostream&, void *p);
+extern ostream& operator<<(ostream&, int n);
+extern ostream& operator<<(ostream&, long n);
+extern ostream& operator<<(ostream&, unsigned int n);
+extern ostream& operator<<(ostream&, unsigned long n);
+inline ostream& operator<<(ostream& os, short n) {return os << (int)n;}
+inline ostream& operator<<(ostream& os, unsigned short n)
+{return os << (unsigned int)n;}
+extern ostream& operator<<(ostream&, float n);
+extern ostream& operator<<(ostream&, double n);
+inline ostream& operator<<(ostream& os, __omanip func) { return (*func)(os); }
+extern ostream& operator<<(ostream&, streambuf*);
+
+class istream : public ios
+{
+    int  _gcount;
+  public:
+    istream();
+    istream(streambuf* sb, ostream*tied=((void*)0) );
+    ~istream();
+    streambuf* istreambuf() const { return _strbuf; }
+    istream& get(char& c);
+    istream& get(unsigned char& c);
+    istream& read(char *ptr, int n);
+    istream& read(unsigned char *ptr, int n) { return read((char*)ptr, n); }
+    istream& read(void *ptr, int n) { return read((char*)ptr, n); }
+     
+    istream& getline(char* ptr, int len, char delim = '\n');
+    istream& get(char* ptr, int len, char delim = '\n');
+    istream& gets(char **s, char delim = '\n');
+    int ipfx(int need) {
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
+	if (!need && (flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx0() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie) _tie->flush();
+	if ((flags() & ios::skipws) && !ws(*this)) return 0;
+	return 1;
+    }
+    int ipfx1() {  
+	if (!good()) { set(ios::failbit); return 0; }
+	if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
+	return 1;
+    }
+    int get() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sbumpc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    int peek() { if (!ipfx1()) return (-1) ;
+		int ch = _strbuf->sgetc();
+		if (ch == (-1) ) set(ios::eofbit);
+		return ch; }
+    int  gcount() { return _gcount; }
+    istream& ignore(int n=1, int delim = (-1) );
+    istream& seekg(streampos);
+    istream& seekg(streamoff, _seek_dir);
+    streampos tellg();
+    istream& putback(char ch) {
+	if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
+	return *this;}
+    istream& unget() {
+	if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
+	return *this;}
+
+    istream& unget(char ch) { return putback(ch); }
+    int skip(int i);
+
+};
+
+extern istream& operator>>(istream&, char*);
+inline istream& operator>>(istream& is, unsigned char* p)
+{ return is >> (char*)p; }
+ 
+extern istream& operator>>(istream&, char& c);
+extern istream& operator>>(istream&, unsigned char& c);
+ 
+extern istream& operator>>(istream&, int&);
+extern istream& operator>>(istream&, long&);
+extern istream& operator>>(istream&, short&);
+extern istream& operator>>(istream&, unsigned int&);
+extern istream& operator>>(istream&, unsigned long&);
+extern istream& operator>>(istream&, unsigned short&);
+extern istream& operator>>(istream&, float&);
+extern istream& operator>>(istream&, double&);
+inline istream& operator>>(istream& is, __imanip func) { return (*func)(is); }
+
+inline ostream& ostream::put(char c) { _strbuf->sputc(c); return *this; }
+
+class iostream : public ios {
+    int  _gcount;
+  public:
+    iostream();
+    iostream(streambuf* sb, ostream*tied=((void*)0) );
+    operator istream&() { return *(istream*)this; }
+    operator ostream&() { return *(ostream*)this; }
+    ~iostream();
+     
+    istream& get(char& c) { return ((istream*)this)->get(c); }
+    istream& get(unsigned char& c) { return ((istream*)this)->get(c); }
+    istream& read(char *ptr, int n) { return ((istream*)this)->read(ptr, n); }
+    istream& read(unsigned char *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    istream& read(void *ptr, int n)
+	{ return ((istream*)this)->read((char*)ptr, n); }
+    istream& getline(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->getline(ptr, len, delim); }
+    istream& get(char* ptr, int len, char delim = '\n')
+	{ return ((istream*)this)->get(ptr, len, delim); }
+    istream& gets(char **s, char delim = '\n')
+	{ return ((istream*)this)->gets(s, delim); }
+    istream& ignore(int n=1, int delim = (-1) )
+	{ return ((istream*)this)->ignore(n, delim); }
+    int ipfx(int need) { return ((istream*)this)->ipfx(need); }
+    int ipfx0()  { return ((istream*)this)->ipfx0(); }
+    int ipfx1()  { return ((istream*)this)->ipfx1(); }
+    int get() { return _strbuf->sbumpc(); }
+    int peek() { return ipfx1() ? _strbuf->sgetc() : (-1) ; }
+    int  gcount() { return _gcount; }
+    istream& putback(char ch) { return ((istream*)this)->putback(ch); }
+    istream& unget() { return ((istream*)this)->unget(); }
+    istream& seekg(streampos pos) { return ((istream*)this)->seekg(pos); }
+    istream& seekg(streamoff off, _seek_dir dir)
+	{ return ((istream*)this)->seekg(off, dir); }
+    streampos tellg() { return ((istream*)this)->tellg(); }
+
+    istream& unget(char ch) { return putback(ch); }
+
+
+     
+    int opfx() { return ((ostream*)this)->opfx(); }
+    void osfx() { ((ostream*)this)->osfx(); }
+    ostream& flush() { return ((ostream*)this)->flush(); }
+    ostream& put(char c) { return ((ostream*)this)->put(c); }
+    ostream& write(const char *s, int n)
+	{ return ((ostream*)this)->write(s, n); }
+    ostream& write(const unsigned char *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& write(const void *s, int n)
+	{ return ((ostream*)this)->write((char*)s, n); }
+    ostream& form(const char *format ...);
+    ostream& vform(const char *format, char*  args)
+	{ return ((ostream*)this)->vform(format, args); }
+    ostream& seekp(streampos pos) { return ((ostream*)this)->seekp(pos); }
+    ostream& seekp(streamoff off, _seek_dir dir)
+	{ return ((ostream*)this)->seekp(off, dir); }
+    streampos tellp() { return ((ostream*)this)->tellp(); }
+};
+
+extern istream cin;
+extern ostream cout, cerr, clog;  
+
+struct Iostream_init { } ;   
+
+inline ios& dec(ios& i)
+{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& hex(ios& i)
+{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
+inline ios& oct(ios& i)
+{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
+
+
+//# 7 "/usr/latest/lib/g++-include/stream.h" 2 3
+
+
+extern char* form(const char*, ...);
+
+extern char* dec(long, int=0);
+extern char* dec(int, int=0);
+extern char* dec(unsigned long, int=0);
+extern char* dec(unsigned int, int=0);
+
+extern char* hex(long, int=0);
+extern char* hex(int, int=0);
+extern char* hex(unsigned long, int=0);
+extern char* hex(unsigned int, int=0);
+
+extern char* oct(long, int=0);
+extern char* oct(int, int=0);
+extern char* oct(unsigned long, int=0);
+extern char* oct(unsigned int, int=0);
+
+inline istream& WS(istream& str) { return ws(str); }
+
+
+//# 9 "test.C" 2
+
+
+class Y {
+public:
+    Y() {}
+    virtual const char *stringify() = 0;
+    virtual char *stringify2() const = 0; // ERROR - 
+};
+
+class X: public Y {
+public:
+    X(): Y() {}
+    char *stringify();		// ERROR - ok
+    const char *stringify2() const;  // ERROR - ok
+};
+
+char *
+X::stringify() const
+{ // ERROR - ok
+    return "stringify";
+}
+
+const char *
+X::stringify2()
+{ // ERROR - ok
+    return "stringify2";
+}
+
+main()
+{
+    X x;
+    Y& y = x;
+
+    cout << "x\n";
+    cout << x.stringify() << '\n';
+    cout << x.stringify2() << '\n';
+
+    cout << "y\n";
+    cout << y.stringify() << '\n';
+    cout << y.stringify2() << '\n';
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8154.C b/gcc/testsuite/g++.old-deja/g++.mike/p8154.C
new file mode 100644
index 00000000000..b68ea5dd194
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8154.C
@@ -0,0 +1,19 @@
+// Build don't link:
+// Special g++ Options:
+// prms-id: 8154
+
+class QvFieldData;
+class QvNode {
+    QvFieldData *fieldData;
+};
+class QvGroup : public QvNode {
+  static QvFieldData *fieldData;
+};
+class QvUnknownNode : public QvGroup
+{
+public:
+  QvUnknownNode :: QvUnknownNode ();
+private:
+  static QvFieldData *fieldData;
+  virtual QvFieldData *getFieldData() { return fieldData; }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8155.C b/gcc/testsuite/g++.old-deja/g++.mike/p8155.C
new file mode 100644
index 00000000000..f62291062f1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8155.C
@@ -0,0 +1,147 @@
+// prms-id: 8155
+
+int fail = 1;
+
+class CMainWindow;
+class CFrameWnd;
+class CWnd;
+class CCmdTarget;
+ 
+typedef void (CCmdTarget::*AFX_PMSG)( void);
+typedef void (CWnd::*AFX_PMSGW)( void);
+
+struct AFX_MSGMAP_ENTRY {
+  unsigned int  nMessage;    
+  AFX_PMSG pfn;
+};
+
+struct AFX_MSGMAP {
+  const AFX_MSGMAP* pBaseMap;
+  const AFX_MSGMAP_ENTRY* lpEntries;
+};
+
+class CCmdTarget {
+public:
+  CCmdTarget();
+private:
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+protected:
+  static const AFX_MSGMAP messageMap;
+  virtual const AFX_MSGMAP* GetMessageMap() const; 
+};
+
+const   AFX_MSGMAP CCmdTarget::messageMap = {
+  0, &CCmdTarget::_messageEntries[0]
+};
+
+const AFX_MSGMAP* CCmdTarget::GetMessageMap() const {
+  return &CCmdTarget::messageMap;
+}
+
+AFX_MSGMAP_ENTRY CCmdTarget::_messageEntries[] =
+{
+  { 0, 0 }
+};
+
+CCmdTarget :: CCmdTarget() { }
+ 
+class CWnd : public CCmdTarget {
+public:
+  CWnd();
+
+protected:
+  void OnPaint();
+private:
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+protected:
+  static   const AFX_MSGMAP messageMap;
+  virtual const AFX_MSGMAP* GetMessageMap() const; 
+};
+
+CWnd :: CWnd() {
+}
+
+void CWnd :: OnPaint() {
+}
+
+const AFX_MSGMAP*   CWnd ::GetMessageMap() const {
+  return &  CWnd ::messageMap;
+}
+const AFX_MSGMAP   CWnd ::messageMap = {
+  &  CCmdTarget ::messageMap, &  CWnd ::_messageEntries[0]
+  };
+AFX_MSGMAP_ENTRY   CWnd ::_messageEntries[] = { 
+  {0, (AFX_PMSG)0 } }; 
+
+class CFrameWnd : public CWnd {
+public:
+  CFrameWnd();
+protected:
+private:
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+protected:
+  static   const AFX_MSGMAP messageMap;
+  virtual const AFX_MSGMAP* GetMessageMap() const; 
+};
+
+CFrameWnd :: CFrameWnd() { }
+
+const AFX_MSGMAP*   CFrameWnd ::GetMessageMap() const {
+  return &  CFrameWnd ::messageMap;
+}
+const AFX_MSGMAP   CFrameWnd ::messageMap = {
+  &  CWnd ::messageMap, &  CFrameWnd ::_messageEntries[0]
+  };
+AFX_MSGMAP_ENTRY   CFrameWnd ::_messageEntries[] = { 
+  {0, (AFX_PMSG)0 } }; 
+
+class CMainWindow : public CFrameWnd {
+public:
+  CMainWindow();
+  void OnPaint();
+  void callProc();
+private:
+  static AFX_MSGMAP_ENTRY _messageEntries[];
+protected:
+  static   const AFX_MSGMAP messageMap;
+  virtual const AFX_MSGMAP* GetMessageMap() const; 
+};
+
+CMainWindow :: CMainWindow()
+{
+}
+void CMainWindow :: OnPaint()
+{
+  fail = 0;
+}
+
+void CMainWindow :: callProc()
+{
+  const AFX_MSGMAP* pMessageMap;
+  const AFX_MSGMAP_ENTRY *lpEntry;
+
+  pMessageMap = GetMessageMap();
+  lpEntry = pMessageMap->lpEntries;
+
+  if( lpEntry->nMessage == 100) {
+    (this->*lpEntry->pfn)();
+  }
+}
+
+const AFX_MSGMAP*   CMainWindow ::GetMessageMap() const {
+  return &  CMainWindow ::messageMap;
+}
+const AFX_MSGMAP   CMainWindow ::messageMap = {
+  &  CFrameWnd ::messageMap, &  CMainWindow ::_messageEntries[0]
+  };
+AFX_MSGMAP_ENTRY   CMainWindow ::_messageEntries[] = { 
+  { 100, (AFX_PMSG)(AFX_PMSGW)(void (CWnd::*)(void))&CMainWindow::OnPaint },
+  {0, (AFX_PMSG)0 }
+}; 
+
+main( int argc, char **argv) {
+  CMainWindow     myWindow;
+
+  myWindow.callProc();
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8175.C b/gcc/testsuite/g++.old-deja/g++.mike/p8175.C
new file mode 100644
index 00000000000..8ae40588ad8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8175.C
@@ -0,0 +1,14 @@
+// prms-id: 8175
+
+class AtoBoolC {
+public:
+  AtoBoolC(const AtoBoolC& aBool);
+private:
+  int myValue;
+};
+
+struct TestCase {
+  AtoBoolC is_call_on_unack;
+};
+
+static TestCase the_cases[] = { { 0 } };	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8269.C b/gcc/testsuite/g++.old-deja/g++.mike/p8269.C
new file mode 100644
index 00000000000..f886fe78fca
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8269.C
@@ -0,0 +1,11 @@
+// Build don't link:
+// prms-id: 8269
+
+typedef char* const char_ptr;
+
+class Foo_Bar {
+public:
+  static char* const counter;
+};
+
+char_ptr Foo_Bar::counter = 0;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8460.C b/gcc/testsuite/g++.old-deja/g++.mike/p8460.C
new file mode 100644
index 00000000000..542921c5738
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8460.C
@@ -0,0 +1,17 @@
+// Build don't link:
+// prms-id: 8460
+
+class A {
+public:
+  A();
+  A(int) { }
+  A(const A&) { }
+private:
+};
+
+main()
+{
+  A a;
+  
+  a.A(1);	// ERROR - cannot find name this way
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8483.C b/gcc/testsuite/g++.old-deja/g++.mike/p8483.C
new file mode 100644
index 00000000000..b04901844fa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8483.C
@@ -0,0 +1,35 @@
+// prms-id: 8483
+
+int count;
+
+class A {
+public:
+  A() { ++count; }
+  ~A() { }
+};
+
+class B {
+private:
+  A b[2];  
+};
+
+class C {
+public:
+private:
+  A c[2][2];
+};
+
+class D {
+public:
+private:
+  A d[2][2][2];
+};
+
+main() {
+  { A a; }
+  { B b; }
+  { C c; }
+  { D d; }
+  if (count != 15)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8620.C b/gcc/testsuite/g++.old-deja/g++.mike/p8620.C
new file mode 100644
index 00000000000..dc6f017adff
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8620.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// prms-id: 8620
+
+struct S {
+  long l;
+};
+
+typedef unsigned long l;
+
+void f() {
+  S* p;
+  if (p->l < 0)
+    return;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8785.C b/gcc/testsuite/g++.old-deja/g++.mike/p8785.C
new file mode 100644
index 00000000000..9c977fdcd30
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8785.C
@@ -0,0 +1,25 @@
+// Build don't link:
+// prms-id: 8785
+
+class Outer {
+private:
+  int x;
+public:
+  struct Inner {
+    int y;
+    void f( Outer * p, int i) {
+      p->x = i;			// ERROR - 
+    };
+    void f( Outer & p) {
+      p.x = y;			// ERROR - 
+    };
+  };
+};
+
+main() {
+  Outer::Inner A;
+  Outer Thing;
+
+  A.f(Thing);
+  A.f(&Thing,2);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8786.C b/gcc/testsuite/g++.old-deja/g++.mike/p8786.C
new file mode 100644
index 00000000000..b5443c0fa6b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8786.C
@@ -0,0 +1,24 @@
+// Build don't link:
+// Special g++ Options: -O
+// prms-id: 8786
+
+class B {
+public:
+  inline ~B();
+};
+
+class D : public B {
+public:
+  D(int);
+};
+
+int foo() {
+  D t(0);
+
+  bool h = 1;
+  if (h) {
+    D p(0);
+    return 0;
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8804.C b/gcc/testsuite/g++.old-deja/g++.mike/p8804.C
new file mode 100644
index 00000000000..e46a4c677ec
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8804.C
@@ -0,0 +1,18 @@
+// prms-id: 8804
+
+extern "C" int printf (const char *, ...);
+
+struct Fails {
+  int i;
+  union {
+    union {
+      int c;
+    };
+  };
+};
+
+Fails d;
+
+main() {
+  return &d.i == &d.c;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p8825.C b/gcc/testsuite/g++.old-deja/g++.mike/p8825.C
new file mode 100644
index 00000000000..11de74e78d2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p8825.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// prms-id: 8825
+
+class A {
+  typedef A x;
+};
+
+class B {
+  typedef B x;
+};
+
+class C : public A, public B {
+  typedef C x;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9068.C b/gcc/testsuite/g++.old-deja/g++.mike/p9068.C
new file mode 100644
index 00000000000..67e879fbd94
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9068.C
@@ -0,0 +1,21 @@
+// prms-id: 9068
+
+struct ostream {
+  void operator<< (int);	// ERROR - fn ref in err msg
+};
+
+class C {
+public:
+  static int& i ();
+  static int& i (int signatureDummy);
+};
+
+void foo (ostream& lhs, const C& rhs)
+{
+  lhs << rhs.i;		// ERROR - no such i for any opr << ()
+}
+
+int& C::i () {
+  static int _i = 4711;
+  return _i;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9129.C b/gcc/testsuite/g++.old-deja/g++.mike/p9129.C
new file mode 100644
index 00000000000..d94f46fa097
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9129.C
@@ -0,0 +1,12 @@
+// Build don't link:
+// Special g++ Options: -ansi -pedantic-errors
+// prms-id: 9129
+
+class Foo {
+public:
+  int DoSomething();
+};
+
+int (Foo::*pA)() = { &Foo::DoSomething };				// ERROR - 
+int (Foo::*X[1])(int) = { { &Foo::DoSomething } };			// ERROR - 
+int (Foo::*Y[])(int) = { { &Foo::DoSomething, &Foo::DoSomething, 0 } }; // ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9206.C b/gcc/testsuite/g++.old-deja/g++.mike/p9206.C
new file mode 100644
index 00000000000..5c4b578b866
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9206.C
@@ -0,0 +1,21 @@
+// prms-id: 9206
+
+class X {
+public:
+  void xtest() { }
+};
+
+class Y { };
+
+typedef void (X::*Xptr)();
+typedef void (Y::*Yptr)();
+
+int main() {
+  X xx;
+
+  Xptr xp = &X::xtest;
+  Yptr yp = reinterpret_cast<Yptr>(xp);
+  xp = reinterpret_cast<Xptr>(yp);
+
+  (xx.*xp)();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9506.C b/gcc/testsuite/g++.old-deja/g++.mike/p9506.C
new file mode 100644
index 00000000000..7c6e47b8e47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9506.C
@@ -0,0 +1,7 @@
+// Build don't link:
+// prms-id: 9506
+
+char * volatile p;
+void foo() {
+  --p = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9706.C b/gcc/testsuite/g++.old-deja/g++.mike/p9706.C
new file mode 100644
index 00000000000..c21f6c6585c
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9706.C
@@ -0,0 +1,33 @@
+// Special g++ Options: -fexceptions
+// excess errors test - XFAIL a29k-*-* sparc64-*-elf sh-*-* arm-*-pe**-*
+// prms-id: 9706
+
+#include <stdlib.h>
+
+int count, acount;
+
+void *operator new(size_t sz) { ++count; return malloc (sz); }
+void operator delete(void *p) throw() { --count; free (p); }
+
+class A {
+public:
+  A() { ++acount; }
+  A(const A&) { ++acount; }
+  ~A() { --acount; }
+};
+
+int main() {
+  int i;
+
+  for( i = 0; i < 10; i++ ) {
+    try {
+      throw A();
+    }
+    catch (A& a) {
+    }
+  }
+  if (acount)
+    return 1;
+  if (count)
+    return 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9732a.C b/gcc/testsuite/g++.old-deja/g++.mike/p9732a.C
new file mode 100644
index 00000000000..13c89892b84
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9732a.C
@@ -0,0 +1,36 @@
+// prms-id: 9732
+
+class A {
+  int i;
+public:
+  A() { i = 1; }
+  ~A() { }
+};
+
+struct value {
+  A x,y,z;
+};
+
+int crash(const value* capt, value* jet) {
+  return capt == jet;
+}
+
+class euler {
+public:
+  value number() const { return _value; }
+  int distance();
+
+private:
+  value _value;
+};
+
+int euler::distance() {
+  const value& capt = number();
+  value jet;
+  return crash (&capt, &jet);
+}
+
+int main() {
+  euler e;
+  return e.distance();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9732b.C b/gcc/testsuite/g++.old-deja/g++.mike/p9732b.C
new file mode 100644
index 00000000000..aadb374b996
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9732b.C
@@ -0,0 +1,42 @@
+// prms-id: 9732
+
+int count;
+int bail = 0;
+
+struct base {
+  base () { ++count; }
+  ~base () { --count; }
+  base(const base&o) { ++count; }
+};
+
+class D {
+public:
+  ~D() {
+    if (bail++)
+      {
+	// On some Linux boxes, we run the dtor for d twice,
+	// once before exit, and once after!
+	abort ();
+      }
+    else
+      {
+	if (count != 0)
+	  exit (1);
+	exit (0);
+      }
+  }
+} d;
+
+base base_object;
+
+base base_returning_function ();
+
+const base& base_ref = base_returning_function ();
+
+int main () {
+}
+
+base base_returning_function () {
+  base local_base_object;
+  return local_base_object;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p9732c.C b/gcc/testsuite/g++.old-deja/g++.mike/p9732c.C
new file mode 100644
index 00000000000..9ec773cc9af
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p9732c.C
@@ -0,0 +1,5 @@
+// Build don't link:
+// prms-id: 9732
+
+struct foo {};
+foo& x() { return foo(); }	// WARNING - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/p991.C b/gcc/testsuite/g++.old-deja/g++.mike/p991.C
new file mode 100644
index 00000000000..037227c4f3e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/p991.C
@@ -0,0 +1,22 @@
+// Build don't link:
+// prms-id: 991
+
+class Complex {
+public:
+	double re;
+	double im;
+	Complex(double r,double i) : re(r), im(i) {}
+};
+
+Complex cos(const Complex&);
+
+extern "C" double cos (double);		// not the same as the above
+extern "C" double cosh (double);
+extern "C" double sin (double);
+extern "C" double sinh (double);
+
+Complex cos(const Complex& arg) {
+	double nr = cos(arg.re)*cosh(arg.im);
+	double ni = -sin(arg.re)*sinh(arg.im);
+	return Complex(nr,ni);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/parse1.C b/gcc/testsuite/g++.old-deja/g++.mike/parse1.C
new file mode 100644
index 00000000000..12e26cf26ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/parse1.C
@@ -0,0 +1,7 @@
+// Build don't link:
+
+enum { name1 };
+struct name0 { };
+struct name1 { };
+struct derived1 : public name1 { };
+struct derived2 : public name0, public name1 { };
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmd1.C b/gcc/testsuite/g++.old-deja/g++.mike/pmd1.C
new file mode 100644
index 00000000000..260dc095eba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmd1.C
@@ -0,0 +1,12 @@
+// Build don't link:
+
+class A;
+struct XX { int A::*py; };
+
+class A {
+public:
+  int p;
+  void setp(XX *xp);
+};
+
+void A::setp(XX *xp) { xp->py = &A::p; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf1.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf1.C
new file mode 100644
index 00000000000..5b2dde87543
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf1.C
@@ -0,0 +1,90 @@
+// extern "C" printf(const char *, ...);
+
+class X
+{
+public:
+  int  a;
+  int f(int);
+};
+
+class Y
+{
+public:
+  int b;
+  int c;
+  int g(int);
+};
+
+class MD : public X, public Y
+{
+public:
+  int c;
+  int hf(int);
+};
+
+int MD::* pmi0 = &MD::a;
+int MD::* pmi1 = &MD::b;
+int MD::* pmi2 = &MD::c;
+
+int (MD::* pmf0)(int) = &MD::f;
+int (MD::* pmf1)(int) = &MD::g;
+int (MD::* pmf2)(int) = &MD::hf;
+
+main()
+{
+  MD obj;
+  int fail = 0;
+
+  obj.a = 1;
+  obj.b = 2;
+  obj.c = 3;
+
+  obj.*pmi0 = 7;
+  obj.*pmi1 = 8;
+  obj.*pmi2 = 9;
+
+  fail += (obj.*pmf0)(7);
+  fail += (obj.*pmf1)(8);
+  fail += (obj.*pmf2)(9);
+
+#if 0
+  if (fail != 0)
+    printf ("failed %d tests\n", fail);
+  else
+    printf ("passed\n");
+
+  printf ("sizeof(X) = %d, sizeof(Y) = %d, sizeof(MD) = %d\n",
+	  sizeof(X), sizeof(Y), sizeof(MD));
+#endif
+  return fail;
+}
+
+int X::f(int v)
+{
+  if (v != a)
+  {
+//    printf ("failed in X::f, a = %d\n", a);
+    return 1;
+  }
+  return 0;
+}
+
+int Y::g(int v)
+{
+  if (v != b)
+  {
+//    printf ("failed in Y::g, b = %d\n", b);
+    return 1;
+  }
+  return 0;
+}
+
+int MD::hf(int v)
+{
+  if (v != c)
+  {
+//    printf ("failed in MD::hf, c = %d\n", c);
+    return 1;
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf2.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf2.C
new file mode 100644
index 00000000000..2f1bec51e95
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf2.C
@@ -0,0 +1,54 @@
+extern "C" int printf(const char *, ...);
+
+class A_table {
+  int c;
+public:
+  A_table() { c = 3;}
+  virtual void func2(int &item) { printf("func2(%d,) c=%d\n",item,c);}
+};
+
+class B_table : private A_table {
+  typedef void (B_table::* B_ti_fn) (int &item);
+public:
+  B_table() { j = 0x4321;}
+  virtual void call_fn_fn1(int &item, void *pfn1);
+  void func1(int &item) { printf("func1(%d)\n",item);}
+  virtual void func2(int &item) { printf("func2(%d) j=%d\n",item,j);}
+  int j;
+};
+
+class foo : public A_table {
+public:
+  int i;
+  virtual ~foo();
+  virtual void func2(int &item) { printf("func2(%d) i=%d\n",item,i);}
+};
+foo::~foo() { i = 0;}
+
+class bar :public foo,public B_table {
+public:
+  int w;
+  virtual ~bar();
+  virtual void func2(int &item) { printf("func2(%d) w=%d\n",item,w);}
+};
+bar::~bar() { w = 0;}
+
+void B_table::call_fn_fn1(int &item, void *pfn1) {
+  (this->*(*(B_ti_fn*)pfn1))(item);
+}
+
+B_table b;
+bar jar;
+
+main() {
+  printf("ptr to B_table=%x, ptr to A_table=%x\n",&b,(A_table*)&b);
+  B_table::B_ti_fn z = &B_table::func1;
+  int j = 1;
+  jar.call_fn_fn1(j,(void *)&z);
+  j++;
+  z = &B_table::func2;
+  b.call_fn_fn1(j,(void *)&z);
+  j++;
+  jar.call_fn_fn1(j,(void *)&z);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf3.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf3.C
new file mode 100644
index 00000000000..24753eb1f9a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf3.C
@@ -0,0 +1,19 @@
+struct Fooey {
+  void f(char* pX);
+  void f(int in);
+  void f(float fx);
+  void h(double dx);
+};
+
+void Fooey::f(char*) { }
+void Fooey::f(int) { }
+void Fooey::f(float) { }
+void Fooey::h(double zahl) { }
+
+int main() {
+  Fooey Blah;
+  void (Fooey::*pointer)(double);
+  pointer = &Fooey::f;		// ERROR - don't call Fooey::h
+  (Blah.*pointer)(42.5);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf4.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf4.C
new file mode 100644
index 00000000000..02e5b10c1ac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf4.C
@@ -0,0 +1,13 @@
+// Build don't link:
+
+class NF { };
+
+struct QF {
+  NF nf;
+
+  typedef float(NF::* const NPF)() const;
+
+  void p (NPF npf) const {
+    float q = (nf.*npf)();
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf5.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf5.C
new file mode 100644
index 00000000000..685801a8591
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf5.C
@@ -0,0 +1,31 @@
+// Special g++ Options: -w
+
+class A {
+  int j;
+};
+
+class Space {
+  int j;
+};
+
+typedef int (A::*pma)();
+
+class B : public Space, virtual public A {
+public:
+  int i;
+  int foo () {
+    return i!=42;
+  }
+  B() {
+    i = 42;
+  }
+};
+
+int call_base (A* ap, pma pmf) {
+  return (ap->*pmf)();
+}
+
+int main() {
+  B b;
+  return call_base ((A*)&b, (pma)&B::foo);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf6.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf6.C
new file mode 100644
index 00000000000..c5327070617
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf6.C
@@ -0,0 +1,12 @@
+// Special g++ Options:
+
+class S {
+public:
+  void (S::*pmf)();
+  void foo() {
+    pmf();			// WARNING - 
+  }
+  static foo1(S* sp) {
+    (sp->pmf)();		// ERROR - 
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf7.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf7.C
new file mode 100644
index 00000000000..b238171ba5f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf7.C
@@ -0,0 +1,29 @@
+class A;
+typedef int (A::*f_ptr) (void);
+
+class B {
+public:
+  B() {}; ~B() {};
+  B& dummy(f_ptr cb) { return *this; };
+};
+
+template<class SP, class CB> SP& call_dummy(SP* sp, CB cb) {
+  sp->dummy(cb);
+  return *sp;
+};
+
+class A {
+public:
+  A() {}; ~A() {};
+  int ok() { return 0; };
+  A& call_it(B* s) {
+    call_dummy(s, &A::ok);
+    return *this;
+  };
+};
+
+int main() {
+  A a; B b;
+  a.call_it(&b);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf8.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf8.C
new file mode 100644
index 00000000000..41a4c0194fb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf8.C
@@ -0,0 +1,31 @@
+int fail;
+
+class A *ptr_a;
+
+class A {
+public:
+  char space1[24];
+  virtual void foo() {
+    if (this != ptr_a)
+      fail = 1;
+  }
+};
+
+class Space {
+  char space2[36];
+};
+
+class B : public Space, public A {
+} b;
+
+void (B::*pmf1)() = &A::foo;
+void (A::*pmf2)() = &A::foo;
+
+int main() {
+  ptr_a = &b;
+  (b .* (void (B::*) ()) &A::foo) ();
+  (b .* pmf1) ();
+  (b .* pmf2) ();
+  (b .* &A::foo) ();
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pmf9.C b/gcc/testsuite/g++.old-deja/g++.mike/pmf9.C
new file mode 100644
index 00000000000..800618ff6c6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pmf9.C
@@ -0,0 +1,23 @@
+class K {
+public:
+  int f(int i) { return i; }
+};
+
+class Q {
+public:
+  Q() { kp = new K; }
+  int g();
+private:
+  K * kp;
+};
+
+int Q::g() {
+  return (kp->f)(42);
+};
+
+
+int main () {
+  Q q;
+  if (q.g() != 42)
+    return 1;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pt1.C b/gcc/testsuite/g++.old-deja/g++.mike/pt1.C
new file mode 100644
index 00000000000..2ef8556b13d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pt1.C
@@ -0,0 +1,36 @@
+template <class T, class V>
+class A {
+public:
+  A (T at, V av);
+  void print () { }
+protected:
+  T t;
+  V v;
+};
+
+template <class T, class V>
+A<T, V>::A (T at, V av) {
+  t = at;
+  v = av;
+}
+
+
+template <class T, class V>
+class B: public virtual A<T, V> {
+public:
+  B (T at, V av);
+  void print () { }
+};
+
+template <class T, class V>
+B<T, V>::B (T at, V av) : A<T, V> (at, av) { }	// gets bogus error - 
+
+int main () {
+  int i = 2;
+  double x = 2;
+
+  B<int, double> ab(i, x);
+  ab.print();
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pt2.C b/gcc/testsuite/g++.old-deja/g++.mike/pt2.C
new file mode 100644
index 00000000000..7c96cabff4d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pt2.C
@@ -0,0 +1,22 @@
+class A {
+public:
+};
+
+template <class T>
+class B: public virtual A {
+public:
+  B ();
+  ~B ();
+};
+
+template <class T>
+B<T>::B () { }
+
+template <class T>
+B<T>::~B () { }
+
+int main () {
+  B<int> ab;
+
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pt3.C b/gcc/testsuite/g++.old-deja/g++.mike/pt3.C
new file mode 100644
index 00000000000..b2abc2bdc46
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pt3.C
@@ -0,0 +1,26 @@
+// Build don't link:
+
+template<class Repr>
+class syHandle
+{
+protected:
+  syHandle();
+  ~syHandle();
+  Repr *_repr;
+};
+
+template<class Repr>
+syHandle<Repr>::~syHandle()
+{
+}
+
+typedef char * char_ptr_t;
+syHandle<char_ptr_t>::syHandle() 
+{
+    _repr = 0;
+}
+
+syHandle<char_ptr_t>::~syHandle() 
+{
+    _repr = 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/pt4.C b/gcc/testsuite/g++.old-deja/g++.mike/pt4.C
new file mode 100644
index 00000000000..00e8ad052df
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/pt4.C
@@ -0,0 +1,4 @@
+// Build don't link:
+
+template <char* c> struct B { B() { } };
+B<0> bnull; 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/ref1.C b/gcc/testsuite/g++.old-deja/g++.mike/ref1.C
new file mode 100644
index 00000000000..054c9850c67
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/ref1.C
@@ -0,0 +1,21 @@
+int count;
+
+struct base {
+  base () { ++count; }
+  ~base () { --count; }
+  base(const base&o) { ++count; }
+};
+
+base base_returning_function ();
+
+const base& base_ref = base_returning_function ();
+
+int main () {
+  if (count != 1)
+    return 1;
+}
+
+base base_returning_function () {
+  base local_base_object;
+  return local_base_object;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/rtti1.C b/gcc/testsuite/g++.old-deja/g++.mike/rtti1.C
new file mode 100644
index 00000000000..e44c5fafdc5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/rtti1.C
@@ -0,0 +1,4 @@
+// Build don't link:
+
+#include <typeinfo>
+#include <iostream.h>
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/rtti2.C b/gcc/testsuite/g++.old-deja/g++.mike/rtti2.C
new file mode 100644
index 00000000000..bf08ede33fd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/rtti2.C
@@ -0,0 +1,5 @@
+#include <typeinfo>
+
+main() {
+  typeid(bool);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/rtti3.C b/gcc/testsuite/g++.old-deja/g++.mike/rtti3.C
new file mode 100644
index 00000000000..a250a26b0f4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/rtti3.C
@@ -0,0 +1,23 @@
+class base {
+public:
+  virtual ~base() {}
+  virtual void m1() = 0;
+  virtual void m2() = 0;
+};
+
+class intermediate : public virtual base {
+public:
+  virtual ~intermediate() {}
+  virtual void m1() {}
+  virtual void m2() {}
+};
+
+class derived : public intermediate {
+public:
+  virtual int IwantedThisMethod() { return 0; }
+  virtual int ButIgotThisOne() { return 1; }
+};
+
+int main() {
+  return derived().IwantedThisMethod();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/scast1.C b/gcc/testsuite/g++.old-deja/g++.mike/scast1.C
new file mode 100644
index 00000000000..dbc5efc4e40
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/scast1.C
@@ -0,0 +1,7 @@
+class A {};
+class C {};
+
+main() {
+  A* a = 0;
+  C* c = static_cast<C*>(a);	// ERROR - bad static cast 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/temp.C b/gcc/testsuite/g++.old-deja/g++.mike/temp.C
new file mode 100644
index 00000000000..8ca31f345b3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/temp.C
@@ -0,0 +1,31 @@
+extern "C" int printf(const char *, ...);
+extern "C" const char *getenv(const char *);
+
+class T {
+  int i;
+public:
+  T() {
+    i = 1;
+    printf("T() at %x\n", this);
+  }
+  T(const T& o) {
+    i = o.i;
+    printf("T(const T&) at %x <-- %x\n", this, &o);
+  }
+  T operator +(const T& o) {
+    T r;
+    r.i = this->i + o.i;
+    return r;
+  }
+  operator int () {
+    return i;
+  }
+  ~T() { printf("~T() at %x\n", this); }
+} s, b;
+
+int foo() { return getenv("TEST") == 0; }
+
+main() {
+  int i = foo() ? s+b : s;
+  return i != 2;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/thunk1.C b/gcc/testsuite/g++.old-deja/g++.mike/thunk1.C
new file mode 100644
index 00000000000..9780c05bc97
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/thunk1.C
@@ -0,0 +1,19 @@
+// Build don't link:
+// Special g++ Options: -fvtable-thunks
+
+struct C1
+{
+    virtual ~C1();
+};
+
+struct C2 : public virtual C1
+{
+        virtual ~C2();
+};
+
+struct C3 : public virtual C2
+{
+    virtual ~C3();
+};
+
+C3::~C3() {}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/thunk2.C b/gcc/testsuite/g++.old-deja/g++.mike/thunk2.C
new file mode 100644
index 00000000000..9bc4558d9f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/thunk2.C
@@ -0,0 +1,39 @@
+// Special g++ Options: -fvtable-thunks
+
+#include <typeinfo>
+
+int state;
+int fail;
+
+class A {
+public:
+  A() {
+    if (++state != 1)
+      fail = 1;
+  }
+  virtual int foo() {
+    if (++state != 2)
+      fail = 1;
+  }
+  virtual ~A() {
+    if (++state != 3)
+      fail = 1;
+  }
+};
+
+A* bar() {
+  return new A;
+}
+
+main() {
+  A *aptr = bar();
+  aptr->foo();
+  if (dynamic_cast <void*> (aptr) != aptr)
+    fail = 1;
+  if (typeid (*aptr) != typeid (A))
+    fail = 1;
+  delete aptr;
+  if (++state != 4)
+    fail = 1;
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/thunk3.C b/gcc/testsuite/g++.old-deja/g++.mike/thunk3.C
new file mode 100644
index 00000000000..9a52c9d6916
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/thunk3.C
@@ -0,0 +1,35 @@
+// Special g++ Options: -fvtable-thunks
+
+int state;
+int fail;
+
+class A {
+public:
+  A() {
+    if (++state != 1)
+      fail = 1;
+  }
+  virtual int foo() {
+    if (++state != 2)
+      fail = 1;
+  }
+  virtual ~A() {
+    if (++state != 3)
+      fail = 1;
+  }
+};
+
+A* bar() {
+  return new A;
+}
+
+main() {
+  A *aptr = bar();
+  aptr->foo();
+  if (dynamic_cast <void*> (aptr) != aptr)
+    fail = 1;
+  delete aptr;
+  if (++state != 4)
+    fail = 1;
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/unroll1.C b/gcc/testsuite/g++.old-deja/g++.mike/unroll1.C
new file mode 100644
index 00000000000..90f37f1ef92
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/unroll1.C
@@ -0,0 +1,11 @@
+// Build don't link:
+// Special g++ Options: -g -O -funroll-loops
+
+struct A {
+  inline ~A() { }
+};
+
+void foo (A) {
+  while (1)
+    A bar;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/virt1.C b/gcc/testsuite/g++.old-deja/g++.mike/virt1.C
new file mode 100644
index 00000000000..28483177bf9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/virt1.C
@@ -0,0 +1,13 @@
+// Build don't link:
+
+struct S0 { virtual void f1 () { } };
+
+struct S1 : virtual public S0 { virtual void f1 () { } };
+
+struct S2 : public S1 { virtual void f1 () { } };
+
+struct S3 : virtual public S0 { virtual void f1 () { } };
+
+struct S4 : public S3 { };
+
+void creator () { new S4; }
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/virt2.C b/gcc/testsuite/g++.old-deja/g++.mike/virt2.C
new file mode 100644
index 00000000000..612d07e49e3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/virt2.C
@@ -0,0 +1,25 @@
+struct S0 {
+  virtual int is_kind_of_S1 () const { return 0; }
+  virtual void dummy () { }
+};
+
+struct S1 : virtual public S0 {
+  virtual int is_kind_of_S1 () const { return 1; }
+  virtual void dummy () { }
+};
+
+struct S2 : virtual public S0 {
+  virtual void dummy () { }
+};
+
+struct S3 : public S2, public S1 {
+  virtual void dummy () { }
+};
+
+static struct S0 *var = new S3 ();
+
+int main () {
+  if (var->is_kind_of_S1() != 1)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/virt3.C b/gcc/testsuite/g++.old-deja/g++.mike/virt3.C
new file mode 100644
index 00000000000..de3ea3d07e2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/virt3.C
@@ -0,0 +1,17 @@
+// Build don't link:
+
+class B {
+public:
+  int Bi;
+  virtual int g() { };
+};
+
+class D : private B {
+  int Di;
+};
+
+class E : public virtual D, public B {
+  int Ei;
+};		// WARNING - direct base inaccessible due to ambiguity
+
+E e;
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/virt4.C b/gcc/testsuite/g++.old-deja/g++.mike/virt4.C
new file mode 100644
index 00000000000..989701833b6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/virt4.C
@@ -0,0 +1,25 @@
+void  Foo () {}
+
+class B {
+public:
+  virtual void foo() = 0;
+};
+
+class D: virtual public B {
+public:
+  void foo() { Foo(); }
+};
+
+class D1: public D {};
+
+class D2: public D {};
+
+class D1_2: public D1, public D2 {
+public:
+  void foo() { D1::foo(); D2::foo(); }
+};
+
+main() {
+  D1_2 h;
+  h.foo();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/virt5.C b/gcc/testsuite/g++.old-deja/g++.mike/virt5.C
new file mode 100644
index 00000000000..a9040c95879
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/virt5.C
@@ -0,0 +1,53 @@
+// Ensure that virtual base upcast and downcasting works on this
+// conversions during virtual function dispatch at ctor/dtor time
+// when dynamic vtable fixups for deltas are needed.
+
+int fail = 0;
+
+struct BASE1 {
+  virtual ~BASE1 () { }      
+};   
+
+class MID;
+
+class BASE2 {
+public: 
+  virtual MID *VFN (){ return 0; }
+};   
+
+class MIBASE : public BASE1, public BASE2 { };   
+
+class VBB : public MIBASE {
+public:
+  virtual long get_STATE () const = 0;
+  void print_STATE() { if (get_STATE () != 87654321) fail = 1; }
+};   
+
+class VBD : public virtual VBB {
+  long STATE;
+public:
+  long get_STATE() const { return STATE; }
+  VBD() { STATE = 87654321; }
+  ~VBD() { STATE = 87654321; }
+};   
+
+class MID : public virtual VBD {
+public:
+  MID () { print_STATE(); }
+  ~MID () { print_STATE(); }
+  virtual MID *VFN() { return this; }
+};  
+
+class LAST : public MID {
+public:
+  LAST () { print_STATE(); }
+  ~LAST () { print_STATE(); }
+};
+
+main() {
+  MIBASE *o = new LAST;
+  MID *p = o->VFN();
+  p->print_STATE();
+  delete o;
+  return fail;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn1.C b/gcc/testsuite/g++.old-deja/g++.mike/warn1.C
new file mode 100644
index 00000000000..206042cb962
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn1.C
@@ -0,0 +1,13 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+typedef char * charptr;
+char c[]={'A','B','C','D'};
+int i=int(&c);
+int *pp=&i;
+void foo() { }
+int main()
+{
+ charptr(*pp)++;	// WARNING - 
+ return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn2.C b/gcc/testsuite/g++.old-deja/g++.mike/warn2.C
new file mode 100644
index 00000000000..a7ce899a31e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn2.C
@@ -0,0 +1,24 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+enum Boolean {
+  Ok = 0,
+  NotOk = 1,
+};
+
+enum OpResult {
+  Succeeded = 0,
+  TempFail = 1,
+  PermFail = 2,
+};
+
+OpResult fn1() {
+  return TempFail;
+}
+
+extern void foo();
+main () {
+  if (fn1() == Ok) {	// WARNING - 
+    foo();
+  }
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn3.C b/gcc/testsuite/g++.old-deja/g++.mike/warn3.C
new file mode 100644
index 00000000000..7adc8a1c37f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn3.C
@@ -0,0 +1,12 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+class B {
+public:
+  B(int) { }
+};
+
+class D : public B {
+  int member;
+  D() : member(0), B(member) { }	// WARNING - reordered
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn4.C b/gcc/testsuite/g++.old-deja/g++.mike/warn4.C
new file mode 100644
index 00000000000..9b959b0316f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn4.C
@@ -0,0 +1 @@
+void foo (int a, int a) { }	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn5.C b/gcc/testsuite/g++.old-deja/g++.mike/warn5.C
new file mode 100644
index 00000000000..742c4bc1807
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn5.C
@@ -0,0 +1,21 @@
+// Build don't link:
+// Special g++ Options: -Wpointer-arith
+
+double X(const double x) { return x; }
+double Y() { return 1.0; }
+double Z() { return 2.0; }
+
+struct A {
+  void bar() { }
+  void foo() { }
+};
+
+typedef void (A::*pmf)();
+
+static int mememe = &A::foo - &A::bar;	// WARNING - 
+pmf b = &A::foo-1;	// WARNING - 
+
+int main() {
+    double y;
+    y=X(Y-Z);   // WARNING - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn6.C b/gcc/testsuite/g++.old-deja/g++.mike/warn6.C
new file mode 100644
index 00000000000..381a3424da2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn6.C
@@ -0,0 +1,42 @@
+// Build don't link:
+// Special g++ Options: -Woverloaded-virtual
+
+struct B4 {
+  virtual void bothfardiff(float);	// WARNING - was hidden
+};
+
+struct B3 : public B4 {
+};
+
+struct B2 {
+};
+
+struct B {
+  virtual void baseonly(int);
+
+  virtual void bothsame(int);
+
+  virtual void bothdiff(float);		// WARNING - was hidden
+
+  virtual void both2same(int);
+  virtual void both2same(float);
+
+  virtual void both12diff(int);
+  virtual void both12diff(float);	// WARNING - was hidden
+};
+
+struct D : public B, public B2, public B3 {
+  virtual void derivedonly(int);
+
+  virtual void bothsame(int);
+
+  virtual void bothdiff(int);		// WARNING - 
+
+  virtual void both2same(int);
+  virtual void both2same(float);
+
+  virtual void both12diff(int);		// WARNING - 
+
+  virtual void bothfardiff(int);	// WARNING - 
+};
+
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn7.C b/gcc/testsuite/g++.old-deja/g++.mike/warn7.C
new file mode 100644
index 00000000000..6772f9585f5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn7.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// Special g++ Options: -Wall
+
+const int& foo() {
+  extern int bar;
+  
+  return bar;
+}
+
+const int* baz() {
+  extern int bar;
+  
+  return &bar;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.mike/warn8.C b/gcc/testsuite/g++.old-deja/g++.mike/warn8.C
new file mode 100644
index 00000000000..3c61c8e0afb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.mike/warn8.C
@@ -0,0 +1,19 @@
+// Build don't link:
+
+struct foo {
+  bool test();
+};
+bool func();
+
+void test() {
+  foo A;
+  bool (foo::* pmf)() = &foo::test;
+  bool (*pf)() = func;
+
+  if (A.test) ;			// WARNING - 
+  if (func) ;			// WARNING - 
+  if (bool(A.test)) ;		// WARNING - 
+  if (bool(func)) ;
+  if (pmf) ;
+  if (pf) ;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/.cvsignore b/gcc/testsuite/g++.old-deja/g++.niklas/.cvsignore
new file mode 100644
index 00000000000..7abff1dbead
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/.cvsignore
@@ -0,0 +1,2 @@
+Makefile
+config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/Makefile.in b/gcc/testsuite/g++.old-deja/g++.niklas/Makefile.in
new file mode 100644
index 00000000000..d5eb149dbee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/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 
+
+distclean:	clean
+		-rm -f Makefile config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/README b/gcc/testsuite/g++.old-deja/g++.niklas/README
new file mode 100644
index 00000000000..b729b9a0cd0
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/README
@@ -0,0 +1,18 @@
+Date: Fri, 22 Jan 93 15:20:55 +0100
+From: niklas@della.appli.se (Niklas Hallqvist)
+Message-Id: <9301221420.AA18489@della.appli.se>
+Subject: g++.niklas DejaGnu sharfile
+
+These are my test-cases in DejaGnu format.
+
+The tests which have "passed" in the groups variable do actually pass
+on my local G++ so if there is a specific "passed" test you'd like to
+see working in your version of G++ but it doesn't pass, contact me and
+I'll dig up the specific patches you'll need.
+
+I have about a hundred or so unsorted test-cases which are not
+included in this archive, due to lack of time and boredom stemming
+from writing .exp-files.  But they will show up eventually.
+
+All these files, and this file are Copyright FSF 1993, and fall under
+the GPL version 2.0 or later.
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/configure.in b/gcc/testsuite/g++.old-deja/g++.niklas/configure.in
new file mode 100644
index 00000000000..2ec1354c91f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/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=t131.exp
+srcname="DejaGnu"
+
+# per-host:
+
+# per-target:
+
+target_makefile_frag=../config/mt-${target_alias}
+
+# post-target:
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t113.C b/gcc/testsuite/g++.old-deja/g++.niklas/t113.C
new file mode 100644
index 00000000000..fdbf4550dce
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t113.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed niklas explicit-construct virtual-base
+struct A {};
+struct B : virtual A { B(); };
+struct C : B {};
+struct D { D(C&); };
+D d(C());
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t114.C b/gcc/testsuite/g++.old-deja/g++.niklas/t114.C
new file mode 100644
index 00000000000..c5b458a4e15
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t114.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed niklas explicit-construct
+struct A { A(); };
+struct B { B(A&); };
+B b(A());
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t115.C b/gcc/testsuite/g++.old-deja/g++.niklas/t115.C
new file mode 100644
index 00000000000..7ec5b4699dd
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t115.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+// GROUPS passed niklas virtual-base
+struct A { A(); virtual void f(); };
+struct B : virtual A { B(); };
+struct C : B {};
+C *c = new C;
+
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t118.C b/gcc/testsuite/g++.old-deja/g++.niklas/t118.C
new file mode 100644
index 00000000000..255747f5498
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t118.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS niklas pt
+template <class T> class C1 {};
+class C1<int> C1_int_object;
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t119.C b/gcc/testsuite/g++.old-deja/g++.niklas/t119.C
new file mode 100644
index 00000000000..522e514f811
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t119.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed niklas i386
+unsigned long foo(unsigned long x)
+{
+  return x & ~0104000;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t120.C b/gcc/testsuite/g++.old-deja/g++.niklas/t120.C
new file mode 100644
index 00000000000..c04158047be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t120.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed niklas ellipsis
+typedef void (*T) (...);
+void f ();
+struct S { void g (T); void h() { g(f); } };// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t121.C b/gcc/testsuite/g++.old-deja/g++.niklas/t121.C
new file mode 100644
index 00000000000..e99c940110d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t121.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed niklas ellipsis
+void f ();
+void g1 (void (*) (...)); void h1 () { g1 (f); }// ERROR - .*
+struct S { void g2 (void (*) (...)); void h2 () { g2 (f); } };// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t122.C b/gcc/testsuite/g++.old-deja/g++.niklas/t122.C
new file mode 100644
index 00000000000..a4ec0454712
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t122.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+// GROUPS passed niklas dwarf
+struct S { S(); };
+
+inline void
+foo (
+      S a,
+      S b
+    )
+{}
+
+void
+bar (S s1, S s2)
+{ foo (s1, s2); }
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t123.C b/gcc/testsuite/g++.old-deja/g++.niklas/t123.C
new file mode 100644
index 00000000000..37db7875eb8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t123.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas dwarf
+struct S { S(); };
+void f(S) {}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t124.C b/gcc/testsuite/g++.old-deja/g++.niklas/t124.C
new file mode 100644
index 00000000000..ba1aa55cc7d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t124.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types static-members
+struct A
+{
+  static void f ();
+  struct B
+  {
+    static void g () { f (); }
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t125.C b/gcc/testsuite/g++.old-deja/g++.niklas/t125.C
new file mode 100644
index 00000000000..e5947ef9ce1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t125.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types static-members
+struct A
+{
+  static void f ();
+  struct B
+  {
+    void h () { f (); }
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t126.C b/gcc/testsuite/g++.old-deja/g++.niklas/t126.C
new file mode 100644
index 00000000000..7313a6abab1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t126.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types static-members
+struct A
+{
+  static void f ();
+  struct B
+  {
+    void g () {}
+    void h () {}
+  };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t127.C b/gcc/testsuite/g++.old-deja/g++.niklas/t127.C
new file mode 100644
index 00000000000..a53d2d4a3b7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t127.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types
+struct A { struct B { ~B (); }; };
+A::B::~B () {}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t128.C b/gcc/testsuite/g++.old-deja/g++.niklas/t128.C
new file mode 100644
index 00000000000..7ada1dc685e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t128.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS niklas uncaught default-construct
+struct A { A (int); };
+struct B : A {}; // ERROR - 
+void f () { B (0); }// ERROR - .*
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t129.C b/gcc/testsuite/g++.old-deja/g++.niklas/t129.C
new file mode 100644
index 00000000000..11e316aef21
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t129.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types
+struct X {
+struct A { A (int); };
+struct B : A { B (int a) : A (a) {} };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t130.C b/gcc/testsuite/g++.old-deja/g++.niklas/t130.C
new file mode 100644
index 00000000000..7b2fb433b85
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t130.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types
+struct A;
+struct B { struct A { A(int); }; struct C : A { C() : A (0) {} }; };
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t131.C b/gcc/testsuite/g++.old-deja/g++.niklas/t131.C
new file mode 100644
index 00000000000..75283a828a3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t131.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas static-members
+struct A { static A a; };
+A f () { return A::a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t132.C b/gcc/testsuite/g++.old-deja/g++.niklas/t132.C
new file mode 100644
index 00000000000..18cd01c4b5e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t132.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+// GROUPS passed niklas construct-destruct
+struct S { S (); ~S (); };
+void f () { while (1) S s; }
+
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t133.C b/gcc/testsuite/g++.old-deja/g++.niklas/t133.C
new file mode 100644
index 00000000000..f79c6dbdef1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t133.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types
+struct A { struct B { void operator = (const B&); }; };
+void A::B::operator = (const B&) {}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t134.C b/gcc/testsuite/g++.old-deja/g++.niklas/t134.C
new file mode 100644
index 00000000000..faa15555e22
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t134.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS passed niklas static-members
+extern "C" int f ();
+struct A { static void f () {} };
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t135.C b/gcc/testsuite/g++.old-deja/g++.niklas/t135.C
new file mode 100644
index 00000000000..138c27802c9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t135.C
@@ -0,0 +1,28 @@
+// Build don't link: 
+// GROUPS niklas pt friend
+// excess errors test - XFAIL *-*-*
+template <class T> class C1
+{
+public:
+	void diddle_C2 ();
+};
+
+class C2
+{
+	int data_member;
+        friend class C1;
+};
+
+class C2 C2_object;
+
+template <class T> void C1<T>::diddle_C2 ()
+{
+  C2_object.data_member = 99;
+}
+
+C1<int> C1_int_object;
+
+void foobar ()
+{
+  C1_int_object.diddle_C2 ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t136.C b/gcc/testsuite/g++.old-deja/g++.niklas/t136.C
new file mode 100644
index 00000000000..4890f61e25f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t136.C
@@ -0,0 +1,4 @@
+// Build don't link: 
+// GROUPS niklas overloading
+extern "C" void f (char*);
+void f (const char*) {}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t137.C b/gcc/testsuite/g++.old-deja/g++.niklas/t137.C
new file mode 100644
index 00000000000..9a64f0fe154
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t137.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed niklas nested-types
+struct A {
+  struct B { void f (); };
+  struct C : B { void f () { B::f (); } };
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t138.C b/gcc/testsuite/g++.old-deja/g++.niklas/t138.C
new file mode 100644
index 00000000000..0f30d953420
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t138.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// GROUPS passed niklas hiding
+struct A;
+void f (A*);
+A* A;
+void g () { f (A); }
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t139.C b/gcc/testsuite/g++.old-deja/g++.niklas/t139.C
new file mode 100644
index 00000000000..702d065f2ad
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t139.C
@@ -0,0 +1,7 @@
+// GROUPS passed niklas hiding ARM
+// Build don't link:
+// Special g++ Options: -w
+struct stat {};
+stat gstat;
+int stat (struct stat*);
+void f () { struct stat* ps; stat (ps); }
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t140.C b/gcc/testsuite/g++.old-deja/g++.niklas/t140.C
new file mode 100644
index 00000000000..f840c62a82e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t140.C
@@ -0,0 +1,11 @@
+// GROUPS passed niklas hiding local-types
+extern "C" int printf (const char*, ...);
+int val = 1;
+void S () { printf ("FAIL\n"); }
+void f () { printf ("PASS\n"); val = 0; }
+int main ()
+{
+  struct S { S () { f (); } };
+  S ();
+  return val;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.niklas/t141.C b/gcc/testsuite/g++.old-deja/g++.niklas/t141.C
new file mode 100644
index 00000000000..dda60f549eb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.niklas/t141.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+// Special g++ Options: -Wshadow
+// GROUPS passed niklas scoping ARM
+class X { X (int); }; // WARNING - private
+void X (int);// ERROR - .*hides constructor.*
+void f () { X (1); }
diff --git a/gcc/testsuite/g++.old-deja/g++.other/.cvsignore b/gcc/testsuite/g++.old-deja/g++.other/.cvsignore
new file mode 100644
index 00000000000..7abff1dbead
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/.cvsignore
@@ -0,0 +1,2 @@
+Makefile
+config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.other/900403_04.C b/gcc/testsuite/g++.old-deja/g++.other/900403_04.C
new file mode 100644
index 00000000000..9d55a37976b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/900403_04.C
@@ -0,0 +1,12 @@
+// GROUPS passed abort
+// Build don't link:
+// g++ 1.37.1 bug 900403_04
+
+// The following erroneous code causes g++ to abort.
+
+// keywords: abort, bit-fields, zero length
+
+struct s {
+  unsigned int foo:0;	// ERROR - causes abort
+  unsigned int field;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.other/900519_12.C b/gcc/testsuite/g++.old-deja/g++.other/900519_12.C
new file mode 100644
index 00000000000..1170b068b2f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/900519_12.C
@@ -0,0 +1,11 @@
+// GROUPS abort
+// Build don't link:
+// g++ 1.37.1 bug 900519_12
+
+// The following erroneous code causes g++ to segfault.
+
+// cfront 2.0 passes this test.
+
+// keywords: segfault, typedef, pointer type, function type
+
+typedef eek void (*)();		// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.other/Makefile.in b/gcc/testsuite/g++.old-deja/g++.other/Makefile.in
new file mode 100644
index 00000000000..d5eb149dbee
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/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 
+
+distclean:	clean
+		-rm -f Makefile config.status
diff --git a/gcc/testsuite/g++.old-deja/g++.other/configure.in b/gcc/testsuite/g++.old-deja/g++.other/configure.in
new file mode 100644
index 00000000000..e198b4f0d45
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/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=g++-03.exp
+srcname="DejaGnu"
+
+# per-host:
+
+# per-target:
+
+target_makefile_frag=../config/mt-${target_alias}
+
+# post-target:
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-1.C b/gcc/testsuite/g++.old-deja/g++.other/dll-1.C
new file mode 100644
index 00000000000..0c66b7faf4b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-1.C
@@ -0,0 +1,10 @@
+// Build don't link:
+// Special g++ Options: -mno-nop-fun-dllimport
+// Skip if not target: arm-*pe
+// declspec test #1
+// set compiler_result "__imp_imp.*\.section${spaces}.drectve\n\[^\n\]*-export:exp"
+// set not_compiler_result "__imp_exp"
+
+__declspec (dllimport) void imp ();
+
+__declspec (dllexport) void exp () { imp (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-2.C b/gcc/testsuite/g++.old-deja/g++.other/dll-2.C
new file mode 100644
index 00000000000..f5c7b2eb8e8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-2.C
@@ -0,0 +1,19 @@
+// Skip if not target: arm-*pe
+// Build don't link:
+// Microsoft's MSVC 2.0 allows dllimport followed by dllexport for variables,
+// but does not allow dllexport followed by dllimport.
+//
+// Switching between dll{export,import} works for functions.
+// We test for that too (by ensuring no error is produced).
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();
+
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();
+
+__declspec (dllimport) int bar1;
+__declspec (dllexport) int bar1;
+
+__declspec (dllexport) int bar2; // ERROR - previously declared
+__declspec (dllimport) int bar2; // ERROR - redefinition
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-3.C b/gcc/testsuite/g++.old-deja/g++.other/dll-3.C
new file mode 100644
index 00000000000..469ea1c6b78
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-3.C
@@ -0,0 +1,17 @@
+// Build don't link:
+// Skip if not target: arm-*pe
+// Special g++ Options: -mno-nop-fun-dllimport
+// set compiler_result "__imp_f1.*\.section${spaces}.drectve\n\[^\n\]*-export:f2"
+// set not_compiler_result "__imp_f2"
+
+class aClass 
+{ 
+public: 
+  __declspec(dllimport) int f1(); 
+  __declspec(dllexport) int f2(); 
+}; 
+ 
+__declspec(dllexport) int aClass::f2() 
+{ 
+  return f1(); 
+} 
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-4.C b/gcc/testsuite/g++.old-deja/g++.other/dll-4.C
new file mode 100644
index 00000000000..322f003dbde
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-4.C
@@ -0,0 +1,14 @@
+// Build don't link:
+// Skip if not target: arm-*pe
+// Ensure dllexport overrides dllimport.
+// set compiler_result "\.section${spaces}\.drectve\n\[^\n\]*-export:foo1.*\.section${spaces}\.drectve\n\[^\n\]*-export:foo2"
+// set not_compiler_result "(__imp_foo1|__imp_foo2)"
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();
+
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();
+
+__declspec (dllexport) int foo1 () { return foo2 (); }
+__declspec (dllexport) int foo2 () { return foo1 (); }
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-5.C b/gcc/testsuite/g++.old-deja/g++.other/dll-5.C
new file mode 100644
index 00000000000..b2ad9f51bac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-5.C
@@ -0,0 +1,13 @@
+// Build don't link:
+// Skip if not target: arm-*pe
+// dllimport is "sorta like" to "extern".
+// set compiler_result "(\nfoo1:.*\nfoo2:|\nfoo2:.*\nfoo1:)"
+// set not_compiler_result "__imp_"
+
+__declspec (dllimport) int foo1;
+int foo1;
+
+__declspec (dllimport) int foo2;
+int foo2 = 5;
+
+int f () { return foo1 + foo2; }
diff --git a/gcc/testsuite/g++.old-deja/g++.other/dll-6.C b/gcc/testsuite/g++.old-deja/g++.other/dll-6.C
new file mode 100644
index 00000000000..b4e0b42edbf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/dll-6.C
@@ -0,0 +1,15 @@
+// Build don't link:
+// Skip if not target: arm-*pe
+// set not_compiler_result "__imp_"
+// dll.h
+class aClass 
+    { 
+public: 
+    __declspec(dllimport) aClass(); 
+    }; 
+
+// dll.cpp
+
+__declspec(dllexport) aClass::aClass() 
+    { 
+    } 
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rtti1.C b/gcc/testsuite/g++.old-deja/g++.other/rtti1.C
new file mode 100644
index 00000000000..7377e156dba
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rtti1.C
@@ -0,0 +1,121 @@
+// test of rtti of non-class types
+// Special g++ Options: -frtti
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+int i;
+short s;
+char c;
+long l;
+
+unsigned int ui;
+unsigned short us;
+unsigned char uc;
+unsigned long ul;
+
+float f;
+double d;
+
+int& ri = i;
+const volatile int cvi = 10;
+volatile const int vci = 20;
+const int ci = 100;
+
+int *pi;
+int ai[10];
+
+enum color { red, blue, green, yellow};
+
+int (*fp)();
+int (*gp)();
+int (*hp)(int);
+
+class XX {
+public:
+  int xxi;
+  float xxf;
+  int xxf1 () {};
+  int xxf2 (int k) {};
+};
+
+class YY {
+public:
+  int yyi;
+  double yyd;
+  int yyf1 (float f) {};
+  double yyf2 () {return yyd;};
+};
+
+int XX::*ptmd1;
+int XX::*ptmd2;
+float XX::*ptmd3;
+int YY::*ptmd4;
+
+int (XX::*ptmf1) ();
+int (XX::*ptmf2) ();
+int (XX::*ptmf3) (int);
+int (YY::*ptmf4) ();
+
+int func1 ()
+{ return 0;}
+
+int func2 ()
+{ return 1;}
+
+int func3 (int i)
+{ return i;}
+
+short func4 ()
+{ return 99;}
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  if (typeid(i) != typeid(int)) error(1);
+  if (typeid(s) != typeid(short)) error(2);
+  if (typeid(c) != typeid(char)) error(3);
+  if (typeid(l) != typeid(long)) error(4);
+  if (typeid(ui) != typeid(unsigned int)) error(5);
+  if (typeid(us) != typeid(unsigned short)) error(6);
+  if (typeid(uc) != typeid(unsigned char)) error(7);
+  if (typeid(ul) != typeid(unsigned long)) error(8);
+  if (typeid(f) != typeid(float)) error(9);
+  if (typeid(d) != typeid(double)) error(10);
+
+  if (typeid(*pi) != typeid(int)) error(51);
+  if (typeid(pi) == typeid(ai)) error(52);
+  if (typeid(ri) != typeid(i)) error(53);
+  if (typeid(cvi) != typeid(vci)) error (54);
+  if (typeid(vci) != typeid(i)) error(55);
+  if (typeid(ci) != typeid(cvi)) error (56);
+  if (typeid(ci) != typeid(const int)) error(57);
+
+  if (typeid(func1) != typeid(func2)) error (81);
+  if (typeid(func2) == typeid(func3)) error (82);
+  if (typeid(func1) == typeid(func4)) error (83);
+  if (typeid(func3) == typeid(func4)) error (84);
+
+  if (typeid(red) != typeid(color)) error (101);
+  if (typeid(green) != typeid(blue)) error (102);
+
+  if (typeid(fp) != typeid(gp)) error (103);
+  if (typeid(gp) == typeid(hp)) error (104);
+
+  if (typeid(ptmd1) != typeid(ptmd2)) error (105);
+  if (typeid(ptmd1) == typeid(ptmd3)) error (106);
+  if (typeid(ptmd2) == typeid(ptmd4)) error (107);
+
+  if (typeid(ptmf1) != typeid(ptmf2)) error (108);
+  if (typeid(ptmf2) == typeid(ptmf3)) error (109);
+  if (typeid(ptmf1) == typeid(ptmf4)) error (110);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rtti2.C b/gcc/testsuite/g++.old-deja/g++.other/rtti2.C
new file mode 100644
index 00000000000..a7a218b06e6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rtti2.C
@@ -0,0 +1,88 @@
+// test of rtti of single inheritance and multiple inheritance classes
+// Special g++ Options: -frtti
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+};
+
+class Y : public X {
+  short ys;
+};
+
+class Z : public Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+ public:
+  int Ai;
+};
+
+class B {
+ public:
+  int Bi;
+};
+
+class D : public A, public B {
+  int Di;
+};
+
+/*
+class E : public D, public B {
+  int Ei;
+};
+*/
+class E {
+  int Ei;
+};
+
+class F : public E, public D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = &d;
+F f;
+A *aap = &f;
+D *dp = &f;
+B *bbp = dp;
+
+void *vp = zp;
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  if (typeid(z) != typeid(Z)) error(1);
+  if (typeid(*yp) == typeid(Z)) error(2);
+  if (typeid(*yp) == typeid(*zp)) error(3);
+  if (typeid(xp) == typeid(yp)) error(4);
+
+  xp = (X *)&y;
+  if (typeid(*xp) == typeid(*yp)) error(5);
+  if (typeid(*xp) == typeid(Y)) error(6);
+  
+  if (typeid(*ap) == typeid(*bp)) error (31);
+  if (typeid(*ap) == typeid(D)) error(32);
+
+  if (typeid(*aap) == typeid(*bbp)) error(33);
+  if (typeid(*dp) == typeid(*aap)) error(34);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rtti3.C b/gcc/testsuite/g++.old-deja/g++.other/rtti3.C
new file mode 100644
index 00000000000..fdb1f9e090d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rtti3.C
@@ -0,0 +1,96 @@
+// test of rtti of single inheritance and multiple inheritance with 
+// virtual functions
+// Special g++ Options: -frtti
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+  virtual int f() {};
+};
+
+class Y : public X {
+  short ys;
+};
+
+class Z : public Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+ public:
+  int Ai;
+  virtual int a() {};
+};
+
+class B {
+ public:
+  int Bi;
+  virtual int g() {};
+};
+
+class D : public A, public B {
+  int Di;
+};
+
+/*
+class E : public D, public B {
+  int Ei;
+};
+*/
+class E {
+  int Ei;
+};
+
+class F : public E, public D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = &d;
+D *dp = &d;
+F f;
+A *aap = &f;
+B *bbp = &f;
+
+void *vp = zp;
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  if (typeid(z) != typeid(Z)) error(1);
+  if (typeid(*yp) != typeid(Z)) error(2);
+  if (typeid(*yp) != typeid(*zp)) error(3);
+  if (typeid(xp) == typeid(yp)) error(4);
+
+  xp = (X *)&y;
+  if (typeid(*xp) == typeid(*yp)) error(5);
+  if (typeid(*xp) != typeid(Y)) error(6);
+  
+  if (typeid(*ap) != typeid(*bp)) error (31);
+  if (typeid(*ap) != typeid(D)) error(32);
+  vp = dp;
+  vp = dynamic_cast<void*> ((B *)vp);
+  if (dp != (D *)vp) error(35);
+
+  dp = (D *)&f;
+  if (typeid(*aap) != typeid(*bbp)) error(37);
+  if (typeid(*dp) != typeid(*aap)) error(38);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rtti4.C b/gcc/testsuite/g++.old-deja/g++.other/rtti4.C
new file mode 100644
index 00000000000..571ed68fd9f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rtti4.C
@@ -0,0 +1,86 @@
+// test of rtti of single inheritance and multiple inheritance with 
+// virtual inheritance
+// Special g++ Options: -frtti -w
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+  virtual int f() {};
+};
+
+class Y : public virtual X {
+  short ys;
+};
+
+class Z : public virtual Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+public:
+  int Ai;
+  virtual int a() {};
+};
+
+class B {
+public:
+  int Bi;
+  virtual int g() {};
+};
+
+class D : public virtual A, private B {
+  int Di;
+};
+
+class E : public virtual D, public B {
+  int Ei;
+};
+
+class F : public E, public virtual D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = (B *)&d;
+F f;
+A *aap = &f;
+D *dp = &f;
+B *bbp = (B *)dp;
+
+void *vp = zp;
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  if (typeid(z) != typeid(Z)) error(1);
+  if (typeid(*yp) != typeid(Z)) error(2);
+  if (typeid(*yp) != typeid(*zp)) error(3);
+  if (typeid(xp) == typeid(yp)) error(4);
+
+  xp = (X *)&y;
+  if (typeid(*xp) == typeid(*yp)) error(5);
+  if (typeid(*xp) != typeid(Y)) error(6);
+  
+  if (typeid(*ap) != typeid(*bp)) error (31);
+  if (typeid(*ap) != typeid(D)) error(32);
+  if (typeid(*aap) != typeid(*bbp)) error(33);
+  if (typeid(*dp) != typeid(*aap)) error(34);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rttid2.C b/gcc/testsuite/g++.old-deja/g++.other/rttid2.C
new file mode 100644
index 00000000000..50c1867c267
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rttid2.C
@@ -0,0 +1,100 @@
+// test of rtti of single inheritance and multiple inheritance classes
+// dynamic casting
+// Special g++ Options: -frtti
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+};
+
+class Y : public X {
+  short ys;
+};
+
+class Z : public Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+ public:
+  int Ai;
+};
+
+class B {
+ public:
+  int Bi;
+};
+
+class D : public A, public B {
+  int Di;
+};
+
+/*
+class E : public D, public B {
+  int Ei;
+};
+*/
+class E {
+  int Ei;
+};
+
+class F : public E, public D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = &d;
+F f;
+F *fp = &f;
+A *aap = &f;
+D *dp = &f;
+B *bbp = dp;
+
+void *vp = zp;
+
+/*
+void error (int i)
+{
+  printf("FAIL\n");
+  exit(i);
+}
+*/
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+
+  vp = (void *)0;
+
+  vp = dynamic_cast<Y *> (&z);
+  if (vp == 0) error(11);
+
+  vp = dynamic_cast<X *> (yp);
+  if (vp == 0) error(12);
+
+  vp = dynamic_cast<D *> (dp);
+  if (vp != (void *)dp) error(21);
+
+  vp = dynamic_cast<B *> (fp);
+  if (vp != (void *)bbp) error(22);
+
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rttid3.C b/gcc/testsuite/g++.old-deja/g++.other/rttid3.C
new file mode 100644
index 00000000000..69b7fc5c38a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rttid3.C
@@ -0,0 +1,115 @@
+// test of rtti of single inheritance and multiple inheritance with 
+// virtual functions
+// dynamic casting
+// Special g++ Options: -frtti
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+  virtual int f() {};
+};
+
+class Y : public X {
+  short ys;
+};
+
+class Z : public Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+ public:
+  int Ai;
+  virtual int a() {};
+};
+
+class B {
+ public:
+  int Bi;
+  virtual int g() {};
+};
+
+class D : public A, public B {
+  int Di;
+};
+
+/*
+class E : public D, public B {
+  int Ei;
+};
+*/
+class E {
+  int Ei;
+};
+
+class F : public E, public D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = &d;
+D *dp = &d;
+F f;
+F *fp = &f;
+A *aap = &f;
+B *bbp = &f;
+
+void *vp = zp;
+
+/*
+void error (int i)
+{
+  printf("FAIL\n");
+  exit(i);
+}
+*/
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  vp = (void *)0;
+
+  vp = dynamic_cast<Y *> (&z);
+  if (vp == 0) error(11);
+
+  vp = dynamic_cast<Z *> (yp);
+  if (vp == 0) error(11);
+
+  vp = dynamic_cast<X *> (yp);
+  if (vp == 0) error(12);
+
+  vp = dynamic_cast<D *> (dp);
+  if (vp != (void *)dp) error(21);
+
+  vp = dynamic_cast<B *> (dp);
+  if (vp == (void *)dp) error(21);
+
+  vp = dynamic_cast<B *> (fp);
+  if (vp != (void *)bbp) error(22);
+
+  vp = dynamic_cast<void *> (aap);
+  if (vp != (void *)fp) error(23);
+
+  vp = dynamic_cast<B *> (aap);
+  if (vp != (void *)bbp) error(24);
+
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.other/rttid4.C b/gcc/testsuite/g++.old-deja/g++.other/rttid4.C
new file mode 100644
index 00000000000..72100b7409d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/rttid4.C
@@ -0,0 +1,111 @@
+// test of rtti of single inheritance and multiple inheritance with 
+// virtual inheritance
+// dynamic casting
+// Special g++ Options: -frtti -w
+
+#include <typeinfo>
+
+extern "C" {
+  int printf(const char *, ...);
+  void exit(int);
+}
+
+class X {
+ public:
+  int xi;
+  virtual int f() {};
+};
+
+class Y : public virtual X {
+  short ys;
+};
+
+class Z : public virtual Y {
+  int zi;
+};
+
+Z z;
+Y y;
+Y *yp = &z;
+X *xp = &z;
+Z *zp = &z;
+
+class A {
+public:
+  int Ai;
+  virtual int a() {};
+};
+
+class B {
+public:
+  int Bi;
+  virtual int g() {};
+};
+
+class D : public virtual A, private B {
+  int Di;
+};
+
+class E : public virtual D, public B {
+  int Ei;
+};
+
+class F : public E, public virtual D {
+  int Fi;
+};
+
+D d;
+A *ap = &d;
+B *bp = (B *)&d;
+F f;
+F *fp = &f;
+A *aap = &f;
+D *dp = &f;
+E *ep = &f;
+B *bbp = (B *)dp;
+
+void *vp = zp;
+
+/*
+void error (int i)
+{
+  printf("FAIL\n");
+  exit(i);
+}
+*/
+
+void error  (int i)
+{
+  exit(i);
+}
+
+int main ()
+{
+  vp = (void *)0;
+
+  vp = dynamic_cast<Y *> (&z);
+  if (vp == 0) error(11);
+
+  vp = dynamic_cast<Z *> (yp);
+  if (vp == 0) error(11);
+
+  vp = dynamic_cast<X *> (yp);
+  if (vp == 0) error(12);
+
+  vp = dynamic_cast<D *> (dp);
+  if (vp != (void *)dp) error(21);
+
+  vp = dynamic_cast<B *> (dp);
+  if (vp == (void *)dp) error(21);
+
+  vp = dynamic_cast<B *> (fp);
+  if (vp == (void *)bbp) error(22);
+
+  vp = dynamic_cast<void *> (aap);
+  if (vp != (void *)fp) error(23);
+
+  vp = dynamic_cast<B *> (aap);
+  if (vp == (void *)bbp) error(24);
+
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/eichin01.C b/gcc/testsuite/g++.old-deja/g++.pt/eichin01.C
new file mode 100644
index 00000000000..154587b0ac9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/eichin01.C
@@ -0,0 +1,27 @@
+// Build don't run:
+
+/*
+
+
+*/
+
+
+template <class X> class TC {
+public:
+  X aaa;
+  static X sss;
+  TC(X a) { aaa = a; }
+  TC(X a, X s) { aaa = a; sss = s; }
+  void sz(X s) { sss = s; }
+};
+
+float TC<float>::sss;
+long TC<long>::sss;
+
+TC<long> xjj(1,2);
+
+int main(int,char*) {
+  TC<float> xff(9.9,3.14);
+  xjj.sz(123);
+  xff.sz(2.71828);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/eichin01a.C b/gcc/testsuite/g++.old-deja/g++.pt/eichin01a.C
new file mode 100644
index 00000000000..1a37eebfc23
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/eichin01a.C
@@ -0,0 +1,21 @@
+template <class X> class TC {
+public:
+  X aaa;
+  static X sss;
+  TC(X a) {aaa = a; }
+  TC(X a, X s) {aaa = a; sss = s; }
+  void sz(X s) { sss = s; }
+};
+
+
+long TC<long>::sss;
+float TC<float>::sss;
+
+TC<long> xjj(1,2);
+
+int main(int,char*) {
+  TC<float> xff(9.9,3.14);
+  xjj.sz(123);
+  xff.sz(2.71828);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/eichin01b.C b/gcc/testsuite/g++.old-deja/g++.pt/eichin01b.C
new file mode 100644
index 00000000000..51bb4474c8f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/eichin01b.C
@@ -0,0 +1,21 @@
+template <class X> class TC {
+public:
+  X aaa;
+  static X sss;
+  TC(X a) {aaa = a; }
+  TC(X a, X s) {aaa = a; sss = s; }
+  void sz(X s) { sss = s; }
+  void syy(X syarg) { sss = syarg; }
+};
+
+long TC<long>::sss;
+float TC<float>::sss;
+
+TC<long> xjj(1,2);
+
+int main(int,char*) {
+  TC<float> xff(9.9,3.14);
+  xjj.sz(123);
+  xff.sz(2.71828);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m1.C b/gcc/testsuite/g++.old-deja/g++.pt/m1.C
new file mode 100644
index 00000000000..2d1321380be
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m1.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+
+int f1 () {
+  struct A {
+    A() : b (2) { }
+    fred () { return b.hi_mom; }
+    struct B {
+      int hi_mom;
+      B (int a) { hi_mom = a; }
+    };
+    B b;
+  };
+  A aa;
+  return aa.fred();
+}
+/* crashes with signal 11 */
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m2.C b/gcc/testsuite/g++.old-deja/g++.pt/m2.C
new file mode 100644
index 00000000000..00fdbadea0b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m2.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+
+struct A { A() { a = 2; } int a; };
+
+int f1 () {
+  struct A { A() { a = 2; } int a; };
+  A aa;
+  return aa.a;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m3.C b/gcc/testsuite/g++.old-deja/g++.pt/m3.C
new file mode 100644
index 00000000000..492b2611a31
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m3.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+
+struct A { A() { a = 2; } int a; };
+
+struct B {
+  struct A { A() { a = 2; } int a; };
+  A aa;
+};
+char xx[]="../tests/m3.cc:4: redefinition of `struct A'";
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m4.C b/gcc/testsuite/g++.old-deja/g++.pt/m4.C
new file mode 100644
index 00000000000..bbfb2272e61
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m4.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+
+struct A1 { struct B { B(); } b; };
+struct A2 { struct B { ~B(); } b; };
+char xx[] ="../tests/m4.cc:1: warning: return type specification for constructor invalid";
+
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m5.C b/gcc/testsuite/g++.old-deja/g++.pt/m5.C
new file mode 100644
index 00000000000..e8349704cae
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m5.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+struct B { struct A { A(); int a; } aa; };
+struct A { A(); int a; };
+B::A::A () { a = 37; }
+char xx[]="../tests/m5.cc:3: Segmentation violation";
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m6.C b/gcc/testsuite/g++.old-deja/g++.pt/m6.C
new file mode 100644
index 00000000000..5d0c81e0d1e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m6.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+
+struct B { struct A { A(); int a; } aa; };
+B::A::A () { a = 37; }
+char* xx[] = {
+"../tests/m6.cc:1: warning: return type specification for constructor invalid",
+"../tests/m6.cc:2: semicolon missing after declaration of `A'",
+"../tests/m6.cc:2: warning: empty declaration",
+"../tests/m6.cc: In function int A ():",
+"../tests/m6.cc:2: `a' undeclared (first use this function)",
+"../tests/m6.cc:2: (Each undeclared identifier is reported only once",
+"../tests/m6.cc:2: for each function it appears in.)",
+"../tests/m6.cc:2: warning: control reaches end of non-void function" };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m7.C b/gcc/testsuite/g++.old-deja/g++.pt/m7.C
new file mode 100644
index 00000000000..06d2ba337a2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m7.C
@@ -0,0 +1,13 @@
+// Build don't link: 
+
+struct B { struct A { A(); int a; }; A aa; };
+B::A::A () { a = 37; }
+char *xx[]= {"/*",
+"../tests/m7.cc:1: warning: return type specification for constructor invalid",
+"../tests/m7.cc: In function struct A A ():",
+"../tests/m7.cc:2: `a' undeclared (first use this function)",
+"../tests/m7.cc:2: (Each undeclared identifier is reported only once",
+"../tests/m7.cc:2: for each function it appears in.)",
+"../tests/m7.cc:2: warning: control reaches end of non-void function",
+	       "*/" };
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m8.C b/gcc/testsuite/g++.old-deja/g++.pt/m8.C
new file mode 100644
index 00000000000..22d01441bb1
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m8.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+
+class A {
+  int a;
+ public:
+  A (int aa = 3);
+};
+
+class B {
+  class A {
+  public:
+    A (int, int);
+  };
+  A aa;
+ public:
+  B (int);
+};
+
+extern void foo();
+B::B (int z) : aa (1, z) {
+  foo ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m9.C b/gcc/testsuite/g++.old-deja/g++.pt/m9.C
new file mode 100644
index 00000000000..d519dbdc728
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m9.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+
+struct A { A() { a = 1; } int a; };
+struct Q {
+  struct A { A() { a = 2; } int a; };
+  struct R {
+     struct A { A() { a = 3; } int a; };
+     A aaz;
+  };
+  R rrr;
+  A aay;
+}
+;
+
+Q qqq;
+A aav;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/m9a.C b/gcc/testsuite/g++.old-deja/g++.pt/m9a.C
new file mode 100644
index 00000000000..9118306d697
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/m9a.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+
+struct A { A() { a = 1; } int a; }; // ERROR - 
+struct A { A() { a = 2; } int a; }; // ERROR - 
+A aavv;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/niklas01.C b/gcc/testsuite/g++.old-deja/g++.pt/niklas01.C
new file mode 100644
index 00000000000..6dcf9d3efaf
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/niklas01.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+template <class T> struct A {};
+template <class T> struct B : A<B<T> > {};
+
+B<int> x;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/niklas01a.C b/gcc/testsuite/g++.old-deja/g++.pt/niklas01a.C
new file mode 100644
index 00000000000..027f2ae9595
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/niklas01a.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+struct A {
+  friend struct B : A {		// ERROR - 
+    int x;
+  };
+  int y;
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/niklas01b.C b/gcc/testsuite/g++.old-deja/g++.pt/niklas01b.C
new file mode 100644
index 00000000000..fa2e5ac884a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/niklas01b.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+template <class T> struct A { T *t; inline A() { t = 0; } };
+template <class T> struct B : A<B<T> > { int x; inline B() { x = 3; } };
+
+B<int> x;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/niklas02.C b/gcc/testsuite/g++.old-deja/g++.pt/niklas02.C
new file mode 100644
index 00000000000..b4d300deaed
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/niklas02.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+
+struct B { int foo (); };
+int B::foo() { return 37; }
+
+template <class A> struct X {
+  void f(int);
+};
+
+template <class A> void X<A>::f (int jj)
+{}
+
+X<int> x;
+
+void xxx () { x.f (1); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/niklas03.C b/gcc/testsuite/g++.old-deja/g++.pt/niklas03.C
new file mode 100644
index 00000000000..29b19726a2d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/niklas03.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+
+template <class A> struct X {
+  A operator[] (int);
+};
+
+template <class A> A X<A>::operator[] (int i)
+{
+  return A();	// gets bogus error
+}
+
+X<int> x;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t00.C b/gcc/testsuite/g++.old-deja/g++.pt/t00.C
new file mode 100644
index 00000000000..14bfcf82ca6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t00.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+
+int f1 () {
+    struct A { A() { a = 2; } int a; } ;
+  A aa;
+  return aa.a;
+}
+int f2 () {
+    struct A { A() { a = 2; } int a; } ;
+  A ab;
+  return ab.a;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t01.C b/gcc/testsuite/g++.old-deja/g++.pt/t01.C
new file mode 100644
index 00000000000..b1d7d386cd9
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t01.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+template <class A> class B { public: A a; };
+static B<int> b_int;
+
+int foo () { return b_int.a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t03.C b/gcc/testsuite/g++.old-deja/g++.pt/t03.C
new file mode 100644
index 00000000000..29f687ae1bc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t03.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+
+template <class A> class B { public: A a; };
+static B<int> b_int;
+static B<char> b_char;
+
+int foo () { return b_int.a + b_char.a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t04.C b/gcc/testsuite/g++.old-deja/g++.pt/t04.C
new file mode 100644
index 00000000000..faa04fc5771
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t04.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class A> class B { public: A a; };
+static B<int> b_int;
+static B<char> b_char;
+static B<unsigned char> b_uchar;
+
+int foo () { return b_int.a + b_char.a + b_uchar.a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t05.C b/gcc/testsuite/g++.old-deja/g++.pt/t05.C
new file mode 100644
index 00000000000..888f1de95ea
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t05.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+
+template <class A> class B {
+  A a;
+ public:
+  B(A&aa);			// ERROR - 
+  ~B();
+};
+static B<int> b_int (3);	// ERROR - 
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t06.C b/gcc/testsuite/g++.old-deja/g++.pt/t06.C
new file mode 100644
index 00000000000..8681f5332fa
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t06.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+
+typedef int I;
+int i;
+
+template <class A> class B {
+  A a;
+ public:
+  B(A&aa);
+  B();
+  ~B();
+};
+
+template <class B> class C { public: B b; };
+
+template <class I, class i> class D : I { public: i ii; };
+
+typedef B<int> b_int;
+typedef C<int> c_int;      
+typedef C<b_int> c_b_int2; 
+
+c_b_int2 x2;
+int z;
+D<c_b_int2,b_int> d;
+int q;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t07.C b/gcc/testsuite/g++.old-deja/g++.pt/t07.C
new file mode 100644
index 00000000000..3cdb3dafdb2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t07.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+
+template <class A> class B {
+  A a;
+ public:
+  const A& value () { return a; }
+};
+static B<int> b_int;
+
+int foo () { return b_int.value(); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t08.C b/gcc/testsuite/g++.old-deja/g++.pt/t08.C
new file mode 100644
index 00000000000..ce24cca7e36
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t08.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+
+template <class A> class B {
+  A a;
+ public:
+  B ();
+  ~B ();
+};
+B<int> b_int;
+B<int> *bp = &b_int;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t09.C b/gcc/testsuite/g++.old-deja/g++.pt/t09.C
new file mode 100644
index 00000000000..dab4730e091
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t09.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+struct bs_1 {
+  typedef int (*pfi) (void);
+};
+static bs_1::pfi fp;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t10.C b/gcc/testsuite/g++.old-deja/g++.pt/t10.C
new file mode 100644
index 00000000000..4f3fc182e04
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t10.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+template <class A> class B { public: A a; B(); };
+class B<char> { public: int y[10]; };
+static B<int> bi;
+static B<char> bc;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t11.C b/gcc/testsuite/g++.old-deja/g++.pt/t11.C
new file mode 100644
index 00000000000..81373498df8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t11.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+
+template <class A>
+class B {
+public:
+  A a;
+  B() { x = 2; }	// ERROR - no x
+};
+static B<int> bi;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t11a.C b/gcc/testsuite/g++.old-deja/g++.pt/t11a.C
new file mode 100644
index 00000000000..0dcd297fa15
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t11a.C
@@ -0,0 +1,9 @@
+// Build don't link: 
+
+template <class A>
+class B {
+public:
+  A a;
+  B() { a = 2; }
+};
+static B<int> bi;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t12.C b/gcc/testsuite/g++.old-deja/g++.pt/t12.C
new file mode 100644
index 00000000000..0ebb0451f79
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t12.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+
+class OBJECT {int a;};
+class STDFILE {int b;};
+
+template <class T> class VECTOR {
+    T *v;
+    int sz;
+public:
+    T& elem(int i) { return v[i]; }
+    T& operator[] (int i);
+};
+
+template <class T>
+class PVECTOR : VECTOR<void *> {
+public:
+    T*& elem(int i)
+        {return (T*&) VECTOR<void *>::elem(i); }
+    T*& operator[] (int i)
+        {return (T*&) VECTOR<void *>::operator[](i);}
+};
+
+PVECTOR<OBJECT *> *foo;
+
+PVECTOR<STDFILE *> *goo;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t12a.C b/gcc/testsuite/g++.old-deja/g++.pt/t12a.C
new file mode 100644
index 00000000000..e0f1e65d50b
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t12a.C
@@ -0,0 +1,5 @@
+// Build don't link: 
+
+int a (void * x) { return 1; }
+typedef void *T;
+int b (T x) { return 2; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t13.C b/gcc/testsuite/g++.old-deja/g++.pt/t13.C
new file mode 100644
index 00000000000..2f589a7d227
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t13.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+
+template <class A> class B {
+public:
+  B();
+  A a;
+  int i;
+};
+
+void *f () {
+  return new B<char *>;
+}
+
+struct foo { int i[10]; };
+extern B<foo> *foop;
+
+void f2 () {
+  foop = new B<foo>;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t14.C b/gcc/testsuite/g++.old-deja/g++.pt/t14.C
new file mode 100644
index 00000000000..8532f2b3501
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t14.C
@@ -0,0 +1,24 @@
+// Build don't link: 
+
+class OBJECT
+{
+    int	a;
+};
+
+ 
+
+template <class T> class TESTA
+{
+public:
+    TESTA();
+      T	foo(int i) {T t = 0; return t};	// ERROR - no semi
+};
+
+
+
+void foo()
+{
+    TESTA<OBJECT *>   *foo;
+
+    foo = new TESTA<OBJECT *>;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t14a.C b/gcc/testsuite/g++.old-deja/g++.pt/t14a.C
new file mode 100644
index 00000000000..694f846fbe5
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t14a.C
@@ -0,0 +1,25 @@
+// Build don't link: 
+
+class OBJECT
+{
+    int	a;
+};
+
+ 
+
+template <class T> class TESTA
+{
+public:
+    TESTA();
+      T	foo(int i) {T t = 0; return t;}
+};
+
+
+
+void foo()
+{
+    TESTA<OBJECT *>   *foo;
+
+    foo = new TESTA<OBJECT *>;
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t16.C b/gcc/testsuite/g++.old-deja/g++.pt/t16.C
new file mode 100644
index 00000000000..a5b19e43fa6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t16.C
@@ -0,0 +1,30 @@
+extern "C" void printf (char *, ...);
+template <class T> T max (const T&x, const T&y)
+{
+  return (x>y)?x:y;
+}
+int min (const float&, const float&);
+int min (const int& i1, const int& i2) {
+  return (i1 < i2) ? i1 : i2;
+}
+
+class complex
+{
+  double re, im;
+ public:
+  complex (double r, double i=0) { re = r; im = i; }
+  friend int operator > (const complex& x, const complex &y) { return 0; }
+  void print () { }
+};
+
+main ()
+{
+  complex c1 (1, 0);
+  complex c2 (2, 0);
+
+  int j = max (1, 37);
+  complex m1 = max (c1, c2);
+  m1.print ();
+  printf ("j=%d\n", j);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t18.C b/gcc/testsuite/g++.old-deja/g++.pt/t18.C
new file mode 100644
index 00000000000..760747eeceb
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t18.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+
+extern void byebye ();
+template <class T1, class T2>
+struct A
+{
+  T1 t1;
+  T2 t2;
+  A() { t1 = 0; t2 = 0; }
+  ~A() { byebye(); }
+};
+
+template <class Q>
+int f (A<int, Q> a) {
+  return a.t1;
+}
+
+extern A<int,double*> aa;
+int foop () { return f(aa); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t20.C b/gcc/testsuite/g++.old-deja/g++.pt/t20.C
new file mode 100644
index 00000000000..07a86fa2d6e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t20.C
@@ -0,0 +1,15 @@
+// Build don't link: 
+
+template <class X> class A {
+public:
+  X aaa;
+  int foo();
+};
+
+template <class X> A<X> f(X);
+
+void frep() {
+  int x;
+  x = f(6.4).foo();
+}
+
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t21.C b/gcc/testsuite/g++.old-deja/g++.pt/t21.C
new file mode 100644
index 00000000000..f05f89ff4c2
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t21.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X> class A { public: int a; X x; };
+template <class X> X f (A<X> a) { return a.x; }
+
+extern A<double> a_dbl;
+
+double fred () { return f (a_dbl); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t22.C b/gcc/testsuite/g++.old-deja/g++.pt/t22.C
new file mode 100644
index 00000000000..1102baabef3
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t22.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+
+class AA { public: static int xx; };
+template <class X> class A {
+ public:
+  static int x;
+};
+
+int AA::xx;
+template <class Y> int A<Y>::x;	// gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t23.C b/gcc/testsuite/g++.old-deja/g++.pt/t23.C
new file mode 100644
index 00000000000..82221b32715
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t23.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+
+template <class T> class temp1
+{
+public:
+        T tvar;
+};
+
+
+template <class T2> class temp2
+{
+public :
+        temp1<T2> t1var;
+};
+
+
+temp1<int> temp1var;
+temp2<int> temp2var;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t24.C b/gcc/testsuite/g++.old-deja/g++.pt/t24.C
new file mode 100644
index 00000000000..60322706389
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t24.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+// Special g++ Options: 
+
+template <class X> int f (X x, X y) { return 23; }
+
+int foo () {
+  return f (7);	// ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t25.C b/gcc/testsuite/g++.old-deja/g++.pt/t25.C
new file mode 100644
index 00000000000..23197746825
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t25.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X> int f (X x, X y) { return 23; }
+template <class X> int f (X x, int j = 3) { return 29; }
+
+int foo () {
+  return f (7);		// gets bogus error - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t26.C b/gcc/testsuite/g++.old-deja/g++.pt/t26.C
new file mode 100644
index 00000000000..cfc1591df2d
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t26.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X> int f (X x, unsigned int j = 3) { return 29; }
+template <class X> int f (X x, X y) { return 23; }
+
+int foo () {
+  return f (7.0, 9.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t27.C b/gcc/testsuite/g++.old-deja/g++.pt/t27.C
new file mode 100644
index 00000000000..f3246e81204
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t27.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X> int f (X x, int * j) { return 29; }
+template <class X> int f (X x, ...) { return 23; }
+
+int foo () {
+  return f (7.0, 9.0);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t28.C b/gcc/testsuite/g++.old-deja/g++.pt/t28.C
new file mode 100644
index 00000000000..dd524cb781a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t28.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+
+template <class X> class B;
+template <class X> int f (B<X> b) { return 37; }
+template <class Y> class B { public: Y y; B() { y = 1; } };
+
+int foo () {
+  B<double> bd;
+  return f(bd);
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t29.C b/gcc/testsuite/g++.old-deja/g++.pt/t29.C
new file mode 100644
index 00000000000..54a5052ff02
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t29.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X, int n> X f (auto X (*x)[n]) { return (*x)[n/2]; }
+extern int i[30];
+extern double d[99];
+
+int foo (int ii) { return f (&i); }		// causes abort
+double foo (double dd) { return f (&d); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t30.C b/gcc/testsuite/g++.old-deja/g++.pt/t30.C
new file mode 100644
index 00000000000..42d88eaee29
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t30.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X, int n> X f (auto X (*x)[n]) { return (*x)[n/2]; }
+extern int i[30], i2[33];
+extern double d[99];
+
+int foo (int ii) { return f (&i) + f(&i2); }	// causes abort
+double foo (double dd) { return f (&d); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t31.C b/gcc/testsuite/g++.old-deja/g++.pt/t31.C
new file mode 100644
index 00000000000..8800ebe7ca8
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t31.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+
+struct B { int foo (); };
+int B::foo() { return 37; }
+
+template <class A> struct X {
+  void f();
+};
+
+template <class A> void X<A>::f ()
+{}
+
+X<int> x;
+
+void xyzzy () {
+  x.f ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t32.C b/gcc/testsuite/g++.old-deja/g++.pt/t32.C
new file mode 100644
index 00000000000..89f8db19108
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t32.C
@@ -0,0 +1,14 @@
+// Build don't link: 
+
+template <class X> struct A {
+  int fooo (int x);
+  int x;
+  inline int y () { return 3; }
+  inline int z () { return 5; }
+};
+
+template <class Y> int A<Y>::fooo (int t) { return (this->*(x?&A<Y>::y : &A<Y>::z))() + t; };	// gets bogus error
+
+A<int> ai;
+
+int frop () { return ai.fooo (100); }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t32a.C b/gcc/testsuite/g++.old-deja/g++.pt/t32a.C
new file mode 100644
index 00000000000..13dfda122b6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t32a.C
@@ -0,0 +1,10 @@
+// Build don't link: 
+
+struct A {
+  int x;
+  int y ();
+  int z ();
+  int foo (int j);
+};
+
+int A::foo (int q) { return q + (this->*(x ? &A::y : &A::z)) (); }	// gets bogus error
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t34.C b/gcc/testsuite/g++.old-deja/g++.pt/t34.C
new file mode 100644
index 00000000000..acf858adf93
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t34.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+template <class X> struct A { int operator [] (int); };
+template <class Y> int A<Y>::operator[] (int j) { return j * j; }
+
+extern A<void **> avpp;
+
+int q () { return avpp[99]; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t34a.C b/gcc/testsuite/g++.old-deja/g++.pt/t34a.C
new file mode 100644
index 00000000000..7d5aebf598a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t34a.C
@@ -0,0 +1,16 @@
+// Build don't link: 
+
+struct A {
+  int operator[] (int);
+};
+
+//int A::operator[] (int);
+
+int A::operator[] (int j)
+{
+  return j * j;
+}
+
+extern A a;
+
+int q () { return a[99]; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t35.C b/gcc/testsuite/g++.old-deja/g++.pt/t35.C
new file mode 100644
index 00000000000..f0ed971ae47
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t35.C
@@ -0,0 +1,12 @@
+// Build don't link: 
+// Special g++ Options:
+template<class X> struct A {
+  A ();
+  ~A();
+  int x, y, z;
+};
+
+template <class Y> inline A<Y>::A () { x = y = 3; z = 99; }
+template <class Z> inline A<Z>::~A() { y = 9999; }
+
+A<int> ai;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t36.C b/gcc/testsuite/g++.old-deja/g++.pt/t36.C
new file mode 100644
index 00000000000..bb791b9df75
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t36.C
@@ -0,0 +1,6 @@
+// Build don't link: 
+
+void * foo () {
+  typedef int * ip;
+  return new ip;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t37.C b/gcc/testsuite/g++.old-deja/g++.pt/t37.C
new file mode 100644
index 00000000000..434dadd8228
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t37.C
@@ -0,0 +1,17 @@
+// Build don't link: 
+
+class A {
+public:
+  A(int);			// ERROR - referenced below
+  A(float);			// ERROR - referenced below
+  ~A();
+}; // ERROR - synthesized copy ctor
+
+A::A() {		// ERROR - 
+}
+  
+A::A(int) {
+}
+  
+A::~A() {
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t37a.C b/gcc/testsuite/g++.old-deja/g++.pt/t37a.C
new file mode 100644
index 00000000000..797b78df5ac
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t37a.C
@@ -0,0 +1,18 @@
+// Build don't link: 
+
+class A {
+public:
+  A(int);
+  A(float);
+  ~A();
+};
+
+A::A(float f) {
+}
+  
+A::A(int i) {
+}
+  
+A::~A() {
+}
+  
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t38.C b/gcc/testsuite/g++.old-deja/g++.pt/t38.C
new file mode 100644
index 00000000000..cd892822b14
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t38.C
@@ -0,0 +1,19 @@
+// Build don't link: 
+// Special g++ Options:
+extern "C" int printf (const char *, ...);
+
+template<class X> struct A {
+  A (int, char);
+  ~A ();
+  A (X *, float);
+};
+
+template<class Y> inline A<Y>::A (int i, char c) {
+  printf ("%d, %d\n", i, c);
+}
+template<class Z> A<Z>::~A() {}
+template<class W> A<W>::A (W * d, float f) {
+  printf ("%x, %e\n", d, f);
+}
+
+A<void> avoid (9, 0);
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t39.C b/gcc/testsuite/g++.old-deja/g++.pt/t39.C
new file mode 100644
index 00000000000..d12ef814063
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t39.C
@@ -0,0 +1,25 @@
+extern "C" int printf (const char *, ...);
+
+template <class T>
+struct frob {
+  T *ptr;
+  void print ();
+  frob (T* init) { ptr = init; }
+};
+
+template <class T>
+void frob<T>::print () {
+  printf ("this = %08x\n", this);
+  printf (" ptr = %08x\n", ptr);
+  printf (" values = %x %x %x ...\n", ptr[0], ptr[1], ptr[2]);
+}
+
+  static int x[10];
+  frob<char> fc ("hello");
+  frob<int> fi (x);
+
+int main () {
+  fc.print ();
+  fi.print ();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t40.C b/gcc/testsuite/g++.old-deja/g++.pt/t40.C
new file mode 100644
index 00000000000..34768a995ff
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t40.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+
+struct A {
+  struct B {
+    B (int);
+  };
+  static int foop (B);
+  static int splat () {
+    return foop (B (1));
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t41.C b/gcc/testsuite/g++.old-deja/g++.pt/t41.C
new file mode 100644
index 00000000000..c02f6779a39
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t41.C
@@ -0,0 +1,11 @@
+// Build don't link: 
+
+struct A {
+  struct B {
+    B (int);
+  };
+  static int foop (B);
+  int splat () {
+    return foop (B (1));
+  }
+};
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/t42.C b/gcc/testsuite/g++.old-deja/g++.pt/t42.C
new file mode 100644
index 00000000000..55459949b77
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/t42.C
@@ -0,0 +1,17 @@
+extern "C" void abort ();
+
+struct A {
+  struct stat {
+    int x;
+    stat (int j) { abort (); }
+  };
+  static int stat (double d) { return 0; }	// gets bogus error - cfront takes it
+  static int zap () {
+    stat (0);
+    return stat (1);	// gets bogus error - this should work
+  }
+};
+
+int main () {
+  return A::zap ();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/test5.C b/gcc/testsuite/g++.old-deja/g++.pt/test5.C
new file mode 100644
index 00000000000..dc74c2d88f7
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/test5.C
@@ -0,0 +1,3 @@
+// Build don't link: 
+
+template <char *a, const char *b, char *const c> class A{int x;};
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/tiemann1r.C b/gcc/testsuite/g++.old-deja/g++.pt/tiemann1r.C
new file mode 100644
index 00000000000..65e6807da98
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/tiemann1r.C
@@ -0,0 +1,8 @@
+// Build don't link: 
+
+struct bs_1
+{
+  typedef int (*p_user_hashf)(int);
+};
+
+bs_1::p_user_hashf i_user_hashf;
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/tiemann2.C b/gcc/testsuite/g++.old-deja/g++.pt/tiemann2.C
new file mode 100644
index 00000000000..31465d86025
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/tiemann2.C
@@ -0,0 +1,34 @@
+extern "C" void printf (char *, ...);
+template <class T> T max (const T&x, const T&y)
+{
+  return (x>y)?x:y;
+}
+
+class complex
+{
+  double re, im;
+ public:
+  complex (double r, double i=0) { re = r; im = i; }
+  friend int operator > (const complex& x, const complex &y);
+  void print () { printf ("re = %g; im = %g;\n", re, im); }
+};
+int operator >(const complex& x, const complex &y)
+{
+  double c1 = x.re * x.re + x.im * x.im;
+  double c2 = y.re * y.re + y.im * y.im;
+  return c1 > c2;
+}
+
+main ()
+{
+  complex c1 (1, 0);
+  complex c2 (2, 0);
+  complex c3 (2, 3);
+  complex c4 (2, 1);
+
+  complex m1 = max (c1, c2);
+  complex m2 = max (c3, c4);
+  m1.print ();
+  m2.print ();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/to2.C b/gcc/testsuite/g++.old-deja/g++.pt/to2.C
new file mode 100644
index 00000000000..936729c6b18
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/to2.C
@@ -0,0 +1,7 @@
+// Build don't link: 
+
+template <class A> class B { public: A a; };
+static B<int> b_int;
+static B<int> b_int2;
+
+int foo () { return b_int.a + b_int2.a; }
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/tt.C b/gcc/testsuite/g++.old-deja/g++.pt/tt.C
new file mode 100644
index 00000000000..e597875a05a
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/tt.C
@@ -0,0 +1,33 @@
+// Build don't link: 
+
+#define DEF_A   struct A { A() { a = 2; } int a; }
+
+#if 1
+int f1 () {
+  DEF_A;
+  A aa;
+  return aa.a;
+}
+
+int f2 () {
+  DEF_A;
+  A ab;
+  return ab.a;
+}
+/* results:
+tt.cc: In function int f2 ():
+tt.cc:9: conflicting types for `A::A ()'
+tt.cc:3: previous declaration of `A::A ()'
+/u2/projects/gcc2/src/cplus-cvt.c:1149: failed assertion `distance >= 0'
+gcc2: Program cc1plus got fatal signal 6.
+*/
+#else
+
+struct B1 { DEF_A; A aa; };
+
+struct B2 { DEF_A; A aa; };
+/* results:
+/u2/projects/gcc2/src/cplus-decl.c:5469: failed assertion `return_type == return_ctor'
+gcc2: Program cc1plus got fatal signal 6.
+*/
+#endif
diff --git a/gcc/testsuite/g++.old-deja/g++.pt/tt2.C b/gcc/testsuite/g++.old-deja/g++.pt/tt2.C
new file mode 100644
index 00000000000..c4323a50340
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.pt/tt2.C
@@ -0,0 +1,22 @@
+// Build don't link: 
+
+int f1 () {
+  struct A {
+    A() : b (2) { }
+    fred () { return b.hi_mom; }
+    struct B {
+      int hi_mom;
+      B (int a) { hi_mom = a; }
+    };
+    B b;
+  };
+  A aa;
+  return aa.fred();
+}
+
+int f2 () {
+  struct A { ~A() { a = 3; } int a; fred () { return a + 1; } };
+  A ab;
+  ab.a = 12;
+  return ab.fred();
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.rfg/00321_01-.C b/gcc/testsuite/g++.old-deja/g++.rfg/00321_01-.C
new file mode 100644
index 00000000000..d7e08a3876f
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.rfg/00321_01-.C
@@ -0,0 +1,14 @@
+// Here is a simple one.  GCC correctly gives errors for this code when the
+// - -pedantic-errors option is used, whereas g++ doesn't.
+
+// Build don't link:
+
+int (*p1)[3];
+int (*p2)[5];
+
+void
+test ()
+{
+  p1 == p2;		// ERROR - comparison.*
+  p1 > p2;		// ERROR - comparison.*
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.rfg/00324_02-.C b/gcc/testsuite/g++.old-deja/g++.rfg/00324_02-.C
new file mode 100644
index 00000000000..4055ba8432e
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.rfg/00324_02-.C
@@ -0,0 +1,16 @@
+// Another simple one.  GCC corerctly gives errors for this code when the
+// - -pedantic-errors options is used.  g++ doesn't.
+
+// Build don't link:
+
+void f (int i) { }
+ 
+void (*fp)(void);
+ 
+int i;
+ 
+void
+test ()
+{
+   i ? f : fp; // ERROR - 
+}
diff --git a/gcc/testsuite/g++.old-deja/g++.rfg/README b/gcc/testsuite/g++.old-deja/g++.rfg/README
new file mode 100644
index 00000000000..9e0e377dff4
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.rfg/README
@@ -0,0 +1,30 @@
+From segfault!rfg@netcom.com Mon Feb 15 10:42:26 1993
+Return-Path: <segfault!rfg@netcom.com>
+Received: from netcomsv.netcom.com (uucp3.netcom.com) by cygnus.com (4.1/SMI-4.1)
+	id AA03498; Mon, 15 Feb 93 10:42:25 PST
+Received: from segfault.UUCP by netcomsv.netcom.com with UUCP (4.1/SMI-4.1)
+	id AA22925; Mon, 15 Feb 93 10:42:24 PST
+From: segfault!rfg@netcom.com
+Received: by segfault.uucp (4.1/SMI-4.1)
+	id AA11458; Mon, 15 Feb 93 10:40:56 PST
+To: cygnus.com!mrs@netcom.com (Mike Stump)
+Subject: Re: g++ errors 
+Reply-To: segfault!rfg@netcom.com
+Date: Mon, 15 Feb 93 10:40:56 PST
+Message-Id: <11457.729801656@segfault>
+
+I hereby grant you limited permission to use this test case (and the
+others I have previously posted the the gcc2 list) for the sole
+purpose of finding and fixing bugs in the g++ compiler.  You may look
+at it, save a copy of it online, and compile it (as often as you like)
+but in all cases, my copyright notice must be maintained.  In no case
+may you redistribute it outside of Cygnus Support, or make it
+available for redistribution outside of Cygnus Support (e.g. via FTP
+or UUCP), either alone, or as part of any larger package or test
+suite.  This test case and the other test cases I have previously
+posted to the gcc2 list are provided on an "as is" basis, and there is
+no warrantee of any kind, either express or implied.  Neither Ron
+Guilmette, nor Ron Guilmette Computing will be responsible or liable
+in any way for any damages, either direct, consequential, or
+incidental, arising from the use of any of the aforementioned test
+cases.
diff --git a/gcc/testsuite/g++.old-deja/old-deja.exp b/gcc/testsuite/g++.old-deja/old-deja.exp
new file mode 100644
index 00000000000..87cdb2eeadc
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/old-deja.exp
@@ -0,0 +1,64 @@
+# Copyright (C) 1988, 90, 91, 92, 1994, 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-g++@prep.ai.mit.edu
+
+# This file was written by Rob Savoye. (rob@cygnus.com)
+
+#
+# these tests come from the original DejaGnu test suite 
+# developed at Cygnus Support. If this isn't deja gnu, I
+# don't know what is...
+#
+
+# load support procs
+load_lib old-dejagnu.exp
+load_lib g++.exp
+
+
+# When a testcase doesn't have any special options, use these.
+if ![info exists DEFAULT_CXXFLAGS] {
+    set DEFAULT_CXXFLAGS "-ansi -pedantic-errors"
+
+}
+
+old-dejagnu-init
+global GXX_UNDER_TEST
+
+#
+# main test loop
+#
+
+
+foreach file [lsort [find $srcdir/$subdir *.C]] {
+    # If we're only testing specific files and this isn't one of them, skip it.
+    if ![runtest_file_p $runtests $file] then {
+	continue
+    }
+    verbose "Testing $file"
+
+    # We don't want old-dejagnu.exp to have to know about all the global
+    # variables we use.  For now we tell it about CXXFLAGS and LIBS and
+    # leave LDFLAGS alone.
+    old-dejagnu $GXX_UNDER_TEST "$file" "" "$DEFAULT_CXXFLAGS" "-lstdc++"
+}
+
+# The framework doesn't like to see any error remnants,
+# so remove them.
+if [info exists errorInfo] then {
+      unset errorInfo
+}
diff --git a/gcc/testsuite/gcc.c-torture/ChangeLog b/gcc/testsuite/gcc.c-torture/ChangeLog
new file mode 100644
index 00000000000..0ee0fa70ed9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/ChangeLog
@@ -0,0 +1,659 @@
+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/testsuite/gcc.c-torture/code_quality/920608-1.c b/gcc/testsuite/gcc.c-torture/code_quality/920608-1.c
new file mode 100644
index 00000000000..cae1978e6c0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/code_quality/Makefile.in b/gcc/testsuite/gcc.c-torture/code_quality/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/code_quality/code_quality.exp b/gcc/testsuite/gcc.c-torture/code_quality/code_quality.exp
new file mode 100644
index 00000000000..b8b72ea1bcb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/code_quality/configure.in b/gcc/testsuite/gcc.c-torture/code_quality/configure.in
new file mode 100644
index 00000000000..0fb5342a5d6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/Makefile.in b/gcc/testsuite/gcc.c-torture/compat/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/configure.in b/gcc/testsuite/gcc.c-torture/compat/configure.in
new file mode 100644
index 00000000000..a4a5810eb96
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/strct-layout.c b/gcc/testsuite/gcc.c-torture/compat/strct-layout.c
new file mode 100644
index 00000000000..b77e1636dd2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-align.c b/gcc/testsuite/gcc.c-torture/compat/struct-align.c
new file mode 100644
index 00000000000..69fe6b335ca
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-big.c b/gcc/testsuite/gcc.c-torture/compat/struct-big.c
new file mode 100644
index 00000000000..e1d5c6a6b37
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-i.c b/gcc/testsuite/gcc.c-torture/compat/struct-i.c
new file mode 100644
index 00000000000..25cbee6071e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-ic.c b/gcc/testsuite/gcc.c-torture/compat/struct-ic.c
new file mode 100644
index 00000000000..7c5fa79e142
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-ii.c b/gcc/testsuite/gcc.c-torture/compat/struct-ii.c
new file mode 100644
index 00000000000..11ebc37edbd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compat/struct-ret-1.c b/gcc/testsuite/gcc.c-torture/compat/struct-ret-1.c
new file mode 100644
index 00000000000..a585c8fdb40
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/900116-1.c b/gcc/testsuite/gcc.c-torture/compile/900116-1.c
new file mode 100644
index 00000000000..37c7eb789b9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/900216-1.c b/gcc/testsuite/gcc.c-torture/compile/900216-1.c
new file mode 100644
index 00000000000..8a4bfb74e78
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/900313-1.c b/gcc/testsuite/gcc.c-torture/compile/900313-1.c
new file mode 100644
index 00000000000..f2bc40d7242
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/900407-1.c b/gcc/testsuite/gcc.c-torture/compile/900407-1.c
new file mode 100644
index 00000000000..fdf47791cd7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/900516-1.c b/gcc/testsuite/gcc.c-torture/compile/900516-1.c
new file mode 100644
index 00000000000..69e96144745
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/900516-1.c
@@ -0,0 +1 @@
+f(c){return!(c?2.0:1.0);}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920301-1.c b/gcc/testsuite/gcc.c-torture/compile/920301-1.c
new file mode 100644
index 00000000000..c4d663eb8a7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920409-1.c b/gcc/testsuite/gcc.c-torture/compile/920409-1.c
new file mode 100644
index 00000000000..b96ec53d595
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920409-1.c
@@ -0,0 +1 @@
+x(){int y;y>0.0?y:y-1;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920409-2.c b/gcc/testsuite/gcc.c-torture/compile/920409-2.c
new file mode 100644
index 00000000000..ef2bdb8b7e7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920410-1.c b/gcc/testsuite/gcc.c-torture/compile/920410-1.c
new file mode 100644
index 00000000000..4bfa7a665a3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920410-2.c b/gcc/testsuite/gcc.c-torture/compile/920410-2.c
new file mode 100644
index 00000000000..958aae9cb0f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920411-2.c b/gcc/testsuite/gcc.c-torture/compile/920411-2.c
new file mode 100644
index 00000000000..0cc13c8436a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920413-1.c b/gcc/testsuite/gcc.c-torture/compile/920413-1.c
new file mode 100644
index 00000000000..45b5fc5d09c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920415-1.c b/gcc/testsuite/gcc.c-torture/compile/920415-1.c
new file mode 100644
index 00000000000..8d9bc065349
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-1.c b/gcc/testsuite/gcc.c-torture/compile/920428-1.c
new file mode 100644
index 00000000000..fdc478a382c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920428-1.c
@@ -0,0 +1 @@
+x(){char*q;return(long)q>>8&0xff;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920428-2.c b/gcc/testsuite/gcc.c-torture/compile/920428-2.c
new file mode 100644
index 00000000000..23f32a83a9d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-3.c b/gcc/testsuite/gcc.c-torture/compile/920428-3.c
new file mode 100644
index 00000000000..13640c98ad2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-4.c b/gcc/testsuite/gcc.c-torture/compile/920428-4.c
new file mode 100644
index 00000000000..cc5e30c2a80
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-5.c b/gcc/testsuite/gcc.c-torture/compile/920428-5.c
new file mode 100644
index 00000000000..ff313799280
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-6.c b/gcc/testsuite/gcc.c-torture/compile/920428-6.c
new file mode 100644
index 00000000000..e43af7ed3a7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920428-7.c b/gcc/testsuite/gcc.c-torture/compile/920428-7.c
new file mode 100644
index 00000000000..69b1d979aa9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-1.c b/gcc/testsuite/gcc.c-torture/compile/920501-1.c
new file mode 100644
index 00000000000..a84956417b0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-10.c b/gcc/testsuite/gcc.c-torture/compile/920501-10.c
new file mode 100644
index 00000000000..ecb5bb4151c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-10.c
@@ -0,0 +1 @@
+x(y){return 8193*y;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920501-11.c b/gcc/testsuite/gcc.c-torture/compile/920501-11.c
new file mode 100644
index 00000000000..d636357e867
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-12.c b/gcc/testsuite/gcc.c-torture/compile/920501-12.c
new file mode 100644
index 00000000000..594e14178b9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-13.c b/gcc/testsuite/gcc.c-torture/compile/920501-13.c
new file mode 100644
index 00000000000..b5a6798ecc2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-15.c b/gcc/testsuite/gcc.c-torture/compile/920501-15.c
new file mode 100644
index 00000000000..81fd66401d5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-16.c b/gcc/testsuite/gcc.c-torture/compile/920501-16.c
new file mode 100644
index 00000000000..f82b7524b24
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-17.c b/gcc/testsuite/gcc.c-torture/compile/920501-17.c
new file mode 100644
index 00000000000..05a4d408d50
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-18.c b/gcc/testsuite/gcc.c-torture/compile/920501-18.c
new file mode 100644
index 00000000000..70f7c0af505
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-19.c b/gcc/testsuite/gcc.c-torture/compile/920501-19.c
new file mode 100644
index 00000000000..1671cc37e68
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-19.c
@@ -0,0 +1 @@
+long long x=0;y(){x=0;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920501-2.c b/gcc/testsuite/gcc.c-torture/compile/920501-2.c
new file mode 100644
index 00000000000..905f5ddb627
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-20.c b/gcc/testsuite/gcc.c-torture/compile/920501-20.c
new file mode 100644
index 00000000000..170d0501761
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-21.c b/gcc/testsuite/gcc.c-torture/compile/920501-21.c
new file mode 100644
index 00000000000..4a9f05a1b20
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-22.c b/gcc/testsuite/gcc.c-torture/compile/920501-22.c
new file mode 100644
index 00000000000..b15d7984b1b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-22.c
@@ -0,0 +1 @@
+x(){int y[]={};}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920501-23.c b/gcc/testsuite/gcc.c-torture/compile/920501-23.c
new file mode 100644
index 00000000000..291d93e6c5d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-24.c b/gcc/testsuite/gcc.c-torture/compile/920501-24.c
new file mode 100644
index 00000000000..ae9c145ef1b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-3.c b/gcc/testsuite/gcc.c-torture/compile/920501-3.c
new file mode 100644
index 00000000000..41ef87fbf7f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-4.c b/gcc/testsuite/gcc.c-torture/compile/920501-4.c
new file mode 100644
index 00000000000..9cd2fd7bd7a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-6.c b/gcc/testsuite/gcc.c-torture/compile/920501-6.c
new file mode 100644
index 00000000000..d0a406381ff
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-6.c
@@ -0,0 +1 @@
+x(y,z)float*y;{*y=z;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920501-7.c b/gcc/testsuite/gcc.c-torture/compile/920501-7.c
new file mode 100644
index 00000000000..ee193f78a4a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920501-8.c b/gcc/testsuite/gcc.c-torture/compile/920501-8.c
new file mode 100644
index 00000000000..68e33934d21
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-8.c
@@ -0,0 +1 @@
+x(int*p){int x=p;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920501-9.c b/gcc/testsuite/gcc.c-torture/compile/920501-9.c
new file mode 100644
index 00000000000..98a06000bf2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920501-9.c
@@ -0,0 +1 @@
+short x(a)unsigned a;{a=32987799;return a;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920502-1.c b/gcc/testsuite/gcc.c-torture/compile/920502-1.c
new file mode 100644
index 00000000000..b576c6c990c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920502-1.c
@@ -0,0 +1 @@
+extern void*t[];x(i){goto*t[i];}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920502-2.c b/gcc/testsuite/gcc.c-torture/compile/920502-2.c
new file mode 100644
index 00000000000..d3aa1e26d81
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920502-2.c
@@ -0,0 +1 @@
+x(c){1LL<<c;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920529-1.c b/gcc/testsuite/gcc.c-torture/compile/920529-1.c
new file mode 100644
index 00000000000..0f50309a27c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920611-2.c b/gcc/testsuite/gcc.c-torture/compile/920611-2.c
new file mode 100644
index 00000000000..e54b1cda5fc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920615-1.c b/gcc/testsuite/gcc.c-torture/compile/920615-1.c
new file mode 100644
index 00000000000..9b1c6aceef3
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920615-1.c
@@ -0,0 +1,4 @@
+f()
+{
+  int x[20] = {[0] = 5, [10] = 12};
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920617-1.c b/gcc/testsuite/gcc.c-torture/compile/920617-1.c
new file mode 100644
index 00000000000..2d84e8d84f8
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920617-1.c
@@ -0,0 +1 @@
+f(){double*xp,y;*xp++=sqrt(y);}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920617-2.c b/gcc/testsuite/gcc.c-torture/compile/920617-2.c
new file mode 100644
index 00000000000..3a5450982c0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920623-1.c b/gcc/testsuite/gcc.c-torture/compile/920623-1.c
new file mode 100644
index 00000000000..9b6ad51e102
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920623-1.c
@@ -0,0 +1,2 @@
+int f(int c){return f(c--);}
+g(){}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920624-1.c b/gcc/testsuite/gcc.c-torture/compile/920624-1.c
new file mode 100644
index 00000000000..8b4d2979d26
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920625-1.c b/gcc/testsuite/gcc.c-torture/compile/920625-1.c
new file mode 100644
index 00000000000..720d43fd42f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920625-2.c b/gcc/testsuite/gcc.c-torture/compile/920625-2.c
new file mode 100644
index 00000000000..1466285f88e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920626-1.c b/gcc/testsuite/gcc.c-torture/compile/920626-1.c
new file mode 100644
index 00000000000..54419866a1f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920626-1.c
@@ -0,0 +1 @@
+f(x)unsigned x;{return x>>-5;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920701-1.c b/gcc/testsuite/gcc.c-torture/compile/920701-1.c
new file mode 100644
index 00000000000..4302f9ea331
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920702-1.c b/gcc/testsuite/gcc.c-torture/compile/920702-1.c
new file mode 100644
index 00000000000..23a5395b0cd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920706-1.c b/gcc/testsuite/gcc.c-torture/compile/920706-1.c
new file mode 100644
index 00000000000..13b0ff1e0ba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920710-2.c b/gcc/testsuite/gcc.c-torture/compile/920710-2.c
new file mode 100644
index 00000000000..dcaf1bea3cf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920711-1.c b/gcc/testsuite/gcc.c-torture/compile/920711-1.c
new file mode 100644
index 00000000000..a5aa7df1127
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920711-1.c
@@ -0,0 +1 @@
+f(a){a=(1,1)/2;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920721-1.c b/gcc/testsuite/gcc.c-torture/compile/920721-1.c
new file mode 100644
index 00000000000..7ced611eb6f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920723-1.c b/gcc/testsuite/gcc.c-torture/compile/920723-1.c
new file mode 100644
index 00000000000..af0cf76f42c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920729-1.c b/gcc/testsuite/gcc.c-torture/compile/920729-1.c
new file mode 100644
index 00000000000..96676e95307
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920806-1.c b/gcc/testsuite/gcc.c-torture/compile/920806-1.c
new file mode 100644
index 00000000000..0928fe8a784
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920806-1.c
@@ -0,0 +1 @@
+f(){short x=32000;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920808-1.c b/gcc/testsuite/gcc.c-torture/compile/920808-1.c
new file mode 100644
index 00000000000..17510a96821
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920808-1.c
@@ -0,0 +1 @@
+f(i){for(i=1;i<=2;({;}),i++){({;}),g();}}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920809-1.c b/gcc/testsuite/gcc.c-torture/compile/920809-1.c
new file mode 100644
index 00000000000..ad35e121003
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920809-1.c
@@ -0,0 +1 @@
+f(x,y){memcpy (&x,&y,8192);}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920817-1.c b/gcc/testsuite/gcc.c-torture/compile/920817-1.c
new file mode 100644
index 00000000000..31a57339ea9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920820-1.c b/gcc/testsuite/gcc.c-torture/compile/920820-1.c
new file mode 100644
index 00000000000..2bc0dbea07b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920820-1.c
@@ -0,0 +1 @@
+long long f(double y){return y;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920821-1.c b/gcc/testsuite/gcc.c-torture/compile/920821-1.c
new file mode 100644
index 00000000000..40a8c178f10
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920821-1.c
@@ -0,0 +1 @@
+/* empty */
diff --git a/gcc/testsuite/gcc.c-torture/compile/920821-2.c b/gcc/testsuite/gcc.c-torture/compile/920821-2.c
new file mode 100644
index 00000000000..a69c0a901ba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920825-1.c b/gcc/testsuite/gcc.c-torture/compile/920825-1.c
new file mode 100644
index 00000000000..514d63f977f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920825-2.c b/gcc/testsuite/gcc.c-torture/compile/920825-2.c
new file mode 100644
index 00000000000..9834aac1783
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920826-1.c b/gcc/testsuite/gcc.c-torture/compile/920826-1.c
new file mode 100644
index 00000000000..d19eff2cec6
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920826-1.c
@@ -0,0 +1 @@
+f(int*x){goto*(char)*x;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920828-1.c b/gcc/testsuite/gcc.c-torture/compile/920828-1.c
new file mode 100644
index 00000000000..4893173423b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920829-1.c b/gcc/testsuite/gcc.c-torture/compile/920829-1.c
new file mode 100644
index 00000000000..593400bac92
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920831-1.c b/gcc/testsuite/gcc.c-torture/compile/920831-1.c
new file mode 100644
index 00000000000..ff2fd6360bf
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/920831-1.c
@@ -0,0 +1 @@
+f(x){goto*(char)x;}
diff --git a/gcc/testsuite/gcc.c-torture/compile/920902-1.c b/gcc/testsuite/gcc.c-torture/compile/920902-1.c
new file mode 100644
index 00000000000..6f6dcd5bf30
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920909-1.c b/gcc/testsuite/gcc.c-torture/compile/920909-1.c
new file mode 100644
index 00000000000..939aaf789e8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920917-1.c b/gcc/testsuite/gcc.c-torture/compile/920917-1.c
new file mode 100644
index 00000000000..ebe8200d48b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-1.c b/gcc/testsuite/gcc.c-torture/compile/920928-1.c
new file mode 100644
index 00000000000..137363dc120
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-2.c b/gcc/testsuite/gcc.c-torture/compile/920928-2.c
new file mode 100644
index 00000000000..a0964f90f44
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-3.c b/gcc/testsuite/gcc.c-torture/compile/920928-3.c
new file mode 100644
index 00000000000..583dc69b74c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-4.c b/gcc/testsuite/gcc.c-torture/compile/920928-4.c
new file mode 100644
index 00000000000..348de654f30
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-5.c b/gcc/testsuite/gcc.c-torture/compile/920928-5.c
new file mode 100644
index 00000000000..8c975f0c051
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/920928-6.c b/gcc/testsuite/gcc.c-torture/compile/920928-6.c
new file mode 100644
index 00000000000..692191b1245
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921004-1.c b/gcc/testsuite/gcc.c-torture/compile/921004-1.c
new file mode 100644
index 00000000000..a947229089f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921011-1.c b/gcc/testsuite/gcc.c-torture/compile/921011-1.c
new file mode 100644
index 00000000000..6cc707dc74c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921011-2.c b/gcc/testsuite/gcc.c-torture/compile/921011-2.c
new file mode 100644
index 00000000000..bf11dad979f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921012-1.c b/gcc/testsuite/gcc.c-torture/compile/921012-1.c
new file mode 100644
index 00000000000..7b5cb6b9f17
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/921012-1.c
@@ -0,0 +1,4 @@
+f()
+{
+g(({int x;0;}));
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/921012-2.c b/gcc/testsuite/gcc.c-torture/compile/921012-2.c
new file mode 100644
index 00000000000..6f4de779549
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921013-1.c b/gcc/testsuite/gcc.c-torture/compile/921013-1.c
new file mode 100644
index 00000000000..0d14cbc6bb6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921019-1.c b/gcc/testsuite/gcc.c-torture/compile/921019-1.c
new file mode 100644
index 00000000000..227bdc276fa
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921021-1.c b/gcc/testsuite/gcc.c-torture/compile/921021-1.c
new file mode 100644
index 00000000000..18dffeb9dd3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921024-1.c b/gcc/testsuite/gcc.c-torture/compile/921024-1.c
new file mode 100644
index 00000000000..e723246d6b2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921026-1.c b/gcc/testsuite/gcc.c-torture/compile/921026-1.c
new file mode 100644
index 00000000000..18238de8332
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/921026-1.c
@@ -0,0 +1,4 @@
+f(unsigned short*a)
+{
+a[0]=65535;
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/921103-1.c b/gcc/testsuite/gcc.c-torture/compile/921103-1.c
new file mode 100644
index 00000000000..578e91aaf83
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921109-1.c b/gcc/testsuite/gcc.c-torture/compile/921109-1.c
new file mode 100644
index 00000000000..eda43451f25
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921109-3.c b/gcc/testsuite/gcc.c-torture/compile/921109-3.c
new file mode 100644
index 00000000000..40e63f26ed6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921111-1.c b/gcc/testsuite/gcc.c-torture/compile/921111-1.c
new file mode 100644
index 00000000000..11b467460b3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921116-2.c b/gcc/testsuite/gcc.c-torture/compile/921116-2.c
new file mode 100644
index 00000000000..9eac91cb5c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921118-1.c b/gcc/testsuite/gcc.c-torture/compile/921118-1.c
new file mode 100644
index 00000000000..857c74e74f1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921126-1.c b/gcc/testsuite/gcc.c-torture/compile/921126-1.c
new file mode 100644
index 00000000000..a7b908b2ef0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921202-1.c b/gcc/testsuite/gcc.c-torture/compile/921202-1.c
new file mode 100644
index 00000000000..1287edc57b8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921202-2.c b/gcc/testsuite/gcc.c-torture/compile/921202-2.c
new file mode 100644
index 00000000000..97d482b633c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921203-1.c b/gcc/testsuite/gcc.c-torture/compile/921203-1.c
new file mode 100644
index 00000000000..50fe3eb0b6f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/921203-1.c
@@ -0,0 +1,5 @@
+char dispstr[];
+f()
+{
+  strcpy(dispstr,"xxxxxxxxxxx");
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/921203-2.c b/gcc/testsuite/gcc.c-torture/compile/921203-2.c
new file mode 100644
index 00000000000..929afb1bdde
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921206-1.c b/gcc/testsuite/gcc.c-torture/compile/921206-1.c
new file mode 100644
index 00000000000..b18709dd8d1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/921227-1.c b/gcc/testsuite/gcc.c-torture/compile/921227-1.c
new file mode 100644
index 00000000000..a49750c81af
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930109-1.c b/gcc/testsuite/gcc.c-torture/compile/930109-1.c
new file mode 100644
index 00000000000..dbd15a1bd0a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930109-2.c b/gcc/testsuite/gcc.c-torture/compile/930109-2.c
new file mode 100644
index 00000000000..61e3a4df99f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930111-1.c b/gcc/testsuite/gcc.c-torture/compile/930111-1.c
new file mode 100644
index 00000000000..28574191d13
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930117-1.c b/gcc/testsuite/gcc.c-torture/compile/930117-1.c
new file mode 100644
index 00000000000..83317cdd07b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/930117-1.c
@@ -0,0 +1,4 @@
+f(x)
+{
+  (*(void (*)())&x)();
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/930118-1.c b/gcc/testsuite/gcc.c-torture/compile/930118-1.c
new file mode 100644
index 00000000000..b29543c529e
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/930118-1.c
@@ -0,0 +1,6 @@
+f()
+{
+__label__ l;
+l:p();
+}
+
diff --git a/gcc/testsuite/gcc.c-torture/compile/930120-1.c b/gcc/testsuite/gcc.c-torture/compile/930120-1.c
new file mode 100644
index 00000000000..95ac43c07ed
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930126-1.c b/gcc/testsuite/gcc.c-torture/compile/930126-1.c
new file mode 100644
index 00000000000..8313c5c450b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930210-1.c b/gcc/testsuite/gcc.c-torture/compile/930210-1.c
new file mode 100644
index 00000000000..47d2da2aca5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930217-1.c b/gcc/testsuite/gcc.c-torture/compile/930217-1.c
new file mode 100644
index 00000000000..70f4a4897c4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930222-1.c b/gcc/testsuite/gcc.c-torture/compile/930222-1.c
new file mode 100644
index 00000000000..c6d6aa3b47d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930325-1.c b/gcc/testsuite/gcc.c-torture/compile/930325-1.c
new file mode 100644
index 00000000000..24cea5027ab
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930326-1.c b/gcc/testsuite/gcc.c-torture/compile/930326-1.c
new file mode 100644
index 00000000000..97313d86aa9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930411-1.c b/gcc/testsuite/gcc.c-torture/compile/930411-1.c
new file mode 100644
index 00000000000..bb03c13fa07
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930421-1.c b/gcc/testsuite/gcc.c-torture/compile/930421-1.c
new file mode 100644
index 00000000000..01b465f7fec
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930427-2.c b/gcc/testsuite/gcc.c-torture/compile/930427-2.c
new file mode 100644
index 00000000000..53b633785ae
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930503-1.c b/gcc/testsuite/gcc.c-torture/compile/930503-1.c
new file mode 100644
index 00000000000..6889e8b7aed
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930503-2.c b/gcc/testsuite/gcc.c-torture/compile/930503-2.c
new file mode 100644
index 00000000000..1b0ea34f038
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/930503-2.c
@@ -0,0 +1,5 @@
+f()
+{
+  struct { char x; } r;
+  g(r);
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/930506-1.c b/gcc/testsuite/gcc.c-torture/compile/930506-1.c
new file mode 100644
index 00000000000..8c26ea3670c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930506-2.c b/gcc/testsuite/gcc.c-torture/compile/930506-2.c
new file mode 100644
index 00000000000..e11e62f026f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930510-1.c b/gcc/testsuite/gcc.c-torture/compile/930510-1.c
new file mode 100644
index 00000000000..8c46282626c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930513-1.c b/gcc/testsuite/gcc.c-torture/compile/930513-1.c
new file mode 100644
index 00000000000..2e106ae43a9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930513-2.c b/gcc/testsuite/gcc.c-torture/compile/930513-2.c
new file mode 100644
index 00000000000..a7f508c8266
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930513-3.c b/gcc/testsuite/gcc.c-torture/compile/930513-3.c
new file mode 100644
index 00000000000..f8d4e60341c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930523-1.c b/gcc/testsuite/gcc.c-torture/compile/930523-1.c
new file mode 100644
index 00000000000..5f2b5b5d7e3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930525-1.c b/gcc/testsuite/gcc.c-torture/compile/930525-1.c
new file mode 100644
index 00000000000..00c2e263b82
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930527-1.c b/gcc/testsuite/gcc.c-torture/compile/930527-1.c
new file mode 100644
index 00000000000..53e00e65ed1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930529-1.c b/gcc/testsuite/gcc.c-torture/compile/930529-1.c
new file mode 100644
index 00000000000..70b2cb8f90c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930530-1.c b/gcc/testsuite/gcc.c-torture/compile/930530-1.c
new file mode 100644
index 00000000000..848e0400ece
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930602-1.c b/gcc/testsuite/gcc.c-torture/compile/930602-1.c
new file mode 100644
index 00000000000..5a0eb2189ba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930603-1.c b/gcc/testsuite/gcc.c-torture/compile/930603-1.c
new file mode 100644
index 00000000000..643cc52d4c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930607-1.c b/gcc/testsuite/gcc.c-torture/compile/930607-1.c
new file mode 100644
index 00000000000..97c94b25ec3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930609-1.c b/gcc/testsuite/gcc.c-torture/compile/930609-1.c
new file mode 100644
index 00000000000..d50d3c97def
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930611-1.c b/gcc/testsuite/gcc.c-torture/compile/930611-1.c
new file mode 100644
index 00000000000..c216c096523
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930618-1.c b/gcc/testsuite/gcc.c-torture/compile/930618-1.c
new file mode 100644
index 00000000000..74c21572550
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930621-1.c b/gcc/testsuite/gcc.c-torture/compile/930621-1.c
new file mode 100644
index 00000000000..3679cf1d3de
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930623-1.c b/gcc/testsuite/gcc.c-torture/compile/930623-1.c
new file mode 100644
index 00000000000..4b5b90bd848
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930623-2.c b/gcc/testsuite/gcc.c-torture/compile/930623-2.c
new file mode 100644
index 00000000000..8b61fc14149
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930702-1.c b/gcc/testsuite/gcc.c-torture/compile/930702-1.c
new file mode 100644
index 00000000000..9f51dd876ee
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/930702-1.c
@@ -0,0 +1,5 @@
+f ()
+{
+  {({});}
+  return 1;
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/930926-1.c b/gcc/testsuite/gcc.c-torture/compile/930926-1.c
new file mode 100644
index 00000000000..fcfa4fbc499
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/930927-1.c b/gcc/testsuite/gcc.c-torture/compile/930927-1.c
new file mode 100644
index 00000000000..81a4979f482
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931003-1.c b/gcc/testsuite/gcc.c-torture/compile/931003-1.c
new file mode 100644
index 00000000000..922b14379c9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931004-1.c b/gcc/testsuite/gcc.c-torture/compile/931004-1.c
new file mode 100644
index 00000000000..0e741fd4ac0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931013-1.c b/gcc/testsuite/gcc.c-torture/compile/931013-1.c
new file mode 100644
index 00000000000..c237c0b7341
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931013-2.c b/gcc/testsuite/gcc.c-torture/compile/931013-2.c
new file mode 100644
index 00000000000..8fc0db492ab
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931013-3.c b/gcc/testsuite/gcc.c-torture/compile/931013-3.c
new file mode 100644
index 00000000000..e663b9acc1c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931018-1.c b/gcc/testsuite/gcc.c-torture/compile/931018-1.c
new file mode 100644
index 00000000000..7efe40ec094
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931031-1.c b/gcc/testsuite/gcc.c-torture/compile/931031-1.c
new file mode 100644
index 00000000000..9015f54f7bf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931102-1.c b/gcc/testsuite/gcc.c-torture/compile/931102-1.c
new file mode 100644
index 00000000000..a039c26331c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931102-2.c b/gcc/testsuite/gcc.c-torture/compile/931102-2.c
new file mode 100644
index 00000000000..f39b271645d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/931203-1.c b/gcc/testsuite/gcc.c-torture/compile/931203-1.c
new file mode 100644
index 00000000000..3007ff582e0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/940611-1.c b/gcc/testsuite/gcc.c-torture/compile/940611-1.c
new file mode 100644
index 00000000000..90f72486ada
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/940712-1.c b/gcc/testsuite/gcc.c-torture/compile/940712-1.c
new file mode 100644
index 00000000000..10a6961dcb7
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/940712-1.c
@@ -0,0 +1,4 @@
+f ()
+{
+  return (*(volatile unsigned int *)8000) / 3;
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/940718-1.c b/gcc/testsuite/gcc.c-torture/compile/940718-1.c
new file mode 100644
index 00000000000..505280fa91e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941014-1.c b/gcc/testsuite/gcc.c-torture/compile/941014-1.c
new file mode 100644
index 00000000000..d31701572fc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941014-2.c b/gcc/testsuite/gcc.c-torture/compile/941014-2.c
new file mode 100644
index 00000000000..01e9a672e88
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941014-3.c b/gcc/testsuite/gcc.c-torture/compile/941014-3.c
new file mode 100644
index 00000000000..6dcb89395e3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941014-4.c b/gcc/testsuite/gcc.c-torture/compile/941014-4.c
new file mode 100644
index 00000000000..9e673f37833
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941019-1.c b/gcc/testsuite/gcc.c-torture/compile/941019-1.c
new file mode 100644
index 00000000000..257b594c1b6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941111-1.c b/gcc/testsuite/gcc.c-torture/compile/941111-1.c
new file mode 100644
index 00000000000..3f0c28bef12
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/941113-1.c b/gcc/testsuite/gcc.c-torture/compile/941113-1.c
new file mode 100644
index 00000000000..5c2e0b68c56
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950122-1.c b/gcc/testsuite/gcc.c-torture/compile/950122-1.c
new file mode 100644
index 00000000000..8dea7905093
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950124-1.c b/gcc/testsuite/gcc.c-torture/compile/950124-1.c
new file mode 100644
index 00000000000..e723954a0c1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950221-1.c b/gcc/testsuite/gcc.c-torture/compile/950221-1.c
new file mode 100644
index 00000000000..14147638668
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950329-1.c b/gcc/testsuite/gcc.c-torture/compile/950329-1.c
new file mode 100644
index 00000000000..7c047f5a59c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950512-1.c b/gcc/testsuite/gcc.c-torture/compile/950512-1.c
new file mode 100644
index 00000000000..e43ec48d165
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950530-1.c b/gcc/testsuite/gcc.c-torture/compile/950530-1.c
new file mode 100644
index 00000000000..2b714e059bc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950607-1.c b/gcc/testsuite/gcc.c-torture/compile/950607-1.c
new file mode 100644
index 00000000000..851defce34c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950610-1.c b/gcc/testsuite/gcc.c-torture/compile/950610-1.c
new file mode 100644
index 00000000000..16d0d0e60f5
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/950610-1.c
@@ -0,0 +1 @@
+f (int n, int a[2][n]) {}
diff --git a/gcc/testsuite/gcc.c-torture/compile/950612-1.c b/gcc/testsuite/gcc.c-torture/compile/950612-1.c
new file mode 100644
index 00000000000..cb3cb0a59d6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950613-1.c b/gcc/testsuite/gcc.c-torture/compile/950613-1.c
new file mode 100644
index 00000000000..8aa757f476c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950618-1.c b/gcc/testsuite/gcc.c-torture/compile/950618-1.c
new file mode 100644
index 00000000000..4229da4e9bf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950719-1.c b/gcc/testsuite/gcc.c-torture/compile/950719-1.c
new file mode 100644
index 00000000000..d3277fada4e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950729-1.c b/gcc/testsuite/gcc.c-torture/compile/950729-1.c
new file mode 100644
index 00000000000..cfdbad9206f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950816-1.c b/gcc/testsuite/gcc.c-torture/compile/950816-1.c
new file mode 100644
index 00000000000..da849bbad0a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950816-2.c b/gcc/testsuite/gcc.c-torture/compile/950816-2.c
new file mode 100644
index 00000000000..41e770d177d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950816-3.c b/gcc/testsuite/gcc.c-torture/compile/950816-3.c
new file mode 100644
index 00000000000..b3cb0fca377
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950910-1.c b/gcc/testsuite/gcc.c-torture/compile/950910-1.c
new file mode 100644
index 00000000000..1be2aa55e68
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950919-1.c b/gcc/testsuite/gcc.c-torture/compile/950919-1.c
new file mode 100644
index 00000000000..8320f6d025a
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/950919-1.c
@@ -0,0 +1,5 @@
+#define empty
+#if empty#cpu(m68k)
+#endif
+
+f (){}
diff --git a/gcc/testsuite/gcc.c-torture/compile/950921-1.c b/gcc/testsuite/gcc.c-torture/compile/950921-1.c
new file mode 100644
index 00000000000..371c7d569c5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/950922-1.c b/gcc/testsuite/gcc.c-torture/compile/950922-1.c
new file mode 100644
index 00000000000..73574f33e68
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/951004-1.c b/gcc/testsuite/gcc.c-torture/compile/951004-1.c
new file mode 100644
index 00000000000..1ca60819cdd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/951106-1.c b/gcc/testsuite/gcc.c-torture/compile/951106-1.c
new file mode 100644
index 00000000000..09cba20c1d0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/951116-1.c b/gcc/testsuite/gcc.c-torture/compile/951116-1.c
new file mode 100644
index 00000000000..100d6902a72
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/951128-1.c b/gcc/testsuite/gcc.c-torture/compile/951128-1.c
new file mode 100644
index 00000000000..5e4dc7093c8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/951220-1.c b/gcc/testsuite/gcc.c-torture/compile/951220-1.c
new file mode 100644
index 00000000000..33e98f6221e
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/951220-1.c
@@ -0,0 +1,4 @@
+f (char *x)
+{
+  return (*x & 2) || (*x & 3);
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/951222-1.c b/gcc/testsuite/gcc.c-torture/compile/951222-1.c
new file mode 100644
index 00000000000..b8246f5fe81
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960106-1.c b/gcc/testsuite/gcc.c-torture/compile/960106-1.c
new file mode 100644
index 00000000000..c8228aab587
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/960106-1.c
@@ -0,0 +1,4 @@
+f (a)
+{
+  return (a & 1) && !(a & 2 & 4);
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/960130-1.c b/gcc/testsuite/gcc.c-torture/compile/960130-1.c
new file mode 100644
index 00000000000..ed8dab45988
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960201-1.c b/gcc/testsuite/gcc.c-torture/compile/960201-1.c
new file mode 100644
index 00000000000..adc462389d2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960218-1.c b/gcc/testsuite/gcc.c-torture/compile/960218-1.c
new file mode 100644
index 00000000000..46fbf778524
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960220-1.c b/gcc/testsuite/gcc.c-torture/compile/960220-1.c
new file mode 100644
index 00000000000..766a066c449
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960221-1.c b/gcc/testsuite/gcc.c-torture/compile/960221-1.c
new file mode 100644
index 00000000000..0e02496c104
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960319-1.c b/gcc/testsuite/gcc.c-torture/compile/960319-1.c
new file mode 100644
index 00000000000..f3d95ab6e8e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960514-1.c b/gcc/testsuite/gcc.c-torture/compile/960514-1.c
new file mode 100644
index 00000000000..1d38cfd1a0b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960704-1.c b/gcc/testsuite/gcc.c-torture/compile/960704-1.c
new file mode 100644
index 00000000000..5a9d35cfd9a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/960829-1.c b/gcc/testsuite/gcc.c-torture/compile/960829-1.c
new file mode 100644
index 00000000000..8c6163dfaf0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961004-1.c b/gcc/testsuite/gcc.c-torture/compile/961004-1.c
new file mode 100644
index 00000000000..6407b625d66
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961010-1.c b/gcc/testsuite/gcc.c-torture/compile/961010-1.c
new file mode 100644
index 00000000000..d6145bc4233
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961019-1.c b/gcc/testsuite/gcc.c-torture/compile/961019-1.c
new file mode 100644
index 00000000000..0ea6ec6e280
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961031-1.c b/gcc/testsuite/gcc.c-torture/compile/961031-1.c
new file mode 100644
index 00000000000..ea8718f763b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961126-1.c b/gcc/testsuite/gcc.c-torture/compile/961126-1.c
new file mode 100644
index 00000000000..f3b6af55595
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/961203-1.c b/gcc/testsuite/gcc.c-torture/compile/961203-1.c
new file mode 100644
index 00000000000..0f066ace617
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/970206-1.c b/gcc/testsuite/gcc.c-torture/compile/970206-1.c
new file mode 100644
index 00000000000..95196cd6a54
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/970214-1.c b/gcc/testsuite/gcc.c-torture/compile/970214-1.c
new file mode 100644
index 00000000000..508ea9e92b6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/Makefile.in b/gcc/testsuite/gcc.c-torture/compile/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/calls.c b/gcc/testsuite/gcc.c-torture/compile/calls.c
new file mode 100644
index 00000000000..1582c0e92fa
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/cmpdi-1.c b/gcc/testsuite/gcc.c-torture/compile/cmpdi-1.c
new file mode 100644
index 00000000000..9e1b659c7cf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/combine-hang.c b/gcc/testsuite/gcc.c-torture/compile/combine-hang.c
new file mode 100644
index 00000000000..7cc57afe603
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/compile.exp b/gcc/testsuite/gcc.c-torture/compile/compile.exp
new file mode 100644
index 00000000000..f96f0231a6c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/configure.in b/gcc/testsuite/gcc.c-torture/compile/configure.in
new file mode 100644
index 00000000000..e4cc69d249e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/funcptr-1.c b/gcc/testsuite/gcc.c-torture/compile/funcptr-1.c
new file mode 100644
index 00000000000..79687c9c005
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/goto-1.c b/gcc/testsuite/gcc.c-torture/compile/goto-1.c
new file mode 100644
index 00000000000..caeed3aa0ba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/init-1.c b/gcc/testsuite/gcc.c-torture/compile/init-1.c
new file mode 100644
index 00000000000..38db9ad87d9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/init-2.c b/gcc/testsuite/gcc.c-torture/compile/init-2.c
new file mode 100644
index 00000000000..63a7f5849d6
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/init-2.c
@@ -0,0 +1,4 @@
+struct
+{
+  int e1, e2;
+} v = { e2: 0 };
diff --git a/gcc/testsuite/gcc.c-torture/compile/labels-1.c b/gcc/testsuite/gcc.c-torture/compile/labels-1.c
new file mode 100644
index 00000000000..fae6ab8f400
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/packed-1.c b/gcc/testsuite/gcc.c-torture/compile/packed-1.c
new file mode 100644
index 00000000000..709fc3cb102
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/compile/widechar-1.c b/gcc/testsuite/gcc.c-torture/compile/widechar-1.c
new file mode 100644
index 00000000000..5d89f33a864
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/widechar-1.c
@@ -0,0 +1 @@
+char *s = L"a" "b";
diff --git a/gcc/testsuite/gcc.c-torture/compile/zero-strct-1.c b/gcc/testsuite/gcc.c-torture/compile/zero-strct-1.c
new file mode 100644
index 00000000000..d3db812691b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/900409-1.c b/gcc/testsuite/gcc.c-torture/execute/900409-1.c
new file mode 100644
index 00000000000..3112effaf2f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920202-1.c b/gcc/testsuite/gcc.c-torture/execute/920202-1.c
new file mode 100644
index 00000000000..e30ce2fd5c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920302-1.c b/gcc/testsuite/gcc.c-torture/execute/920302-1.c
new file mode 100644
index 00000000000..5fbfd9d1b9c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920409-1.c b/gcc/testsuite/gcc.c-torture/execute/920409-1.c
new file mode 100644
index 00000000000..938ce7d92d6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920410-1.c b/gcc/testsuite/gcc.c-torture/execute/920410-1.c
new file mode 100644
index 00000000000..f5180f06a9c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920411-1.c b/gcc/testsuite/gcc.c-torture/execute/920411-1.c
new file mode 100644
index 00000000000..e3e98100108
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920415-1.c b/gcc/testsuite/gcc.c-torture/execute/920415-1.c
new file mode 100644
index 00000000000..25100ad5200
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920428-1.c b/gcc/testsuite/gcc.c-torture/execute/920428-1.c
new file mode 100644
index 00000000000..154af763a50
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920428-2.c b/gcc/testsuite/gcc.c-torture/execute/920428-2.c
new file mode 100644
index 00000000000..118ba968314
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920428-2.cexp b/gcc/testsuite/gcc.c-torture/execute/920428-2.cexp
new file mode 100644
index 00000000000..c7d9f030049
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/920428-2.cexp
@@ -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/testsuite/gcc.c-torture/execute/920429-1.c b/gcc/testsuite/gcc.c-torture/execute/920429-1.c
new file mode 100644
index 00000000000..f37bf68bdd4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-1.c b/gcc/testsuite/gcc.c-torture/execute/920501-1.c
new file mode 100644
index 00000000000..6f757cac59c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-2.c b/gcc/testsuite/gcc.c-torture/execute/920501-2.c
new file mode 100644
index 00000000000..d99eef289e5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-3.c b/gcc/testsuite/gcc.c-torture/execute/920501-3.c
new file mode 100644
index 00000000000..1031d7378cb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-4.c b/gcc/testsuite/gcc.c-torture/execute/920501-4.c
new file mode 100644
index 00000000000..b936c4984b6
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/920501-4.c
@@ -0,0 +1,6 @@
+#ifndef NO_LABEL_VALUES
+x(int i){static const 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/testsuite/gcc.c-torture/execute/920501-5.c b/gcc/testsuite/gcc.c-torture/execute/920501-5.c
new file mode 100644
index 00000000000..09740747712
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-6.c b/gcc/testsuite/gcc.c-torture/execute/920501-6.c
new file mode 100644
index 00000000000..cbb7b43243f
--- /dev/null
+++ b/gcc/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 = 1 << (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/testsuite/gcc.c-torture/execute/920501-7.c b/gcc/testsuite/gcc.c-torture/execute/920501-7.c
new file mode 100644
index 00000000000..f032bd8c690
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920501-7.cexp b/gcc/testsuite/gcc.c-torture/execute/920501-7.cexp
new file mode 100644
index 00000000000..c7d9f030049
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/920501-7.cexp
@@ -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/testsuite/gcc.c-torture/execute/920501-8.c b/gcc/testsuite/gcc.c-torture/execute/920501-8.c
new file mode 100644
index 00000000000..04f1e132f5b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/920501-8.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdarg.h>
+
+extern int	sprintf(char *, const char *, ...);
+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/testsuite/gcc.c-torture/execute/920501-9.c b/gcc/testsuite/gcc.c-torture/execute/920501-9.c
new file mode 100644
index 00000000000..f585ac6e0f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920506-1.c b/gcc/testsuite/gcc.c-torture/execute/920506-1.c
new file mode 100644
index 00000000000..9a646a30fc2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920520-1.c b/gcc/testsuite/gcc.c-torture/execute/920520-1.c
new file mode 100644
index 00000000000..068a12e9249
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920603-1.c b/gcc/testsuite/gcc.c-torture/execute/920603-1.c
new file mode 100644
index 00000000000..bd27ca6196e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920604-1.c b/gcc/testsuite/gcc.c-torture/execute/920604-1.c
new file mode 100644
index 00000000000..d7d9be13fd8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920612-1.c b/gcc/testsuite/gcc.c-torture/execute/920612-1.c
new file mode 100644
index 00000000000..a70c0d2e078
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920612-2.c b/gcc/testsuite/gcc.c-torture/execute/920612-2.c
new file mode 100644
index 00000000000..2667093491f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920618-1.c b/gcc/testsuite/gcc.c-torture/execute/920618-1.c
new file mode 100644
index 00000000000..224f7208953
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920625-1.c b/gcc/testsuite/gcc.c-torture/execute/920625-1.c
new file mode 100644
index 00000000000..ae2f415dec7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920710-1.c b/gcc/testsuite/gcc.c-torture/execute/920710-1.c
new file mode 100644
index 00000000000..7c6f871e2ac
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920711-1.c b/gcc/testsuite/gcc.c-torture/execute/920711-1.c
new file mode 100644
index 00000000000..aa83452dafe
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920715-1.c b/gcc/testsuite/gcc.c-torture/execute/920715-1.c
new file mode 100644
index 00000000000..8b0f54b081c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920715-1.cexp b/gcc/testsuite/gcc.c-torture/execute/920715-1.cexp
new file mode 100644
index 00000000000..28da30bbcd3
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/920715-1.cexp
@@ -0,0 +1,13 @@
+# This doesn't work on h8300s
+# It also doesn't work on d10v if doubles are not 64 bits
+
+if { [istarget "h8300*-*-*"] || [istarget "mn10200*-*-*"] } {
+	set torture_execute_xfail "h8300*-*-*"
+	set torture_execute_xfail "mn10200*-*-*"
+}
+
+if { [istarget "d10v-*-*"] && ! [string-match "*-mdouble64*" $CFLAGS] } {
+	set torture_execute_xfail "d10v-*-*"
+}
+
+return 0
diff --git a/gcc/testsuite/gcc.c-torture/execute/920721-1.c b/gcc/testsuite/gcc.c-torture/execute/920721-1.c
new file mode 100644
index 00000000000..086b5463f7f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920721-2.c b/gcc/testsuite/gcc.c-torture/execute/920721-2.c
new file mode 100644
index 00000000000..ed4e0bf8700
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920721-3.c b/gcc/testsuite/gcc.c-torture/execute/920721-3.c
new file mode 100644
index 00000000000..61f605d0ad9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920721-4.c b/gcc/testsuite/gcc.c-torture/execute/920721-4.c
new file mode 100644
index 00000000000..3cccc5b3024
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920726-1.c b/gcc/testsuite/gcc.c-torture/execute/920726-1.c
new file mode 100644
index 00000000000..d6042c9f5d1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920728-1.c b/gcc/testsuite/gcc.c-torture/execute/920728-1.c
new file mode 100644
index 00000000000..7a2968b71be
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920731-1.c b/gcc/testsuite/gcc.c-torture/execute/920731-1.c
new file mode 100644
index 00000000000..de0fb58fcde
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920810-1.c b/gcc/testsuite/gcc.c-torture/execute/920810-1.c
new file mode 100644
index 00000000000..9565bfc1a2b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920812-1.c b/gcc/testsuite/gcc.c-torture/execute/920812-1.c
new file mode 100644
index 00000000000..b49ab425b21
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920829-1.c b/gcc/testsuite/gcc.c-torture/execute/920829-1.c
new file mode 100644
index 00000000000..ed2c2271caa
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920908-1.c b/gcc/testsuite/gcc.c-torture/execute/920908-1.c
new file mode 100644
index 00000000000..98fbb5eaa6d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920908-2.c b/gcc/testsuite/gcc.c-torture/execute/920908-2.c
new file mode 100644
index 00000000000..66a6d86a7e7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920909-1.c b/gcc/testsuite/gcc.c-torture/execute/920909-1.c
new file mode 100644
index 00000000000..c8880348c12
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920922-1.c b/gcc/testsuite/gcc.c-torture/execute/920922-1.c
new file mode 100644
index 00000000000..4fae192bb90
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/920929-1.c b/gcc/testsuite/gcc.c-torture/execute/920929-1.c
new file mode 100644
index 00000000000..e43444e31d7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921006-1.c b/gcc/testsuite/gcc.c-torture/execute/921006-1.c
new file mode 100644
index 00000000000..50fbdb71125
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921007-1.c b/gcc/testsuite/gcc.c-torture/execute/921007-1.c
new file mode 100644
index 00000000000..ea036519463
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/921007-1.c
@@ -0,0 +1,7 @@
+int strcmp(){return-1;}
+#define strcmp __builtin_strcmp
+main()
+{
+if(strcmp("X","X\376")>=0)abort();
+exit(0);
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/921013-1.c b/gcc/testsuite/gcc.c-torture/execute/921013-1.c
new file mode 100644
index 00000000000..d041beb257a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921016-1.c b/gcc/testsuite/gcc.c-torture/execute/921016-1.c
new file mode 100644
index 00000000000..46f8a838765
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921017-1.c b/gcc/testsuite/gcc.c-torture/execute/921017-1.c
new file mode 100644
index 00000000000..3a0db5c4d56
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921019-1.c b/gcc/testsuite/gcc.c-torture/execute/921019-1.c
new file mode 100644
index 00000000000..f48613a8ba9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921019-2.c b/gcc/testsuite/gcc.c-torture/execute/921019-2.c
new file mode 100644
index 00000000000..9003e7b64d5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921029-1.c b/gcc/testsuite/gcc.c-torture/execute/921029-1.c
new file mode 100644
index 00000000000..76fc974c2f0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921104-1.c b/gcc/testsuite/gcc.c-torture/execute/921104-1.c
new file mode 100644
index 00000000000..4b6f4bcfb5b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921110-1.c b/gcc/testsuite/gcc.c-torture/execute/921110-1.c
new file mode 100644
index 00000000000..27ff96f18fb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921112-1.c b/gcc/testsuite/gcc.c-torture/execute/921112-1.c
new file mode 100644
index 00000000000..5946398e3c0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921113-1.c b/gcc/testsuite/gcc.c-torture/execute/921113-1.c
new file mode 100644
index 00000000000..78972bc975e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921117-1.c b/gcc/testsuite/gcc.c-torture/execute/921117-1.c
new file mode 100644
index 00000000000..2ed30fbeeef
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921123-1.c b/gcc/testsuite/gcc.c-torture/execute/921123-1.c
new file mode 100644
index 00000000000..d3daf120f0a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921123-2.c b/gcc/testsuite/gcc.c-torture/execute/921123-2.c
new file mode 100644
index 00000000000..3028717cf5a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921124-1.c b/gcc/testsuite/gcc.c-torture/execute/921124-1.c
new file mode 100644
index 00000000000..51b090b4de1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921202-1.c b/gcc/testsuite/gcc.c-torture/execute/921202-1.c
new file mode 100644
index 00000000000..d42fc74403c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921202-2.c b/gcc/testsuite/gcc.c-torture/execute/921202-2.c
new file mode 100644
index 00000000000..48d4a412d1b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921204-1.c b/gcc/testsuite/gcc.c-torture/execute/921204-1.c
new file mode 100644
index 00000000000..9e4f4a6bae7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921207-1.c b/gcc/testsuite/gcc.c-torture/execute/921207-1.c
new file mode 100644
index 00000000000..5ee9d27cc2f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921208-1.c b/gcc/testsuite/gcc.c-torture/execute/921208-1.c
new file mode 100644
index 00000000000..143ef63b0c9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921208-2.c b/gcc/testsuite/gcc.c-torture/execute/921208-2.c
new file mode 100644
index 00000000000..d5edcf97c66
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921215-1.c b/gcc/testsuite/gcc.c-torture/execute/921215-1.c
new file mode 100644
index 00000000000..4fa3b7dfccc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921218-1.c b/gcc/testsuite/gcc.c-torture/execute/921218-1.c
new file mode 100644
index 00000000000..ab7bc19cc15
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/921218-2.c b/gcc/testsuite/gcc.c-torture/execute/921218-2.c
new file mode 100644
index 00000000000..b5d57e9c3c8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930106-1.c b/gcc/testsuite/gcc.c-torture/execute/930106-1.c
new file mode 100644
index 00000000000..8081f926013
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930111-1.c b/gcc/testsuite/gcc.c-torture/execute/930111-1.c
new file mode 100644
index 00000000000..e908f14f67f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930123-1.c b/gcc/testsuite/gcc.c-torture/execute/930123-1.c
new file mode 100644
index 00000000000..7365bae5200
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930126-1.c b/gcc/testsuite/gcc.c-torture/execute/930126-1.c
new file mode 100644
index 00000000000..ff08e7d6131
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930208-1.c b/gcc/testsuite/gcc.c-torture/execute/930208-1.c
new file mode 100644
index 00000000000..464b69d437e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930406-1.c b/gcc/testsuite/gcc.c-torture/execute/930406-1.c
new file mode 100644
index 00000000000..1546f5150dd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930408-1.c b/gcc/testsuite/gcc.c-torture/execute/930408-1.c
new file mode 100644
index 00000000000..42ffc098f80
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930429-1.c b/gcc/testsuite/gcc.c-torture/execute/930429-1.c
new file mode 100644
index 00000000000..656d928ebd7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930429-2.c b/gcc/testsuite/gcc.c-torture/execute/930429-2.c
new file mode 100644
index 00000000000..e52c8b4d723
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930513-1.c b/gcc/testsuite/gcc.c-torture/execute/930513-1.c
new file mode 100644
index 00000000000..4544471ec7d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930513-2.c b/gcc/testsuite/gcc.c-torture/execute/930513-2.c
new file mode 100644
index 00000000000..3731f620497
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930518-1.c b/gcc/testsuite/gcc.c-torture/execute/930518-1.c
new file mode 100644
index 00000000000..44bdf96afb7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930526-1.c b/gcc/testsuite/gcc.c-torture/execute/930526-1.c
new file mode 100644
index 00000000000..bbf63c6009a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930527-1.c b/gcc/testsuite/gcc.c-torture/execute/930527-1.c
new file mode 100644
index 00000000000..fef34bf6b7f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930529-1.c b/gcc/testsuite/gcc.c-torture/execute/930529-1.c
new file mode 100644
index 00000000000..906338e6e9a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930603-1.c b/gcc/testsuite/gcc.c-torture/execute/930603-1.c
new file mode 100644
index 00000000000..6a84de03562
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930603-2.c b/gcc/testsuite/gcc.c-torture/execute/930603-2.c
new file mode 100644
index 00000000000..8cf06a21139
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930603-3.c b/gcc/testsuite/gcc.c-torture/execute/930603-3.c
new file mode 100644
index 00000000000..22e5aed4a8b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930608-1.c b/gcc/testsuite/gcc.c-torture/execute/930608-1.c
new file mode 100644
index 00000000000..004a4400709
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930614-1.c b/gcc/testsuite/gcc.c-torture/execute/930614-1.c
new file mode 100644
index 00000000000..7b206344b3a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930614-2.c b/gcc/testsuite/gcc.c-torture/execute/930614-2.c
new file mode 100644
index 00000000000..ab83a7e3bb9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930621-1.c b/gcc/testsuite/gcc.c-torture/execute/930621-1.c
new file mode 100644
index 00000000000..6131301df2f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930622-1.c b/gcc/testsuite/gcc.c-torture/execute/930622-1.c
new file mode 100644
index 00000000000..d733e133d35
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930622-2.c b/gcc/testsuite/gcc.c-torture/execute/930622-2.c
new file mode 100644
index 00000000000..d049b002a19
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930628-1.c b/gcc/testsuite/gcc.c-torture/execute/930628-1.c
new file mode 100644
index 00000000000..58c612d1a1c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930630-1.c b/gcc/testsuite/gcc.c-torture/execute/930630-1.c
new file mode 100644
index 00000000000..4befa835d0d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930702-1.c b/gcc/testsuite/gcc.c-torture/execute/930702-1.c
new file mode 100644
index 00000000000..8828a701cb9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930713-1.c b/gcc/testsuite/gcc.c-torture/execute/930713-1.c
new file mode 100644
index 00000000000..6b4d5ab796a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930718-1.c b/gcc/testsuite/gcc.c-torture/execute/930718-1.c
new file mode 100644
index 00000000000..a8eacc2d222
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930719-1.c b/gcc/testsuite/gcc.c-torture/execute/930719-1.c
new file mode 100644
index 00000000000..c6557efc735
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930725-1.c b/gcc/testsuite/gcc.c-torture/execute/930725-1.c
new file mode 100644
index 00000000000..3bd738ca08a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930818-1.c b/gcc/testsuite/gcc.c-torture/execute/930818-1.c
new file mode 100644
index 00000000000..710e3ce2fbe
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930916-1.c b/gcc/testsuite/gcc.c-torture/execute/930916-1.c
new file mode 100644
index 00000000000..6302614a8c8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930921-1.c b/gcc/testsuite/gcc.c-torture/execute/930921-1.c
new file mode 100644
index 00000000000..12e04e30954
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930929-1.c b/gcc/testsuite/gcc.c-torture/execute/930929-1.c
new file mode 100644
index 00000000000..31f695442f5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930930-1.c b/gcc/testsuite/gcc.c-torture/execute/930930-1.c
new file mode 100644
index 00000000000..68fdbbfe851
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/930930-2.c b/gcc/testsuite/gcc.c-torture/execute/930930-2.c
new file mode 100644
index 00000000000..eb34d11fe22
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931002-1.c b/gcc/testsuite/gcc.c-torture/execute/931002-1.c
new file mode 100644
index 00000000000..6a02b234394
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-1.c b/gcc/testsuite/gcc.c-torture/execute/931004-1.c
new file mode 100644
index 00000000000..9c89afdae35
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-10.c b/gcc/testsuite/gcc.c-torture/execute/931004-10.c
new file mode 100644
index 00000000000..cf0125dba62
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-11.c b/gcc/testsuite/gcc.c-torture/execute/931004-11.c
new file mode 100644
index 00000000000..b6047025ce9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-12.c b/gcc/testsuite/gcc.c-torture/execute/931004-12.c
new file mode 100644
index 00000000000..d3fc71e0cb0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-13.c b/gcc/testsuite/gcc.c-torture/execute/931004-13.c
new file mode 100644
index 00000000000..60422af8eb7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-14.c b/gcc/testsuite/gcc.c-torture/execute/931004-14.c
new file mode 100644
index 00000000000..55c71bbc42a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-2.c b/gcc/testsuite/gcc.c-torture/execute/931004-2.c
new file mode 100644
index 00000000000..83bdea67b0c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-3.c b/gcc/testsuite/gcc.c-torture/execute/931004-3.c
new file mode 100644
index 00000000000..1e7a0fdcd53
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-4.c b/gcc/testsuite/gcc.c-torture/execute/931004-4.c
new file mode 100644
index 00000000000..f0d2331e5cc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-5.c b/gcc/testsuite/gcc.c-torture/execute/931004-5.c
new file mode 100644
index 00000000000..9bef779e6ed
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-6.c b/gcc/testsuite/gcc.c-torture/execute/931004-6.c
new file mode 100644
index 00000000000..6dca48f38ef
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-7.c b/gcc/testsuite/gcc.c-torture/execute/931004-7.c
new file mode 100644
index 00000000000..8ab2fcb2ab2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-8.c b/gcc/testsuite/gcc.c-torture/execute/931004-8.c
new file mode 100644
index 00000000000..5fb97f64a6b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931004-9.c b/gcc/testsuite/gcc.c-torture/execute/931004-9.c
new file mode 100644
index 00000000000..07247f7adfa
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931005-1.c b/gcc/testsuite/gcc.c-torture/execute/931005-1.c
new file mode 100644
index 00000000000..5a7e031cbfe
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931009-1.c b/gcc/testsuite/gcc.c-torture/execute/931009-1.c
new file mode 100644
index 00000000000..292228014e7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931012-1.c b/gcc/testsuite/gcc.c-torture/execute/931012-1.c
new file mode 100644
index 00000000000..d9c958ddb90
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931017-1.c b/gcc/testsuite/gcc.c-torture/execute/931017-1.c
new file mode 100644
index 00000000000..5917bd95b76
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931018-1.c b/gcc/testsuite/gcc.c-torture/execute/931018-1.c
new file mode 100644
index 00000000000..d3814e699b8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931031-1.c b/gcc/testsuite/gcc.c-torture/execute/931031-1.c
new file mode 100644
index 00000000000..761989040f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931102-1.c b/gcc/testsuite/gcc.c-torture/execute/931102-1.c
new file mode 100644
index 00000000000..489e7ebda8d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931102-2.c b/gcc/testsuite/gcc.c-torture/execute/931102-2.c
new file mode 100644
index 00000000000..6fc735c8bc1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931110-1.c b/gcc/testsuite/gcc.c-torture/execute/931110-1.c
new file mode 100644
index 00000000000..5b33b269a2d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931110-2.c b/gcc/testsuite/gcc.c-torture/execute/931110-2.c
new file mode 100644
index 00000000000..586615b180c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931208-1.c b/gcc/testsuite/gcc.c-torture/execute/931208-1.c
new file mode 100644
index 00000000000..ee2bc9f1e04
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/931228-1.c b/gcc/testsuite/gcc.c-torture/execute/931228-1.c
new file mode 100644
index 00000000000..dcd3b65ff3b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/940115-1.c b/gcc/testsuite/gcc.c-torture/execute/940115-1.c
new file mode 100644
index 00000000000..d0fac9077a1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/940122-1.c b/gcc/testsuite/gcc.c-torture/execute/940122-1.c
new file mode 100644
index 00000000000..9dbf6ae185b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941014-1.c b/gcc/testsuite/gcc.c-torture/execute/941014-1.c
new file mode 100644
index 00000000000..98db917428f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941014-2.c b/gcc/testsuite/gcc.c-torture/execute/941014-2.c
new file mode 100644
index 00000000000..3932a34ce92
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941015-1.c b/gcc/testsuite/gcc.c-torture/execute/941015-1.c
new file mode 100644
index 00000000000..38d4796645f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941021-1.c b/gcc/testsuite/gcc.c-torture/execute/941021-1.c
new file mode 100644
index 00000000000..9fc1cfadf97
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941025-1.c b/gcc/testsuite/gcc.c-torture/execute/941025-1.c
new file mode 100644
index 00000000000..2daf0ad25cc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941031-1.c b/gcc/testsuite/gcc.c-torture/execute/941031-1.c
new file mode 100644
index 00000000000..134f966c6f3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941101-1.c b/gcc/testsuite/gcc.c-torture/execute/941101-1.c
new file mode 100644
index 00000000000..66b5f384a80
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941110-1.c b/gcc/testsuite/gcc.c-torture/execute/941110-1.c
new file mode 100644
index 00000000000..b78256d3c3f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/941202-1.c b/gcc/testsuite/gcc.c-torture/execute/941202-1.c
new file mode 100644
index 00000000000..72d0b33e924
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950221-1.c b/gcc/testsuite/gcc.c-torture/execute/950221-1.c
new file mode 100644
index 00000000000..d45fb5aeef0
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/950221-1.c
@@ -0,0 +1,51 @@
+struct parsefile
+{
+  long fd;
+  char *buf;
+};
+struct parsefile basepf;
+struct parsefile *parsefile = &basepf;
+int filler[0x3000];
+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/testsuite/gcc.c-torture/execute/950322-1.c b/gcc/testsuite/gcc.c-torture/execute/950322-1.c
new file mode 100644
index 00000000000..28a1469fea0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950426-1.c b/gcc/testsuite/gcc.c-torture/execute/950426-1.c
new file mode 100644
index 00000000000..076032c7220
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950426-2.c b/gcc/testsuite/gcc.c-torture/execute/950426-2.c
new file mode 100644
index 00000000000..a1a690469d1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950503-1.c b/gcc/testsuite/gcc.c-torture/execute/950503-1.c
new file mode 100644
index 00000000000..1c95b369c50
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950511-1.c b/gcc/testsuite/gcc.c-torture/execute/950511-1.c
new file mode 100644
index 00000000000..6584b0c86b6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950512-1.c b/gcc/testsuite/gcc.c-torture/execute/950512-1.c
new file mode 100644
index 00000000000..8aa116d27ca
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950605-1.c b/gcc/testsuite/gcc.c-torture/execute/950605-1.c
new file mode 100644
index 00000000000..d89a42e49c6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950607-1.c b/gcc/testsuite/gcc.c-torture/execute/950607-1.c
new file mode 100644
index 00000000000..7b1503ad11d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950607-2.c b/gcc/testsuite/gcc.c-torture/execute/950607-2.c
new file mode 100644
index 00000000000..da18f7373f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950612-1.c b/gcc/testsuite/gcc.c-torture/execute/950612-1.c
new file mode 100644
index 00000000000..f9885279c33
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950621-1.c b/gcc/testsuite/gcc.c-torture/execute/950621-1.c
new file mode 100644
index 00000000000..5fc5a902874
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950628-1.c b/gcc/testsuite/gcc.c-torture/execute/950628-1.c
new file mode 100644
index 00000000000..e330ff56971
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950704-1.c b/gcc/testsuite/gcc.c-torture/execute/950704-1.c
new file mode 100644
index 00000000000..f11aff8cabc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950706-1.c b/gcc/testsuite/gcc.c-torture/execute/950706-1.c
new file mode 100644
index 00000000000..2db1915411c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950710-1.c b/gcc/testsuite/gcc.c-torture/execute/950710-1.c
new file mode 100644
index 00000000000..26ff9b2a8a0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950714-1.c b/gcc/testsuite/gcc.c-torture/execute/950714-1.c
new file mode 100644
index 00000000000..5dc44a906e2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950809-1.c b/gcc/testsuite/gcc.c-torture/execute/950809-1.c
new file mode 100644
index 00000000000..a33d42bd7cd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950906-1.c b/gcc/testsuite/gcc.c-torture/execute/950906-1.c
new file mode 100644
index 00000000000..31997d5c257
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950915-1.c b/gcc/testsuite/gcc.c-torture/execute/950915-1.c
new file mode 100644
index 00000000000..cfa044757b8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/950929-1.c b/gcc/testsuite/gcc.c-torture/execute/950929-1.c
new file mode 100644
index 00000000000..a35cd6a153e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/951003-1.c b/gcc/testsuite/gcc.c-torture/execute/951003-1.c
new file mode 100644
index 00000000000..269bf135386
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/951115-1.c b/gcc/testsuite/gcc.c-torture/execute/951115-1.c
new file mode 100644
index 00000000000..03520c99ca2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/951204-1.c b/gcc/testsuite/gcc.c-torture/execute/951204-1.c
new file mode 100644
index 00000000000..c4d585b6b9e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960116-1.c b/gcc/testsuite/gcc.c-torture/execute/960116-1.c
new file mode 100644
index 00000000000..6d7624ca1a1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960117-1.c b/gcc/testsuite/gcc.c-torture/execute/960117-1.c
new file mode 100644
index 00000000000..741455b08b9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960209-1.c b/gcc/testsuite/gcc.c-torture/execute/960209-1.c
new file mode 100644
index 00000000000..decd2af2aab
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960215-1.c b/gcc/testsuite/gcc.c-torture/execute/960215-1.c
new file mode 100644
index 00000000000..9502b4b2de4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960218-1.c b/gcc/testsuite/gcc.c-torture/execute/960218-1.c
new file mode 100644
index 00000000000..7301a17b00d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960219-1.c b/gcc/testsuite/gcc.c-torture/execute/960219-1.c
new file mode 100644
index 00000000000..d21bcfcad24
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960301-1.c b/gcc/testsuite/gcc.c-torture/execute/960301-1.c
new file mode 100644
index 00000000000..d75efea9844
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960302-1.c b/gcc/testsuite/gcc.c-torture/execute/960302-1.c
new file mode 100644
index 00000000000..7a9426a4635
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960311-1.c b/gcc/testsuite/gcc.c-torture/execute/960311-1.c
new file mode 100644
index 00000000000..16579d0bbd1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960311-2.c b/gcc/testsuite/gcc.c-torture/execute/960311-2.c
new file mode 100644
index 00000000000..d5c2d07a336
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960311-3.c b/gcc/testsuite/gcc.c-torture/execute/960311-3.c
new file mode 100644
index 00000000000..755fc723f85
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960312-1.c b/gcc/testsuite/gcc.c-torture/execute/960312-1.c
new file mode 100644
index 00000000000..94e67df23bd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960317-1.c b/gcc/testsuite/gcc.c-torture/execute/960317-1.c
new file mode 100644
index 00000000000..8d7907d751c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960321-1.c b/gcc/testsuite/gcc.c-torture/execute/960321-1.c
new file mode 100644
index 00000000000..eafe48ff753
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960326-1.c b/gcc/testsuite/gcc.c-torture/execute/960326-1.c
new file mode 100644
index 00000000000..f2013737022
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960327-1.c b/gcc/testsuite/gcc.c-torture/execute/960327-1.c
new file mode 100644
index 00000000000..d630a7b572c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960402-1.c b/gcc/testsuite/gcc.c-torture/execute/960402-1.c
new file mode 100644
index 00000000000..601a9a3b091
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960405-1.c b/gcc/testsuite/gcc.c-torture/execute/960405-1.c
new file mode 100644
index 00000000000..d8480cc2c05
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960416-1.c b/gcc/testsuite/gcc.c-torture/execute/960416-1.c
new file mode 100644
index 00000000000..f7cb056802c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960419-1.c b/gcc/testsuite/gcc.c-torture/execute/960419-1.c
new file mode 100644
index 00000000000..68bd2b97dd1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960419-2.c b/gcc/testsuite/gcc.c-torture/execute/960419-2.c
new file mode 100644
index 00000000000..c9526dcd779
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960512-1.c b/gcc/testsuite/gcc.c-torture/execute/960512-1.c
new file mode 100644
index 00000000000..a7c1d5fb47c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960513-1.c b/gcc/testsuite/gcc.c-torture/execute/960513-1.c
new file mode 100644
index 00000000000..acc263ca6c8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960521-1.c b/gcc/testsuite/gcc.c-torture/execute/960521-1.c
new file mode 100644
index 00000000000..9fc5821495a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960608-1.c b/gcc/testsuite/gcc.c-torture/execute/960608-1.c
new file mode 100644
index 00000000000..1f47d02d9d5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960801-1.c b/gcc/testsuite/gcc.c-torture/execute/960801-1.c
new file mode 100644
index 00000000000..1707269189a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960802-1.c b/gcc/testsuite/gcc.c-torture/execute/960802-1.c
new file mode 100644
index 00000000000..f9ee75260be
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960830-1.c b/gcc/testsuite/gcc.c-torture/execute/960830-1.c
new file mode 100644
index 00000000000..d87b39e2da3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/960909-1.c b/gcc/testsuite/gcc.c-torture/execute/960909-1.c
new file mode 100644
index 00000000000..de1ed933978
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961004-1.c b/gcc/testsuite/gcc.c-torture/execute/961004-1.c
new file mode 100644
index 00000000000..7ebba2d7b1e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961017-1.c b/gcc/testsuite/gcc.c-torture/execute/961017-1.c
new file mode 100644
index 00000000000..88c9d9505a1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961017-2.c b/gcc/testsuite/gcc.c-torture/execute/961017-2.c
new file mode 100644
index 00000000000..768ddbc6e74
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961026-1.c b/gcc/testsuite/gcc.c-torture/execute/961026-1.c
new file mode 100644
index 00000000000..942a6eb131a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961112-1.c b/gcc/testsuite/gcc.c-torture/execute/961112-1.c
new file mode 100644
index 00000000000..4b1c31222ca
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961122-1.c b/gcc/testsuite/gcc.c-torture/execute/961122-1.c
new file mode 100644
index 00000000000..1f0a63463e1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961122-2.c b/gcc/testsuite/gcc.c-torture/execute/961122-2.c
new file mode 100644
index 00000000000..81e404ec4f1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961125-1.c b/gcc/testsuite/gcc.c-torture/execute/961125-1.c
new file mode 100644
index 00000000000..7fe3dd45422
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961206-1.c b/gcc/testsuite/gcc.c-torture/execute/961206-1.c
new file mode 100644
index 00000000000..943ac66804d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961213-1.c b/gcc/testsuite/gcc.c-torture/execute/961213-1.c
new file mode 100644
index 00000000000..12bb27f3145
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/961223-1.c b/gcc/testsuite/gcc.c-torture/execute/961223-1.c
new file mode 100644
index 00000000000..9bc6cfa354d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/970214-1.c b/gcc/testsuite/gcc.c-torture/execute/970214-1.c
new file mode 100644
index 00000000000..4a06dfebc8d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/970214-2.c b/gcc/testsuite/gcc.c-torture/execute/970214-2.c
new file mode 100644
index 00000000000..cb9007625dd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/970217-1.c b/gcc/testsuite/gcc.c-torture/execute/970217-1.c
new file mode 100644
index 00000000000..09e716a330b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/970312-1.c b/gcc/testsuite/gcc.c-torture/execute/970312-1.c
new file mode 100644
index 00000000000..b303c4a8e60
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/970312-1.c
@@ -0,0 +1,71 @@
+#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++;
+}
+
+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);
+
+  printf ("%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/testsuite/gcc.c-torture/execute/Makefile.in b/gcc/testsuite/gcc.c-torture/execute/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/arith-1.c b/gcc/testsuite/gcc.c-torture/execute/arith-1.c
new file mode 100644
index 00000000000..58df322e68a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/arith-rand.c b/gcc/testsuite/gcc.c-torture/execute/arith-rand.c
new file mode 100644
index 00000000000..4af146a1a56
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/bf-layout-1.c b/gcc/testsuite/gcc.c-torture/execute/bf-layout-1.c
new file mode 100644
index 00000000000..a82429ba208
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/bf-pack-1.c b/gcc/testsuite/gcc.c-torture/execute/bf-pack-1.c
new file mode 100644
index 00000000000..ca3b1db763b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/bf-sign-1.c b/gcc/testsuite/gcc.c-torture/execute/bf-sign-1.c
new file mode 100644
index 00000000000..3cc3eac15fd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/bf-sign-2.c b/gcc/testsuite/gcc.c-torture/execute/bf-sign-2.c
new file mode 100644
index 00000000000..479082217eb
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/bf-sign-2.c
@@ -0,0 +1,52 @@
+/* 
+ 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 arithmatic.
+ */
+
+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;
+};
+
+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.u31 - 2) >= 0)		/* promoted value should be signed */
+    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/testsuite/gcc.c-torture/execute/bf64-1.c b/gcc/testsuite/gcc.c-torture/execute/bf64-1.c
new file mode 100644
index 00000000000..60028fb1aa8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/cbrt.c b/gcc/testsuite/gcc.c-torture/execute/cbrt.c
new file mode 100644
index 00000000000..8f1fe68df1d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/cbrt.c
@@ -0,0 +1,91 @@
+/*
+ * ====================================================
+ * 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;
+  union {
+    double t;
+    unsigned long 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/testsuite/gcc.c-torture/execute/cmpdi-1.c b/gcc/testsuite/gcc.c-torture/execute/cmpdi-1.c
new file mode 100644
index 00000000000..e3e9c860603
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/cmpsi-1.c b/gcc/testsuite/gcc.c-torture/execute/cmpsi-1.c
new file mode 100644
index 00000000000..9fce104fefb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/comp-goto-1.c b/gcc/testsuite/gcc.c-torture/execute/comp-goto-1.c
new file mode 100644
index 00000000000..04c7503115d
--- /dev/null
+++ b/gcc/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 ();
+
+void
+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/testsuite/gcc.c-torture/execute/complex-1.c b/gcc/testsuite/gcc.c-torture/execute/complex-1.c
new file mode 100644
index 00000000000..424fa65b150
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/complex-2.c b/gcc/testsuite/gcc.c-torture/execute/complex-2.c
new file mode 100644
index 00000000000..9634c7943f3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/complex-3.c b/gcc/testsuite/gcc.c-torture/execute/complex-3.c
new file mode 100644
index 00000000000..4297cf11ebd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/complex-4.c b/gcc/testsuite/gcc.c-torture/execute/complex-4.c
new file mode 100644
index 00000000000..1c458d21fba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/complex-5.c b/gcc/testsuite/gcc.c-torture/execute/complex-5.c
new file mode 100644
index 00000000000..a3338082c46
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/compndlit-1.c b/gcc/testsuite/gcc.c-torture/execute/compndlit-1.c
new file mode 100644
index 00000000000..4a8488d0ab4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/configure.in b/gcc/testsuite/gcc.c-torture/execute/configure.in
new file mode 100644
index 00000000000..7d7078dbfd2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/conversion.c b/gcc/testsuite/gcc.c-torture/execute/conversion.c
new file mode 100644
index 00000000000..5f358727d8f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/conversion.c
@@ -0,0 +1,364 @@
+/* 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();
+
+  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();
+
+
+  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();
+
+  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();
+}
+
+#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/testsuite/gcc.c-torture/execute/cvt-1.c b/gcc/testsuite/gcc.c-torture/execute/cvt-1.c
new file mode 100644
index 00000000000..d7c2b33fde1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/cvt-1.cexp b/gcc/testsuite/gcc.c-torture/execute/cvt-1.cexp
new file mode 100644
index 00000000000..997c8650c00
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/cvt-1.cexp
@@ -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/testsuite/gcc.c-torture/execute/dbra-1.c b/gcc/testsuite/gcc.c-torture/execute/dbra-1.c
new file mode 100644
index 00000000000..20ae8988ec8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/divconst-1.c b/gcc/testsuite/gcc.c-torture/execute/divconst-1.c
new file mode 100644
index 00000000000..ce9dd60a8e8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/divconst-2.c b/gcc/testsuite/gcc.c-torture/execute/divconst-2.c
new file mode 100644
index 00000000000..d3adaf3a0af
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/divconst-3.c b/gcc/testsuite/gcc.c-torture/execute/divconst-3.c
new file mode 100644
index 00000000000..ddd687cbcfd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/divmod-1.c b/gcc/testsuite/gcc.c-torture/execute/divmod-1.c
new file mode 100644
index 00000000000..ade019c884e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/enum-1.c b/gcc/testsuite/gcc.c-torture/execute/enum-1.c
new file mode 100644
index 00000000000..381e354918c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/execute.exp b/gcc/testsuite/gcc.c-torture/execute/execute.exp
new file mode 100644
index 00000000000..8c896cb3e15
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/func-ptr-1.c b/gcc/testsuite/gcc.c-torture/execute/func-ptr-1.c
new file mode 100644
index 00000000000..55f0e10660f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/gofast.c b/gcc/testsuite/gcc.c-torture/execute/gofast.c
new file mode 100644
index 00000000000..f55ced22073
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/920518-1.c b/gcc/testsuite/gcc.c-torture/execute/ieee/920518-1.c
new file mode 100644
index 00000000000..7f072b2981a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/920810-1.c b/gcc/testsuite/gcc.c-torture/execute/ieee/920810-1.c
new file mode 100644
index 00000000000..62d22940adc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/930529-1.c b/gcc/testsuite/gcc.c-torture/execute/ieee/930529-1.c
new file mode 100644
index 00000000000..0b5eda4ac9a
--- /dev/null
+++ b/gcc/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);
+#ifdef __arm__
+      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/testsuite/gcc.c-torture/execute/ieee/Makefile.in b/gcc/testsuite/gcc.c-torture/execute/ieee/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/configure.in b/gcc/testsuite/gcc.c-torture/execute/ieee/configure.in
new file mode 100644
index 00000000000..7d7078dbfd2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c
new file mode 100644
index 00000000000..3c3ccb65c09
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-1.c
@@ -0,0 +1,40 @@
+#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)
+  /* NaN is an IEEE unordered operand.  All these test should be false.  */
+  if (nan == nan)
+    abort ();
+  if (nan != x)
+    x = 1.0;
+  else
+    abort ();
+
+#ifndef SIGNAL_SUPPRESS
+  /* Some machines catches a SIGFPE when a NaN is compared.
+     Let this test succeed o such machines.  */
+  signal (SIGFPE, leave);
+#endif
+
+  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/testsuite/gcc.c-torture/execute/ieee/ieee.exp b/gcc/testsuite/gcc.c-torture/execute/ieee/ieee.exp
new file mode 100644
index 00000000000..795dbf167c9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/ieee/ieee.exp
@@ -0,0 +1,51 @@
+#
+# 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
+}
+
+# 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
+}
+
+# All done.
+gcc_finish
diff --git a/gcc/testsuite/gcc.c-torture/execute/ieee/minuszero.c b/gcc/testsuite/gcc.c-torture/execute/ieee/minuszero.c
new file mode 100644
index 00000000000..85715261d61
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/rbug.c b/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.c
new file mode 100644
index 00000000000..a91a99e92e2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ieee/rbug.cexp b/gcc/testsuite/gcc.c-torture/execute/ieee/rbug.cexp
new file mode 100644
index 00000000000..0ae0a35d315
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/index-1.c b/gcc/testsuite/gcc.c-torture/execute/index-1.c
new file mode 100644
index 00000000000..b00090d834a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/inst-check.c b/gcc/testsuite/gcc.c-torture/execute/inst-check.c
new file mode 100644
index 00000000000..ff4b00d7868
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/int-compare.c b/gcc/testsuite/gcc.c-torture/execute/int-compare.c
new file mode 100644
index 00000000000..017a8cc3f15
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-1.c b/gcc/testsuite/gcc.c-torture/execute/loop-1.c
new file mode 100644
index 00000000000..81aeeb6b392
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2.c b/gcc/testsuite/gcc.c-torture/execute/loop-2.c
new file mode 100644
index 00000000000..3227734fbf8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2b.c b/gcc/testsuite/gcc.c-torture/execute/loop-2b.c
new file mode 100644
index 00000000000..7f67bcd639d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2c.c b/gcc/testsuite/gcc.c-torture/execute/loop-2c.c
new file mode 100644
index 00000000000..9facf3bfd92
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2d.c b/gcc/testsuite/gcc.c-torture/execute/loop-2d.c
new file mode 100644
index 00000000000..19272bf0183
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2e.c b/gcc/testsuite/gcc.c-torture/execute/loop-2e.c
new file mode 100644
index 00000000000..b6ee6501501
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-2f.c b/gcc/testsuite/gcc.c-torture/execute/loop-2f.c
new file mode 100644
index 00000000000..9f544b9fcbd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-3.c b/gcc/testsuite/gcc.c-torture/execute/loop-3.c
new file mode 100644
index 00000000000..e314a01b1f1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-3b.c b/gcc/testsuite/gcc.c-torture/execute/loop-3b.c
new file mode 100644
index 00000000000..3de322cf146
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/loop-3c.c b/gcc/testsuite/gcc.c-torture/execute/loop-3c.c
new file mode 100644
index 00000000000..bc74c2e6d9b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/memcpy-1.c b/gcc/testsuite/gcc.c-torture/execute/memcpy-1.c
new file mode 100644
index 00000000000..684854b66dc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/mod-1.c b/gcc/testsuite/gcc.c-torture/execute/mod-1.c
new file mode 100644
index 00000000000..b460df5cdb1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/nest-stdar-1.c b/gcc/testsuite/gcc.c-torture/execute/nest-stdar-1.c
new file mode 100644
index 00000000000..2c6108b52e6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/nestfunc-1.c b/gcc/testsuite/gcc.c-torture/execute/nestfunc-1.c
new file mode 100644
index 00000000000..e34a56b3f57
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/packed-1.c b/gcc/testsuite/gcc.c-torture/execute/packed-1.c
new file mode 100644
index 00000000000..9b226aeab9b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/pending-4.c b/gcc/testsuite/gcc.c-torture/execute/pending-4.c
new file mode 100644
index 00000000000..8000621e6b6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/ptr-arith-1.c b/gcc/testsuite/gcc.c-torture/execute/ptr-arith-1.c
new file mode 100644
index 00000000000..46162b8964d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/regstack-1.c b/gcc/testsuite/gcc.c-torture/execute/regstack-1.c
new file mode 100644
index 00000000000..51fb858cf92
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/scope-1.c b/gcc/testsuite/gcc.c-torture/execute/scope-1.c
new file mode 100644
index 00000000000..cedd0b48ccb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/scope-2.c b/gcc/testsuite/gcc.c-torture/execute/scope-2.c
new file mode 100644
index 00000000000..c9a4775f6f5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/strct-pack-1.c b/gcc/testsuite/gcc.c-torture/execute/strct-pack-1.c
new file mode 100644
index 00000000000..7b702f2cd68
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/strct-pack-2.c b/gcc/testsuite/gcc.c-torture/execute/strct-pack-2.c
new file mode 100644
index 00000000000..be76c764521
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/strct-pack-3.c b/gcc/testsuite/gcc.c-torture/execute/strct-pack-3.c
new file mode 100644
index 00000000000..8f91b040ca8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/strct-pack-4.c b/gcc/testsuite/gcc.c-torture/execute/strct-pack-4.c
new file mode 100644
index 00000000000..56d315f47ff
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/strct-varg-1.c b/gcc/testsuite/gcc.c-torture/execute/strct-varg-1.c
new file mode 100644
index 00000000000..f76bb368409
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ini-1.c b/gcc/testsuite/gcc.c-torture/execute/struct-ini-1.c
new file mode 100644
index 00000000000..ab2d178a751
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ini-2.c b/gcc/testsuite/gcc.c-torture/execute/struct-ini-2.c
new file mode 100644
index 00000000000..c785257ccba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ini-3.c b/gcc/testsuite/gcc.c-torture/execute/struct-ini-3.c
new file mode 100644
index 00000000000..7d282ecb8af
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ini-4.c b/gcc/testsuite/gcc.c-torture/execute/struct-ini-4.c
new file mode 100644
index 00000000000..3342439e54d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ret-1.c b/gcc/testsuite/gcc.c-torture/execute/struct-ret-1.c
new file mode 100644
index 00000000000..e5274ec4c15
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/struct-ret-2.c b/gcc/testsuite/gcc.c-torture/execute/struct-ret-2.c
new file mode 100644
index 00000000000..06a40a72099
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/tstdi-1.c b/gcc/testsuite/gcc.c-torture/execute/tstdi-1.c
new file mode 100644
index 00000000000..3e31fdf5934
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-1.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-1.c
new file mode 100644
index 00000000000..3f3b141a931
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-2.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-2.c
new file mode 100644
index 00000000000..7675b3f7603
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-3.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-3.c
new file mode 100644
index 00000000000..7b0a0b0cf36
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-4.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-4.c
new file mode 100644
index 00000000000..a824f64ffa1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-5.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-5.c
new file mode 100644
index 00000000000..3d8b1a79ad1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/va-arg-6.c b/gcc/testsuite/gcc.c-torture/execute/va-arg-6.c
new file mode 100644
index 00000000000..e8d495d66e7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/execute/widechar-1.c b/gcc/testsuite/gcc.c-torture/execute/widechar-1.c
new file mode 100644
index 00000000000..45b9d89b4b4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/920507-1.c b/gcc/testsuite/gcc.c-torture/noncompile/920507-1.c
new file mode 100644
index 00000000000..e1bd9934de3
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/920507-1.c
@@ -0,0 +1 @@
+x(){register*a asm("fr1");int*v[1]={a};}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/920616-2.c b/gcc/testsuite/gcc.c-torture/noncompile/920616-2.c
new file mode 100644
index 00000000000..ddfa0de1ba1
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/920616-2.c
@@ -0,0 +1 @@
+f(void a,...){}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/920721-2.c b/gcc/testsuite/gcc.c-torture/noncompile/920721-2.c
new file mode 100644
index 00000000000..4621983e037
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/920824-1.c b/gcc/testsuite/gcc.c-torture/noncompile/920824-1.c
new file mode 100644
index 00000000000..36661f63c17
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/920824-1.c
@@ -0,0 +1 @@
+struct s{struct s{int i;}x;};
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/920923-1.c b/gcc/testsuite/gcc.c-torture/noncompile/920923-1.c
new file mode 100644
index 00000000000..52f8338abf3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/921102-1.c b/gcc/testsuite/gcc.c-torture/noncompile/921102-1.c
new file mode 100644
index 00000000000..3fb42f19b56
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/921102-1.c
@@ -0,0 +1 @@
+int x[]={[0.3 ... 4.6]9};
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/921116-1.c b/gcc/testsuite/gcc.c-torture/noncompile/921116-1.c
new file mode 100644
index 00000000000..78a75ea8193
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/921116-1.c
@@ -0,0 +1 @@
+void a (void x) {}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/930301-1.c b/gcc/testsuite/gcc.c-torture/noncompile/930301-1.c
new file mode 100644
index 00000000000..de4271415e9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/930301-1.c
@@ -0,0 +1,5 @@
+struct a *q;
+f()
+{
+  q++;
+}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/930622-1.c b/gcc/testsuite/gcc.c-torture/noncompile/930622-1.c
new file mode 100644
index 00000000000..27bb9ebd2f2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/930622-1.c
@@ -0,0 +1,6 @@
+f ()
+{
+  double b;
+  b = b * 10;
+  goto c;
+}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/930622-2.c b/gcc/testsuite/gcc.c-torture/noncompile/930622-2.c
new file mode 100644
index 00000000000..a75e0c43889
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/930622-2.c
@@ -0,0 +1,6 @@
+f ()
+{
+  int i;
+  for (i--)
+    ;
+}
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/930714-1.c b/gcc/testsuite/gcc.c-torture/noncompile/930714-1.c
new file mode 100644
index 00000000000..d940c550f57
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/931203-1.c b/gcc/testsuite/gcc.c-torture/noncompile/931203-1.c
new file mode 100644
index 00000000000..1f5a8c3d7ad
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940112-1.c b/gcc/testsuite/gcc.c-torture/noncompile/940112-1.c
new file mode 100644
index 00000000000..17dda8be54a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940227-1.c b/gcc/testsuite/gcc.c-torture/noncompile/940227-1.c
new file mode 100644
index 00000000000..21bba6c9cfe
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940510-1.c b/gcc/testsuite/gcc.c-torture/noncompile/940510-1.c
new file mode 100644
index 00000000000..9882d155e97
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/940510-1.c
@@ -0,0 +1 @@
+struct { int a[]; } x = { 0 };
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/940712-1.c b/gcc/testsuite/gcc.c-torture/noncompile/940712-1.c
new file mode 100644
index 00000000000..b1b82347483
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940712-1.h b/gcc/testsuite/gcc.c-torture/noncompile/940712-1.h
new file mode 100644
index 00000000000..183821334b1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940712-1a.h b/gcc/testsuite/gcc.c-torture/noncompile/940712-1a.h
new file mode 100644
index 00000000000..55ab6b844ec
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/940712-1b.h b/gcc/testsuite/gcc.c-torture/noncompile/940712-1b.h
new file mode 100644
index 00000000000..d75156c04b9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/940712-1b.h
@@ -0,0 +1,2 @@
+/* spanning a .h file */
+
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/950825-1.c b/gcc/testsuite/gcc.c-torture/noncompile/950825-1.c
new file mode 100644
index 00000000000..6104444da3b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/950825-1.c
@@ -0,0 +1 @@
+main() { return (struct x) {{y: 0}}; }
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/950921-1.c b/gcc/testsuite/gcc.c-torture/noncompile/950921-1.c
new file mode 100644
index 00000000000..bcf2f05e44f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/951025-1.c b/gcc/testsuite/gcc.c-torture/noncompile/951025-1.c
new file mode 100644
index 00000000000..694887290dd
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/951025-1.c
@@ -0,0 +1 @@
+#include /\
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/951123-1.c b/gcc/testsuite/gcc.c-torture/noncompile/951123-1.c
new file mode 100644
index 00000000000..e9ed3dcd246
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/951227-1.c b/gcc/testsuite/gcc.c-torture/noncompile/951227-1.c
new file mode 100644
index 00000000000..7c449c8579c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/951227-1.c
@@ -0,0 +1,2 @@
+#if 0xe-1
+#endif
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/Makefile.in b/gcc/testsuite/gcc.c-torture/noncompile/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/configure.in b/gcc/testsuite/gcc.c-torture/noncompile/configure.in
new file mode 100644
index 00000000000..19f62f2dfe5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/init-1.c b/gcc/testsuite/gcc.c-torture/noncompile/init-1.c
new file mode 100644
index 00000000000..52f43e81a4f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/init-2.c b/gcc/testsuite/gcc.c-torture/noncompile/init-2.c
new file mode 100644
index 00000000000..52ee17b019f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/init-2.c
@@ -0,0 +1 @@
+int d[][] = { {1}, {2}, {3} };
diff --git a/gcc/testsuite/gcc.c-torture/noncompile/invalid_asm.c b/gcc/testsuite/gcc.c-torture/noncompile/invalid_asm.c
new file mode 100644
index 00000000000..bb017f4315e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/noncompile/noncompile.exp b/gcc/testsuite/gcc.c-torture/noncompile/noncompile.exp
new file mode 100644
index 00000000000..cf8166d5308
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/noncompile/noncompile.exp
@@ -0,0 +1,307 @@
+#   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 9211102-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 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 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/testsuite/gcc.c-torture/noncompile/va-arg-1.c b/gcc/testsuite/gcc.c-torture/noncompile/va-arg-1.c
new file mode 100644
index 00000000000..0285872860d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/920413-1.c b/gcc/testsuite/gcc.c-torture/special/920413-1.c
new file mode 100644
index 00000000000..a3e06139a5d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/920520-1.c b/gcc/testsuite/gcc.c-torture/special/920520-1.c
new file mode 100644
index 00000000000..6b1cd7b17c4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/920521-1.c b/gcc/testsuite/gcc.c-torture/special/920521-1.c
new file mode 100644
index 00000000000..0f4dc08fb30
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/920521-1.c
@@ -0,0 +1 @@
+f(){asm("f":::"cc");}g(x){asm("g"::"%r"(x));}
diff --git a/gcc/testsuite/gcc.c-torture/special/920717-x.c b/gcc/testsuite/gcc.c-torture/special/920717-x.c
new file mode 100644
index 00000000000..07601e397f0
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/920717-x.c
@@ -0,0 +1,3 @@
+/* 920717-1.c */
+
+const char s[]="foo";
diff --git a/gcc/testsuite/gcc.c-torture/special/920717-y.c b/gcc/testsuite/gcc.c-torture/special/920717-y.c
new file mode 100644
index 00000000000..eaffa5e4bb7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/920730-1.c b/gcc/testsuite/gcc.c-torture/special/920730-1.c
new file mode 100644
index 00000000000..d97d873634d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/921210-1.c b/gcc/testsuite/gcc.c-torture/special/921210-1.c
new file mode 100644
index 00000000000..bbbf39a314b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/930510-1.c b/gcc/testsuite/gcc.c-torture/special/930510-1.c
new file mode 100644
index 00000000000..f973bc63321
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/930510-1.c
@@ -0,0 +1,3 @@
+#define ugly 3
+#ugly "foobar" 3	/* { dg-error "invalid" "invalid directive" } */
+main() { exit (0); }
diff --git a/gcc/testsuite/gcc.c-torture/special/951130-1.c b/gcc/testsuite/gcc.c-torture/special/951130-1.c
new file mode 100644
index 00000000000..c06ba075ff6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/960224-1.c b/gcc/testsuite/gcc.c-torture/special/960224-1.c
new file mode 100644
index 00000000000..de0a6ae7227
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/960224-1.c
@@ -0,0 +1,6 @@
+#if 0
+#if 0
+#endif \
+\
+
+#endif
diff --git a/gcc/testsuite/gcc.c-torture/special/960224-2.c b/gcc/testsuite/gcc.c-torture/special/960224-2.c
new file mode 100644
index 00000000000..3d696940640
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/960224-2.c
@@ -0,0 +1,4 @@
+#if 0
+#if 0
+#endif /
+#endif
diff --git a/gcc/testsuite/gcc.c-torture/special/Makefile.in b/gcc/testsuite/gcc.c-torture/special/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/configure.in b/gcc/testsuite/gcc.c-torture/special/configure.in
new file mode 100644
index 00000000000..b9cbac3fd77
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/special/special.exp b/gcc/testsuite/gcc.c-torture/special/special.exp
new file mode 100644
index 00000000000..9b1142149e6
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/special/special.exp
@@ -0,0 +1,100 @@
+# 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) ##################
+
+# 921210-1
+set lines [gcc_target_compile $srcdir/$subdir/921210-1.c "" preprocess ""]
+set lines [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"
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/386.c b/gcc/testsuite/gcc.c-torture/unsorted/386.c
new file mode 100644
index 00000000000..432cdaddd12
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/86.c b/gcc/testsuite/gcc.c-torture/unsorted/86.c
new file mode 100644
index 00000000000..deea85ee2f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG1.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG1.c
new file mode 100644
index 00000000000..ada8eaf49c7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG11.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG11.c
new file mode 100644
index 00000000000..fe2923a97f0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG12.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG12.c
new file mode 100644
index 00000000000..b32fa607176
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/BUG12.c
@@ -0,0 +1,5 @@
+long long
+main ()
+{
+  return 1.1e10;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/BUG13.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG13.c
new file mode 100644
index 00000000000..9a302b95152
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG16.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG16.c
new file mode 100644
index 00000000000..daeae2ca562
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/BUG16.c
@@ -0,0 +1,6 @@
+setgetlen (a)
+     int *a;
+{
+  while (*a++ & 0x80000000)
+    ;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/BUG17.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG17.c
new file mode 100644
index 00000000000..920587046ed
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/BUG17.c
@@ -0,0 +1,8 @@
+double d;
+
+main()
+{
+  int i;
+
+  i = (int) d;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/BUG18.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG18.c
new file mode 100644
index 00000000000..ed586a7f9d6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG2.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG2.c
new file mode 100644
index 00000000000..6dc30be6502
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG21.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG21.c
new file mode 100644
index 00000000000..c8a1157cc46
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG22.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG22.c
new file mode 100644
index 00000000000..9fd95254d3d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG23.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG23.c
new file mode 100644
index 00000000000..1ff429ef0ac
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG24.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG24.c
new file mode 100644
index 00000000000..7627a3ddcdd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG25.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG25.c
new file mode 100644
index 00000000000..57441706125
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/BUG25.c
@@ -0,0 +1,5 @@
+
+foo (a)
+{
+  __builtin_ffs (a);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/BUG3.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG3.c
new file mode 100644
index 00000000000..30e6622a566
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG4.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG4.c
new file mode 100644
index 00000000000..be6a14989c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG5.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG5.c
new file mode 100644
index 00000000000..9bed7136f59
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/BUG6.c b/gcc/testsuite/gcc.c-torture/unsorted/BUG6.c
new file mode 100644
index 00000000000..b1394650964
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/DFcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/DFcmp.c
new file mode 100644
index 00000000000..b32b0ecc6ab
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/HIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/HIcmp.c
new file mode 100644
index 00000000000..eea39841b95
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/HIset.c b/gcc/testsuite/gcc.c-torture/unsorted/HIset.c
new file mode 100644
index 00000000000..8108fbb27c4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/Makefile.in b/gcc/testsuite/gcc.c-torture/unsorted/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/PYRBUG.c b/gcc/testsuite/gcc.c-torture/unsorted/PYRBUG.c
new file mode 100644
index 00000000000..c64c3f5e1b2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/QIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/QIcmp.c
new file mode 100644
index 00000000000..c5161646f2c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/QIset.c b/gcc/testsuite/gcc.c-torture/unsorted/QIset.c
new file mode 100644
index 00000000000..212609dc864
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/SFset.c b/gcc/testsuite/gcc.c-torture/unsorted/SFset.c
new file mode 100644
index 00000000000..ad3e41b834b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/SIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/SIcmp.c
new file mode 100644
index 00000000000..30e07392467
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/SIset.c b/gcc/testsuite/gcc.c-torture/unsorted/SIset.c
new file mode 100644
index 00000000000..74a51cd0fb4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/UHIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/UHIcmp.c
new file mode 100644
index 00000000000..1e969e7103a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/UQIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/UQIcmp.c
new file mode 100644
index 00000000000..3e9cdebc903
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/USIcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/USIcmp.c
new file mode 100644
index 00000000000..e2175262a42
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/a.c b/gcc/testsuite/gcc.c-torture/unsorted/a.c
new file mode 100644
index 00000000000..47fb1f493f2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/a.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a & 65535;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/a1.c b/gcc/testsuite/gcc.c-torture/unsorted/a1.c
new file mode 100644
index 00000000000..654781d05ea
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/a3.c b/gcc/testsuite/gcc.c-torture/unsorted/a3.c
new file mode 100644
index 00000000000..85d2a242630
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/aa.c b/gcc/testsuite/gcc.c-torture/unsorted/aa.c
new file mode 100644
index 00000000000..61a4147afa6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/aaa.c b/gcc/testsuite/gcc.c-torture/unsorted/aaa.c
new file mode 100644
index 00000000000..e31fb567c1c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/abs.c b/gcc/testsuite/gcc.c-torture/unsorted/abs.c
new file mode 100644
index 00000000000..6a746b12639
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ac.c b/gcc/testsuite/gcc.c-torture/unsorted/ac.c
new file mode 100644
index 00000000000..1d3c085eec1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/acc.c b/gcc/testsuite/gcc.c-torture/unsorted/acc.c
new file mode 100644
index 00000000000..a4a027a5fce
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/add.c b/gcc/testsuite/gcc.c-torture/unsorted/add.c
new file mode 100644
index 00000000000..d796e41c712
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/add.c
@@ -0,0 +1,5 @@
+foo (a, b, p)
+     int *p;
+{
+  return 34 + *p;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/add386.c b/gcc/testsuite/gcc.c-torture/unsorted/add386.c
new file mode 100644
index 00000000000..bfdffbfe2f2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/add386.c
@@ -0,0 +1,4 @@
+main (a)
+{
+  return a + 128;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/addcc.c b/gcc/testsuite/gcc.c-torture/unsorted/addcc.c
new file mode 100644
index 00000000000..cf52307aa97
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/andm.c b/gcc/testsuite/gcc.c-torture/unsorted/andm.c
new file mode 100644
index 00000000000..17101ae3050
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/andmem.c b/gcc/testsuite/gcc.c-torture/unsorted/andmem.c
new file mode 100644
index 00000000000..10bad00f445
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/andn.c b/gcc/testsuite/gcc.c-torture/unsorted/andn.c
new file mode 100644
index 00000000000..2e38dd0e36e
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/andn.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  int b = 0x1fff;
+  return a & ~b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/andok.c b/gcc/testsuite/gcc.c-torture/unsorted/andok.c
new file mode 100644
index 00000000000..d55bd01b70d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/andsi.c b/gcc/testsuite/gcc.c-torture/unsorted/andsi.c
new file mode 100644
index 00000000000..b9c3c76de03
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/andsi.c
@@ -0,0 +1,4 @@
+foo ()
+{
+  return (int)&foo;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/andsparc.c b/gcc/testsuite/gcc.c-torture/unsorted/andsparc.c
new file mode 100644
index 00000000000..62f0de003b2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/aos.c b/gcc/testsuite/gcc.c-torture/unsorted/aos.c
new file mode 100644
index 00000000000..77c92f677e4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/arr.c b/gcc/testsuite/gcc.c-torture/unsorted/arr.c
new file mode 100644
index 00000000000..ed56667dd75
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/as.c b/gcc/testsuite/gcc.c-torture/unsorted/as.c
new file mode 100644
index 00000000000..172f88355d9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ase.c b/gcc/testsuite/gcc.c-torture/unsorted/ase.c
new file mode 100644
index 00000000000..2d3d8edbd0b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/b.c b/gcc/testsuite/gcc.c-torture/unsorted/b.c
new file mode 100644
index 00000000000..498d7552af9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/b.c
@@ -0,0 +1,4 @@
+main ()
+{
+  *(short *) 25 = 123;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/b1.c b/gcc/testsuite/gcc.c-torture/unsorted/b1.c
new file mode 100644
index 00000000000..b6737594cb1
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/b2.c b/gcc/testsuite/gcc.c-torture/unsorted/b2.c
new file mode 100644
index 00000000000..96e4556a53a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/b3.c b/gcc/testsuite/gcc.c-torture/unsorted/b3.c
new file mode 100644
index 00000000000..af693f77931
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/b88.c b/gcc/testsuite/gcc.c-torture/unsorted/b88.c
new file mode 100644
index 00000000000..971c7c76d92
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bad.c b/gcc/testsuite/gcc.c-torture/unsorted/bad.c
new file mode 100644
index 00000000000..8cc84973b72
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/band.c b/gcc/testsuite/gcc.c-torture/unsorted/band.c
new file mode 100644
index 00000000000..74b02fd3b34
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bb0.c b/gcc/testsuite/gcc.c-torture/unsorted/bb0.c
new file mode 100644
index 00000000000..aab6d683fbd
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/bb0.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  return (a & 0xfff000) != 0;
+
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/bb1.c b/gcc/testsuite/gcc.c-torture/unsorted/bb1.c
new file mode 100644
index 00000000000..3f9aebe0364
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bbb.c b/gcc/testsuite/gcc.c-torture/unsorted/bbb.c
new file mode 100644
index 00000000000..837dd9ecf93
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bc.c b/gcc/testsuite/gcc.c-torture/unsorted/bc.c
new file mode 100644
index 00000000000..c713bb61b3d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/bc.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a % (1 << b);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/bcopy.c b/gcc/testsuite/gcc.c-torture/unsorted/bcopy.c
new file mode 100644
index 00000000000..1732b349e4d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bf.c b/gcc/testsuite/gcc.c-torture/unsorted/bf.c
new file mode 100644
index 00000000000..821623df09c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bfins.c b/gcc/testsuite/gcc.c-torture/unsorted/bfins.c
new file mode 100644
index 00000000000..e626d82b3cb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bfx.c b/gcc/testsuite/gcc.c-torture/unsorted/bfx.c
new file mode 100644
index 00000000000..d47bd7d18bc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bge.c b/gcc/testsuite/gcc.c-torture/unsorted/bge.c
new file mode 100644
index 00000000000..55f4788299a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bit.c b/gcc/testsuite/gcc.c-torture/unsorted/bit.c
new file mode 100644
index 00000000000..e76bb45e7cd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bitf.c b/gcc/testsuite/gcc.c-torture/unsorted/bitf.c
new file mode 100644
index 00000000000..5b0aefc83d4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bitw.c b/gcc/testsuite/gcc.c-torture/unsorted/bitw.c
new file mode 100644
index 00000000000..585cd32e603
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/blk.c b/gcc/testsuite/gcc.c-torture/unsorted/blk.c
new file mode 100644
index 00000000000..18a9545cc28
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bt.c b/gcc/testsuite/gcc.c-torture/unsorted/bt.c
new file mode 100644
index 00000000000..ac20c05674d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/bt.c
@@ -0,0 +1,7 @@
+main ()
+{
+  int i;
+
+  for (i = 1000000; --i;)
+    ;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/bt386.c b/gcc/testsuite/gcc.c-torture/unsorted/bt386.c
new file mode 100644
index 00000000000..283ab5fa64a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bug.c b/gcc/testsuite/gcc.c-torture/unsorted/bug.c
new file mode 100644
index 00000000000..447eb7af297
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/bug.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a - 65536;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/bugc.c b/gcc/testsuite/gcc.c-torture/unsorted/bugc.c
new file mode 100644
index 00000000000..b2ce1fad8ac
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/buns.c b/gcc/testsuite/gcc.c-torture/unsorted/buns.c
new file mode 100644
index 00000000000..f206bfaed0c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/bx.c b/gcc/testsuite/gcc.c-torture/unsorted/bx.c
new file mode 100644
index 00000000000..274fb015cf5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/c.c b/gcc/testsuite/gcc.c-torture/unsorted/c.c
new file mode 100644
index 00000000000..384ee3e3cf3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/c1.c b/gcc/testsuite/gcc.c-torture/unsorted/c1.c
new file mode 100644
index 00000000000..f50d437f60b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/c2.c b/gcc/testsuite/gcc.c-torture/unsorted/c2.c
new file mode 100644
index 00000000000..ef5a71188d3
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/c2.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  bar (a);
+  bar (a);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/call.c b/gcc/testsuite/gcc.c-torture/unsorted/call.c
new file mode 100644
index 00000000000..c8106038371
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/call386.c b/gcc/testsuite/gcc.c-torture/unsorted/call386.c
new file mode 100644
index 00000000000..18498932c5b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/callind.c b/gcc/testsuite/gcc.c-torture/unsorted/callind.c
new file mode 100644
index 00000000000..74c0f1f9cef
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cc.c b/gcc/testsuite/gcc.c-torture/unsorted/cc.c
new file mode 100644
index 00000000000..e29bec49d41
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/charmtst.c b/gcc/testsuite/gcc.c-torture/unsorted/charmtst.c
new file mode 100644
index 00000000000..2945f198e5e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cmb.c b/gcc/testsuite/gcc.c-torture/unsorted/cmb.c
new file mode 100644
index 00000000000..1fd946182ba
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cmp.c b/gcc/testsuite/gcc.c-torture/unsorted/cmp.c
new file mode 100644
index 00000000000..a82fe424735
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cmphi.c b/gcc/testsuite/gcc.c-torture/unsorted/cmphi.c
new file mode 100644
index 00000000000..1ffc2140fba
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/cmphi.c
@@ -0,0 +1,4 @@
+foo (short *p, short a)
+{
+  return a < *p;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/cmpsi386.c b/gcc/testsuite/gcc.c-torture/unsorted/cmpsi386.c
new file mode 100644
index 00000000000..50b08d7126d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cmul.c b/gcc/testsuite/gcc.c-torture/unsorted/cmul.c
new file mode 100644
index 00000000000..cce20bc358d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/cmul.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a * 84;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/cn1.c b/gcc/testsuite/gcc.c-torture/unsorted/cn1.c
new file mode 100644
index 00000000000..866778ca199
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/cn1.c
@@ -0,0 +1,5 @@
+int
+foo ()
+{
+  return 7561;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/comb.c b/gcc/testsuite/gcc.c-torture/unsorted/comb.c
new file mode 100644
index 00000000000..a4689079b79
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/configure.in b/gcc/testsuite/gcc.c-torture/unsorted/configure.in
new file mode 100644
index 00000000000..7810172c29e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/consec.c b/gcc/testsuite/gcc.c-torture/unsorted/consec.c
new file mode 100644
index 00000000000..fd76cd2eec4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/const.c b/gcc/testsuite/gcc.c-torture/unsorted/const.c
new file mode 100644
index 00000000000..209fc768887
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/const.c
@@ -0,0 +1,4 @@
+main (a)
+{
+  return a + (~0 - 240);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/conv.c b/gcc/testsuite/gcc.c-torture/unsorted/conv.c
new file mode 100644
index 00000000000..70fc024127c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/conv_tst.c b/gcc/testsuite/gcc.c-torture/unsorted/conv_tst.c
new file mode 100644
index 00000000000..513d6a2471e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cp.c b/gcc/testsuite/gcc.c-torture/unsorted/cp.c
new file mode 100644
index 00000000000..04b1420cb30
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/csebug.c b/gcc/testsuite/gcc.c-torture/unsorted/csebug.c
new file mode 100644
index 00000000000..f49f6842c1a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/cvt.c b/gcc/testsuite/gcc.c-torture/unsorted/cvt.c
new file mode 100644
index 00000000000..716659c4798
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/d.c b/gcc/testsuite/gcc.c-torture/unsorted/d.c
new file mode 100644
index 00000000000..5fca120d85a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dbl_parm.c b/gcc/testsuite/gcc.c-torture/unsorted/dbl_parm.c
new file mode 100644
index 00000000000..ce5ba4f16d5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dblbug.c b/gcc/testsuite/gcc.c-torture/unsorted/dblbug.c
new file mode 100644
index 00000000000..cd13b796297
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ddd.c b/gcc/testsuite/gcc.c-torture/unsorted/ddd.c
new file mode 100644
index 00000000000..b0b6809dd69
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/ddd.c
@@ -0,0 +1,7 @@
+int foo;
+int bar;
+
+main ()
+{
+  return foo + bar;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/dead.c b/gcc/testsuite/gcc.c-torture/unsorted/dead.c
new file mode 100644
index 00000000000..795f7c7e467
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/dead.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  ++a;
+  return a == 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/delay.c b/gcc/testsuite/gcc.c-torture/unsorted/delay.c
new file mode 100644
index 00000000000..c776383520a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/di.c b/gcc/testsuite/gcc.c-torture/unsorted/di.c
new file mode 100644
index 00000000000..476bf700fb3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dic.c b/gcc/testsuite/gcc.c-torture/unsorted/dic.c
new file mode 100644
index 00000000000..9c2c9f90fd6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dilayout.c b/gcc/testsuite/gcc.c-torture/unsorted/dilayout.c
new file mode 100644
index 00000000000..4bba661c0a4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dimove.c b/gcc/testsuite/gcc.c-torture/unsorted/dimove.c
new file mode 100644
index 00000000000..7caf3fa468b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/dimove.c
@@ -0,0 +1,4 @@
+foo (long long *p)
+{
+  p[0] = p[1];
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/dimul.c b/gcc/testsuite/gcc.c-torture/unsorted/dimul.c
new file mode 100644
index 00000000000..c8529565fa9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/div.c b/gcc/testsuite/gcc.c-torture/unsorted/div.c
new file mode 100644
index 00000000000..1f0904a649d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/div.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a / b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/divdf.c b/gcc/testsuite/gcc.c-torture/unsorted/divdf.c
new file mode 100644
index 00000000000..5ea89ae3ddc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dm.c b/gcc/testsuite/gcc.c-torture/unsorted/dm.c
new file mode 100644
index 00000000000..67c60ee9820
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/dshift.c b/gcc/testsuite/gcc.c-torture/unsorted/dshift.c
new file mode 100644
index 00000000000..94750cc3cbc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/e.c b/gcc/testsuite/gcc.c-torture/unsorted/e.c
new file mode 100644
index 00000000000..fa20e00ef8f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ex.c b/gcc/testsuite/gcc.c-torture/unsorted/ex.c
new file mode 100644
index 00000000000..f5d90fd2e65
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ext.c b/gcc/testsuite/gcc.c-torture/unsorted/ext.c
new file mode 100644
index 00000000000..8fa8cd73363
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/f1.c b/gcc/testsuite/gcc.c-torture/unsorted/f1.c
new file mode 100644
index 00000000000..446acc6e1a1
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/f1.c
@@ -0,0 +1,5 @@
+double
+foo ()
+{
+  return 1.2587624368724;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/f2.c b/gcc/testsuite/gcc.c-torture/unsorted/f2.c
new file mode 100644
index 00000000000..8bb384902b9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/f2.c
@@ -0,0 +1,4 @@
+foo (double *p)
+{
+  p[0] = p[1];
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/fdmul.c b/gcc/testsuite/gcc.c-torture/unsorted/fdmul.c
new file mode 100644
index 00000000000..711707b51fc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/flo.c b/gcc/testsuite/gcc.c-torture/unsorted/flo.c
new file mode 100644
index 00000000000..2a213b7ab79
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/float.c b/gcc/testsuite/gcc.c-torture/unsorted/float.c
new file mode 100644
index 00000000000..b6789203b5d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/flt_const.c b/gcc/testsuite/gcc.c-torture/unsorted/flt_const.c
new file mode 100644
index 00000000000..65700ba7730
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/flt_const.c
@@ -0,0 +1,5 @@
+double
+foo ()
+{
+  return 3.141592653589793238462643;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/fnul.c b/gcc/testsuite/gcc.c-torture/unsorted/fnul.c
new file mode 100644
index 00000000000..b0c9816adf7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/foo.c b/gcc/testsuite/gcc.c-torture/unsorted/foo.c
new file mode 100644
index 00000000000..762d7e457d0
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/forgetcc.c b/gcc/testsuite/gcc.c-torture/unsorted/forgetcc.c
new file mode 100644
index 00000000000..4105408a050
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/fq.c b/gcc/testsuite/gcc.c-torture/unsorted/fq.c
new file mode 100644
index 00000000000..c4ac3696096
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/g.c b/gcc/testsuite/gcc.c-torture/unsorted/g.c
new file mode 100644
index 00000000000..e00f1244fc4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/gen_tst.c b/gcc/testsuite/gcc.c-torture/unsorted/gen_tst.c
new file mode 100644
index 00000000000..5a7a3763a3a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/glob.c b/gcc/testsuite/gcc.c-torture/unsorted/glob.c
new file mode 100644
index 00000000000..e3206154fd9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/gronk.c b/gcc/testsuite/gcc.c-torture/unsorted/gronk.c
new file mode 100644
index 00000000000..c1bb767e576
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/hi.c b/gcc/testsuite/gcc.c-torture/unsorted/hi.c
new file mode 100644
index 00000000000..1624f777995
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/hi.c
@@ -0,0 +1,5 @@
+foo (a, b)
+     short a, b;
+{
+  return a < b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/hibug.c b/gcc/testsuite/gcc.c-torture/unsorted/hibug.c
new file mode 100644
index 00000000000..ad5c8267994
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/i++.c b/gcc/testsuite/gcc.c-torture/unsorted/i++.c
new file mode 100644
index 00000000000..01d9ca95a8a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/i.c b/gcc/testsuite/gcc.c-torture/unsorted/i.c
new file mode 100644
index 00000000000..3bee8eacb80
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/i386bug.c b/gcc/testsuite/gcc.c-torture/unsorted/i386bug.c
new file mode 100644
index 00000000000..395bfa6c3e2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ic.c b/gcc/testsuite/gcc.c-torture/unsorted/ic.c
new file mode 100644
index 00000000000..150e1e8ed7e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/icmp.c b/gcc/testsuite/gcc.c-torture/unsorted/icmp.c
new file mode 100644
index 00000000000..dc9678ec335
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ifreg.c b/gcc/testsuite/gcc.c-torture/unsorted/ifreg.c
new file mode 100644
index 00000000000..9e2f9562e38
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/imm.c b/gcc/testsuite/gcc.c-torture/unsorted/imm.c
new file mode 100644
index 00000000000..c3efba45eee
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/imm.c
@@ -0,0 +1,7 @@
+int
+imm ()
+
+{
+  return 11234;
+
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/isinf.c b/gcc/testsuite/gcc.c-torture/unsorted/isinf.c
new file mode 100644
index 00000000000..12a8283747f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/isinf.c
@@ -0,0 +1,5 @@
+int
+isinf ()
+{
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/jmp.c b/gcc/testsuite/gcc.c-torture/unsorted/jmp.c
new file mode 100644
index 00000000000..474206a1f5e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/jumptab.c b/gcc/testsuite/gcc.c-torture/unsorted/jumptab.c
new file mode 100644
index 00000000000..d86c30e40d6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/l.c b/gcc/testsuite/gcc.c-torture/unsorted/l.c
new file mode 100644
index 00000000000..cc23b190b1d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/l.c
@@ -0,0 +1,4 @@
+main (a)
+{
+  return - 256 + a;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/layout.c b/gcc/testsuite/gcc.c-torture/unsorted/layout.c
new file mode 100644
index 00000000000..04c825df645
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/lbug.c b/gcc/testsuite/gcc.c-torture/unsorted/lbug.c
new file mode 100644
index 00000000000..0440a0a7a9d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ll1.c b/gcc/testsuite/gcc.c-torture/unsorted/ll1.c
new file mode 100644
index 00000000000..9009e77b6f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/llbug.c b/gcc/testsuite/gcc.c-torture/unsorted/llbug.c
new file mode 100644
index 00000000000..8c56dfbe70d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/lll.c b/gcc/testsuite/gcc.c-torture/unsorted/lll.c
new file mode 100644
index 00000000000..dee9dc37d15
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/load8.c b/gcc/testsuite/gcc.c-torture/unsorted/load8.c
new file mode 100644
index 00000000000..947a8165c29
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/load8.c
@@ -0,0 +1,4 @@
+foo ()
+{
+  return *(short *) 126;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/loadhicc.c b/gcc/testsuite/gcc.c-torture/unsorted/loadhicc.c
new file mode 100644
index 00000000000..a7540894f5e
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/log2.c b/gcc/testsuite/gcc.c-torture/unsorted/log2.c
new file mode 100644
index 00000000000..39b85784069
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/logic.c b/gcc/testsuite/gcc.c-torture/unsorted/logic.c
new file mode 100644
index 00000000000..a9d6e9d0c2d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/loop-1.c b/gcc/testsuite/gcc.c-torture/unsorted/loop-1.c
new file mode 100644
index 00000000000..e50687a9fdd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/loop386.c b/gcc/testsuite/gcc.c-torture/unsorted/loop386.c
new file mode 100644
index 00000000000..429a320abbd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/lop.c b/gcc/testsuite/gcc.c-torture/unsorted/lop.c
new file mode 100644
index 00000000000..72464111d4d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/lop.c
@@ -0,0 +1,6 @@
+lop (a)
+{
+  do
+    a--;
+  while (a >= -1);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/m1.c b/gcc/testsuite/gcc.c-torture/unsorted/m1.c
new file mode 100644
index 00000000000..8660f60c950
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/m1.c
@@ -0,0 +1,5 @@
+foo (p)
+     int *p;
+{
+  *p = 1234;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/m2.c b/gcc/testsuite/gcc.c-torture/unsorted/m2.c
new file mode 100644
index 00000000000..203c855b5eb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/m5.c b/gcc/testsuite/gcc.c-torture/unsorted/m5.c
new file mode 100644
index 00000000000..23ad8445d32
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/m5.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a * 5 + 12;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/m68.c b/gcc/testsuite/gcc.c-torture/unsorted/m68.c
new file mode 100644
index 00000000000..a1ee486d4c2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mbyte.c b/gcc/testsuite/gcc.c-torture/unsorted/mbyte.c
new file mode 100644
index 00000000000..a8a23eab90a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mchar.c b/gcc/testsuite/gcc.c-torture/unsorted/mchar.c
new file mode 100644
index 00000000000..a1b106037f7
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mcmp.c b/gcc/testsuite/gcc.c-torture/unsorted/mcmp.c
new file mode 100644
index 00000000000..6008008e164
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mdouble.c b/gcc/testsuite/gcc.c-torture/unsorted/mdouble.c
new file mode 100644
index 00000000000..992db2205f2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/mdouble.c
@@ -0,0 +1,6 @@
+double
+foo (double a)
+{
+
+  return 1.123486712;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/memtst.c b/gcc/testsuite/gcc.c-torture/unsorted/memtst.c
new file mode 100644
index 00000000000..b345ba00b3c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/memtst.c
@@ -0,0 +1,20 @@
+memtst (int *p, int a)
+{
+  do
+    {
+      if (p[a] == 1)
+	break;
+    }
+  while (--a);
+}
+
+main ()
+{
+  int a[65536];
+  int i;
+  bzero (a, 65536 * 4);
+  for (i = 0;  i < 100;  i++)
+    {
+      memtst (a, 65536);
+    }
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/miscomp.c b/gcc/testsuite/gcc.c-torture/unsorted/miscomp.c
new file mode 100644
index 00000000000..0bcb568d54b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mm.c b/gcc/testsuite/gcc.c-torture/unsorted/mm.c
new file mode 100644
index 00000000000..a8efaae21cb
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/mm.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a * 2;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/mod.c b/gcc/testsuite/gcc.c-torture/unsorted/mod.c
new file mode 100644
index 00000000000..c33211dc7fc
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/mod.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a % b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/modcc.c b/gcc/testsuite/gcc.c-torture/unsorted/modcc.c
new file mode 100644
index 00000000000..2574090e96c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/modcc.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return (a % b) == 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/move.c b/gcc/testsuite/gcc.c-torture/unsorted/move.c
new file mode 100644
index 00000000000..78e00ff2100
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/move_qhi.c b/gcc/testsuite/gcc.c-torture/unsorted/move_qhi.c
new file mode 100644
index 00000000000..9bc9cb6630c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mregtst.c b/gcc/testsuite/gcc.c-torture/unsorted/mregtst.c
new file mode 100644
index 00000000000..b6bb6c21f55
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/msp.c b/gcc/testsuite/gcc.c-torture/unsorted/msp.c
new file mode 100644
index 00000000000..c73cedd294c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/msp.c
@@ -0,0 +1,5 @@
+foo ()
+{
+  int a[16384];
+  bar (a);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/mtst.c b/gcc/testsuite/gcc.c-torture/unsorted/mtst.c
new file mode 100644
index 00000000000..4f43137b705
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mu.c b/gcc/testsuite/gcc.c-torture/unsorted/mu.c
new file mode 100644
index 00000000000..c469a6e3a9b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/mu.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a * b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/mul.c b/gcc/testsuite/gcc.c-torture/unsorted/mul.c
new file mode 100644
index 00000000000..cc5d06b5fac
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mword.c b/gcc/testsuite/gcc.c-torture/unsorted/mword.c
new file mode 100644
index 00000000000..873e08868c5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/mword1.c b/gcc/testsuite/gcc.c-torture/unsorted/mword1.c
new file mode 100644
index 00000000000..690703eb8bf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/n.c b/gcc/testsuite/gcc.c-torture/unsorted/n.c
new file mode 100644
index 00000000000..1a9a8697417
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/n1.c b/gcc/testsuite/gcc.c-torture/unsorted/n1.c
new file mode 100644
index 00000000000..dfa93cebed4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/nand.c b/gcc/testsuite/gcc.c-torture/unsorted/nand.c
new file mode 100644
index 00000000000..8228a3c3a42
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/nand.c
@@ -0,0 +1,4 @@
+nadn (a, b)
+{
+  return (~a) | (~b);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/neg.c b/gcc/testsuite/gcc.c-torture/unsorted/neg.c
new file mode 100644
index 00000000000..c005b1327dd
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/neg.c
@@ -0,0 +1 @@
+foo (a) {return -a;}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/o.c b/gcc/testsuite/gcc.c-torture/unsorted/o.c
new file mode 100644
index 00000000000..e8b78e383cb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/omit.c b/gcc/testsuite/gcc.c-torture/unsorted/omit.c
new file mode 100644
index 00000000000..f59d6ee8f27
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/opout.c b/gcc/testsuite/gcc.c-torture/unsorted/opout.c
new file mode 100644
index 00000000000..6d3736e059a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/opt.c b/gcc/testsuite/gcc.c-torture/unsorted/opt.c
new file mode 100644
index 00000000000..faad10e48fe
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/opt.c
@@ -0,0 +1,5 @@
+int
+foo (a)
+{
+  return (a == 2);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/or.c b/gcc/testsuite/gcc.c-torture/unsorted/or.c
new file mode 100644
index 00000000000..2a2e3b668b7
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/or.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a | 0xffff0101;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/or386.c b/gcc/testsuite/gcc.c-torture/unsorted/or386.c
new file mode 100644
index 00000000000..ad49f35043c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/p.c b/gcc/testsuite/gcc.c-torture/unsorted/p.c
new file mode 100644
index 00000000000..465e741592a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/parms.c b/gcc/testsuite/gcc.c-torture/unsorted/parms.c
new file mode 100644
index 00000000000..26c2c701756
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pass.c b/gcc/testsuite/gcc.c-torture/unsorted/pass.c
new file mode 100644
index 00000000000..6b663828aee
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pmt.c b/gcc/testsuite/gcc.c-torture/unsorted/pmt.c
new file mode 100644
index 00000000000..b6aced6ec81
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/poor.c b/gcc/testsuite/gcc.c-torture/unsorted/poor.c
new file mode 100644
index 00000000000..66d584aff43
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pp.c b/gcc/testsuite/gcc.c-torture/unsorted/pp.c
new file mode 100644
index 00000000000..7d38d53de0f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pret-arg.c b/gcc/testsuite/gcc.c-torture/unsorted/pret-arg.c
new file mode 100644
index 00000000000..a7fa8562830
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pyr.c b/gcc/testsuite/gcc.c-torture/unsorted/pyr.c
new file mode 100644
index 00000000000..d25b2a99aa5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/pyr2.c b/gcc/testsuite/gcc.c-torture/unsorted/pyr2.c
new file mode 100644
index 00000000000..12e2ccd24b2
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/pyr2.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return ((int *)0)[a];
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/q.c b/gcc/testsuite/gcc.c-torture/unsorted/q.c
new file mode 100644
index 00000000000..fa08e758a52
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/r.c b/gcc/testsuite/gcc.c-torture/unsorted/r.c
new file mode 100644
index 00000000000..19eeda7ab44
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/r1.c b/gcc/testsuite/gcc.c-torture/unsorted/r1.c
new file mode 100644
index 00000000000..0b277b0f8dc
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/rel.c b/gcc/testsuite/gcc.c-torture/unsorted/rel.c
new file mode 100644
index 00000000000..54d36052ed3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/rmsc.c b/gcc/testsuite/gcc.c-torture/unsorted/rmsc.c
new file mode 100644
index 00000000000..5c97c6dae14
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/round.c b/gcc/testsuite/gcc.c-torture/unsorted/round.c
new file mode 100644
index 00000000000..5233e65ea90
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/run.c b/gcc/testsuite/gcc.c-torture/unsorted/run.c
new file mode 100644
index 00000000000..40892f6037f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/s.c b/gcc/testsuite/gcc.c-torture/unsorted/s.c
new file mode 100644
index 00000000000..e0c84262208
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sar.c b/gcc/testsuite/gcc.c-torture/unsorted/sar.c
new file mode 100644
index 00000000000..9bf9bec0625
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sc.c b/gcc/testsuite/gcc.c-torture/unsorted/sc.c
new file mode 100644
index 00000000000..84dc60f7e90
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/scal.c b/gcc/testsuite/gcc.c-torture/unsorted/scal.c
new file mode 100644
index 00000000000..94e22aa80f5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/scc.c b/gcc/testsuite/gcc.c-torture/unsorted/scc.c
new file mode 100644
index 00000000000..79ae4e12f45
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/scond.c b/gcc/testsuite/gcc.c-torture/unsorted/scond.c
new file mode 100644
index 00000000000..087b0a66e94
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/selfrec.c b/gcc/testsuite/gcc.c-torture/unsorted/selfrec.c
new file mode 100644
index 00000000000..c7aaca552a0
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/selfrec.c
@@ -0,0 +1,5 @@
+int
+foo (a)
+{
+  return foo (a - 1) * a;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/seq.c b/gcc/testsuite/gcc.c-torture/unsorted/seq.c
new file mode 100644
index 00000000000..0793228b491
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/seq.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a < 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/set386.c b/gcc/testsuite/gcc.c-torture/unsorted/set386.c
new file mode 100644
index 00000000000..c16ae8dbdfe
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/set386.c
@@ -0,0 +1,5 @@
+foo (a, p)
+     int *p;
+{
+  *p = a > 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/set88.c b/gcc/testsuite/gcc.c-torture/unsorted/set88.c
new file mode 100644
index 00000000000..8069ea622a3
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sh.c b/gcc/testsuite/gcc.c-torture/unsorted/sh.c
new file mode 100644
index 00000000000..8d3265f83f7
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sh.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a << b;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/shand.c b/gcc/testsuite/gcc.c-torture/unsorted/shand.c
new file mode 100644
index 00000000000..5a401961355
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/shft.c b/gcc/testsuite/gcc.c-torture/unsorted/shft.c
new file mode 100644
index 00000000000..7d318c863c5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/shift.c b/gcc/testsuite/gcc.c-torture/unsorted/shift.c
new file mode 100644
index 00000000000..1ed1879c616
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/shloop.c b/gcc/testsuite/gcc.c-torture/unsorted/shloop.c
new file mode 100644
index 00000000000..f4c9366394a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/shm.c b/gcc/testsuite/gcc.c-torture/unsorted/shm.c
new file mode 100644
index 00000000000..b667b26abe9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/shm.c
@@ -0,0 +1,5 @@
+foo (int *p)
+{
+  int a = *p;
+  return a >> 24;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/signext.c b/gcc/testsuite/gcc.c-torture/unsorted/signext.c
new file mode 100644
index 00000000000..2724098d031
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/signext2.c b/gcc/testsuite/gcc.c-torture/unsorted/signext2.c
new file mode 100644
index 00000000000..d2eb6370df8
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sim.c b/gcc/testsuite/gcc.c-torture/unsorted/sim.c
new file mode 100644
index 00000000000..e8c4fb42f53
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sim.c
@@ -0,0 +1,7 @@
+main ()
+{
+  int i;
+
+  for (i = 1;  i < 10000; i++)
+    ;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/simple.c b/gcc/testsuite/gcc.c-torture/unsorted/simple.c
new file mode 100644
index 00000000000..614acba82d9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/simple.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/sne.c b/gcc/testsuite/gcc.c-torture/unsorted/sne.c
new file mode 100644
index 00000000000..6844a6e53b9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sne.c
@@ -0,0 +1,4 @@
+foo (double a)
+{
+  return (a != 0);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/sound.c b/gcc/testsuite/gcc.c-torture/unsorted/sound.c
new file mode 100644
index 00000000000..be727e3febb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sparcbug.c b/gcc/testsuite/gcc.c-torture/unsorted/sparcbug.c
new file mode 100644
index 00000000000..cd42a86cccc
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sparcbug.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  int b = a;
+  return b + 8762345;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/speed.c b/gcc/testsuite/gcc.c-torture/unsorted/speed.c
new file mode 100644
index 00000000000..d61407e321d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/speed.c
@@ -0,0 +1,8 @@
+main ()
+{
+  int i;
+
+  for (i = 5000000; i >=0; i--)
+    {
+    }
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/stor.c b/gcc/testsuite/gcc.c-torture/unsorted/stor.c
new file mode 100644
index 00000000000..57981eff5a6
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/store0.c b/gcc/testsuite/gcc.c-torture/unsorted/store0.c
new file mode 100644
index 00000000000..3b7b16ef3bc
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/store0.c
@@ -0,0 +1,4 @@
+foo (int *p)
+{
+  p[10] = 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/storecc.c b/gcc/testsuite/gcc.c-torture/unsorted/storecc.c
new file mode 100644
index 00000000000..11634691091
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/str.c b/gcc/testsuite/gcc.c-torture/unsorted/str.c
new file mode 100644
index 00000000000..d2dec4b2303
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/stru.c b/gcc/testsuite/gcc.c-torture/unsorted/stru.c
new file mode 100644
index 00000000000..042c5221784
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/structret.c b/gcc/testsuite/gcc.c-torture/unsorted/structret.c
new file mode 100644
index 00000000000..9c705d4c0a2
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/stuct.c b/gcc/testsuite/gcc.c-torture/unsorted/stuct.c
new file mode 100644
index 00000000000..bf7e2329bd9
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/stuct.c
@@ -0,0 +1,16 @@
+struct foo
+{
+  int a, b, c;
+  int arr[10000000];
+};
+
+struct foo s, ss;
+
+main ()
+{
+
+  s.b = 2;
+  s.c = 3;
+  ss.b = 2;
+  ss.c = 3;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/sub32.c b/gcc/testsuite/gcc.c-torture/unsorted/sub32.c
new file mode 100644
index 00000000000..93114d96cd7
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sub32.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a + 32;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/subcc.c b/gcc/testsuite/gcc.c-torture/unsorted/subcc.c
new file mode 100644
index 00000000000..d50114eee42
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/subcse.c b/gcc/testsuite/gcc.c-torture/unsorted/subcse.c
new file mode 100644
index 00000000000..0a10991f18a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/sym.c b/gcc/testsuite/gcc.c-torture/unsorted/sym.c
new file mode 100644
index 00000000000..8a0fe323b03
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/sym.c
@@ -0,0 +1,4 @@
+foo ()
+{
+  return (int) &foo;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/symconst.c b/gcc/testsuite/gcc.c-torture/unsorted/symconst.c
new file mode 100644
index 00000000000..7add218108e
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/symconst.c
@@ -0,0 +1,4 @@
+foo ()
+{
+  return (int)foo;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/t.c b/gcc/testsuite/gcc.c-torture/unsorted/t.c
new file mode 100644
index 00000000000..48095e7c38b
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/test-flow.c b/gcc/testsuite/gcc.c-torture/unsorted/test-flow.c
new file mode 100644
index 00000000000..01ec724eb2f
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/test-loop.c b/gcc/testsuite/gcc.c-torture/unsorted/test-loop.c
new file mode 100644
index 00000000000..d441dde0ca9
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/test.c b/gcc/testsuite/gcc.c-torture/unsorted/test.c
new file mode 100644
index 00000000000..46e830a3521
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/test.c
@@ -0,0 +1,6 @@
+foo (a)
+{
+  if (a & 38)
+    return 1;
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/time.c b/gcc/testsuite/gcc.c-torture/unsorted/time.c
new file mode 100644
index 00000000000..7e22681d98b
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/time.c
@@ -0,0 +1,7 @@
+main ()
+{
+  int i;
+  for (i = 3000000; --i;)
+    {
+    }
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/tmp.c b/gcc/testsuite/gcc.c-torture/unsorted/tmp.c
new file mode 100644
index 00000000000..463d9fb530d
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/tmp.c
@@ -0,0 +1,5 @@
+foo (a, b)
+{
+  return (a - b) == 0;
+}
+
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/trivial.c b/gcc/testsuite/gcc.c-torture/unsorted/trivial.c
new file mode 100644
index 00000000000..e9665cd8dd7
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/trivial.c
@@ -0,0 +1 @@
+foo () {}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/trunc.c b/gcc/testsuite/gcc.c-torture/unsorted/trunc.c
new file mode 100644
index 00000000000..dee0e158728
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/u.c b/gcc/testsuite/gcc.c-torture/unsorted/u.c
new file mode 100644
index 00000000000..7fc0dda3784
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/u.c
@@ -0,0 +1 @@
+foo (a, b) { return a % b; }
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/udconvert.c b/gcc/testsuite/gcc.c-torture/unsorted/udconvert.c
new file mode 100644
index 00000000000..31b494fe08a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/udivmod4.c b/gcc/testsuite/gcc.c-torture/unsorted/udivmod4.c
new file mode 100644
index 00000000000..40d2fa8d07c
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/uns.c b/gcc/testsuite/gcc.c-torture/unsorted/uns.c
new file mode 100644
index 00000000000..314704f89d3
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/uns.c
@@ -0,0 +1,5 @@
+foo (a)
+{
+  if ((unsigned) a < 234)
+    return 1;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/uns_tst.c b/gcc/testsuite/gcc.c-torture/unsorted/uns_tst.c
new file mode 100644
index 00000000000..e34ffaf30eb
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/unsorted.exp b/gcc/testsuite/gcc.c-torture/unsorted/unsorted.exp
new file mode 100644
index 00000000000..a586170a48a
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/uuarg.c b/gcc/testsuite/gcc.c-torture/unsorted/uuarg.c
new file mode 100644
index 00000000000..8928b3e0768
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/v.c b/gcc/testsuite/gcc.c-torture/unsorted/v.c
new file mode 100644
index 00000000000..87ac00aef64
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/w.c b/gcc/testsuite/gcc.c-torture/unsorted/w.c
new file mode 100644
index 00000000000..1acfe1512a5
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/ww.c b/gcc/testsuite/gcc.c-torture/unsorted/ww.c
new file mode 100644
index 00000000000..657f8c6b839
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/x.c b/gcc/testsuite/gcc.c-torture/unsorted/x.c
new file mode 100644
index 00000000000..baf98960cfd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xb.c b/gcc/testsuite/gcc.c-torture/unsorted/xb.c
new file mode 100644
index 00000000000..09087ccf387
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xbg.c b/gcc/testsuite/gcc.c-torture/unsorted/xbg.c
new file mode 100644
index 00000000000..b600964d420
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xc.c b/gcc/testsuite/gcc.c-torture/unsorted/xc.c
new file mode 100644
index 00000000000..aed06a04ecd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xcsebug.c b/gcc/testsuite/gcc.c-torture/unsorted/xcsebug.c
new file mode 100644
index 00000000000..614a6e80ebf
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xdi.c b/gcc/testsuite/gcc.c-torture/unsorted/xdi.c
new file mode 100644
index 00000000000..413dd6cf84d
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xfoo.c b/gcc/testsuite/gcc.c-torture/unsorted/xfoo.c
new file mode 100644
index 00000000000..da879d2aa13
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xfoo.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return (a & ~0xfff) == 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/xi.c b/gcc/testsuite/gcc.c-torture/unsorted/xi.c
new file mode 100644
index 00000000000..54b42c5a377
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xlop.c b/gcc/testsuite/gcc.c-torture/unsorted/xlop.c
new file mode 100644
index 00000000000..6506bfd3415
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xmtst.c b/gcc/testsuite/gcc.c-torture/unsorted/xmtst.c
new file mode 100644
index 00000000000..ca78fcaac12
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xneg.c b/gcc/testsuite/gcc.c-torture/unsorted/xneg.c
new file mode 100644
index 00000000000..ff5b8503482
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xneg.c
@@ -0,0 +1,5 @@
+foo (a)
+     double a;
+{
+  return -a;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/xopt.c b/gcc/testsuite/gcc.c-torture/unsorted/xopt.c
new file mode 100644
index 00000000000..b1a50f86cef
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xor.c b/gcc/testsuite/gcc.c-torture/unsorted/xor.c
new file mode 100644
index 00000000000..435f2231e64
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xor.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return ~(a ^ ~123);
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/xorn.c b/gcc/testsuite/gcc.c-torture/unsorted/xorn.c
new file mode 100644
index 00000000000..d7b75f936bd
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xp.c b/gcc/testsuite/gcc.c-torture/unsorted/xp.c
new file mode 100644
index 00000000000..139335c0287
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xp.c
@@ -0,0 +1,4 @@
+foo (a)
+{
+  return a & 255;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/xpp.c b/gcc/testsuite/gcc.c-torture/unsorted/xpp.c
new file mode 100644
index 00000000000..daf3399a3f4
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xs.c b/gcc/testsuite/gcc.c-torture/unsorted/xs.c
new file mode 100644
index 00000000000..24f773e7577
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xsh.c b/gcc/testsuite/gcc.c-torture/unsorted/xsh.c
new file mode 100644
index 00000000000..9ba0b6c9e02
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xxs.c b/gcc/testsuite/gcc.c-torture/unsorted/xxs.c
new file mode 100644
index 00000000000..1757f976008
--- /dev/null
+++ b/gcc/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/testsuite/gcc.c-torture/unsorted/xz.c b/gcc/testsuite/gcc.c-torture/unsorted/xz.c
new file mode 100644
index 00000000000..97a1d1e2cdc
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xz.c
@@ -0,0 +1,4 @@
+foo (int *p)
+{
+  *p = (unsigned short) *p;
+}
diff --git a/gcc/testsuite/gcc.c-torture/unsorted/xzz.c b/gcc/testsuite/gcc.c-torture/unsorted/xzz.c
new file mode 100644
index 00000000000..f1972b6c618
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/unsorted/xzz.c
@@ -0,0 +1,4 @@
+foo (a, b)
+{
+  return a >> (char) b;
+}
diff --git a/gcc/testsuite/gcc.dg/README b/gcc/testsuite/gcc.dg/README
new file mode 100644
index 00000000000..6f14899edf9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/README
@@ -0,0 +1,16 @@
+Notes for testsuite/gcc.dg.
+
+1) There should be only one driver, dg.exp.
+
+2) Try to organize the tests by topic using file name prefixes.
+
+   Eg: All bitfield tests are named "bf-*.c".
+
+   This lets the person running the tests choose particular sets of tests to
+   run easily (using wildcards).
+
+   Eg: make check RUNTESTFLAGS='dg.exp=bf-*.c'
+
+3) Remember DOS file name restrictions (8.3).  Sigh.
+
+4) Send bugs, comments, etc. to dje@cygnus.com.
\ No newline at end of file
diff --git a/gcc/testsuite/gcc.dg/bf-spl1.c b/gcc/testsuite/gcc.dg/bf-spl1.c
new file mode 100644
index 00000000000..df3f4817043
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/bf-spl1.c
@@ -0,0 +1,58 @@
+/* { dg-do run { target m68k-*-* sparc-*-* } } */
+/* { dg-options { -m68000 -O2 } { target m68k-*-* } } */
+/* { dg-options { -O2 } { target sparc-*-* } } */
+
+typedef SFtype __attribute__ ((mode (SF)));
+typedef DFtype __attribute__ ((mode (DF)));
+
+typedef int HItype __attribute__ ((mode (HI)));
+typedef int SItype __attribute__ ((mode (SI)));
+typedef int DItype __attribute__ ((mode (DI)));
+
+typedef unsigned int UHItype __attribute__ ((mode (HI)));
+typedef unsigned int USItype __attribute__ ((mode (SI)));
+typedef unsigned int UDItype __attribute__ ((mode (DI)));
+
+typedef UDItype fractype;
+typedef USItype halffractype;
+typedef DFtype FLO_type;
+typedef DItype intfrac;
+
+
+typedef union
+{
+  long long foo;
+  FLO_type value;
+  struct
+    {
+      fractype fraction:52 __attribute__ ((packed));
+      unsigned int exp:11 __attribute__ ((packed));
+      unsigned int sign:1 __attribute__ ((packed));
+    }
+  bits;
+} FLO_union_type;
+
+void foo (long long a);
+long long x; 
+
+void
+pack_d ()
+{
+  FLO_union_type dst = { 0x0123456789abcdefLL };
+
+  x = dst.bits.fraction;
+}
+
+main ()
+{
+  pack_d ();
+  foo (x);
+  return 0;
+}
+
+void
+foo (long long a)
+{
+  if (a != 0x0123456789abcLL)
+    abort ();
+}
diff --git a/gcc/testsuite/gcc.dg/cpp-mi.c b/gcc/testsuite/gcc.dg/cpp-mi.c
new file mode 100644
index 00000000000..f667d0c4b9d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/cpp-mi.c
@@ -0,0 +1,34 @@
+/* Test "ignore redundant include" facility.
+   This doesn't test for the case where the file is opened, and then ignored
+   (the file shouldn't have even been opened).  That would require tracing
+   system calls.  It could be done on some systems however.  */
+
+/* We have to test two cases: C comments at the top and C++ comments
+   at the top.  */
+
+/*
+{ dg-do preprocess }
+{ dg-options "-Wp,-lang-c-c++-comments" }
+*/
+
+#include "cpp-mic.h"
+#include "cpp-mic.h"
+
+#include "cpp-micc.h"
+#include "cpp-micc.h"
+
+main ()
+{
+}
+
+/*
+   { dg-final { if ![file exists cpp-mi.i] { return }		} }
+
+   { dg-final { set tmp [grep cpp-mi.i cpp-micc? line]		} }
+   { dg-final { # send_user "$tmp\n" } }
+   { dg-final { if [regexp "^{\[0-9\]+ cpp-mic} {\[0-9\]+ cpp-micc}$" $tmp] \{ } }
+   { dg-final {     pass "cpp-mi.c: redundant include check"	} }
+   { dg-final { \} else \{					} }
+   { dg-final {     fail "cpp-mi.c: redundant include check"	} }
+   { dg-final { \}						} }
+*/
diff --git a/gcc/testsuite/gcc.dg/cpp-mic.h b/gcc/testsuite/gcc.dg/cpp-mic.h
new file mode 100644
index 00000000000..bae9d8b6db7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/cpp-mic.h
@@ -0,0 +1,10 @@
+/* Redundant header include test with C comments at top.  */
+
+#ifndef CPP_MIC_H
+#define CPP_MIC_H
+
+int a;
+
+#endif
+
+/* And at the end too!  */
diff --git a/gcc/testsuite/gcc.dg/cpp-micc.h b/gcc/testsuite/gcc.dg/cpp-micc.h
new file mode 100644
index 00000000000..52c9dccca89
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/cpp-micc.h
@@ -0,0 +1,10 @@
+// Redundant header include test with C comments at top.
+
+#ifndef CPP_MICC_H
+#define CPP_MICC_H
+
+int a;
+
+#endif
+
+// And at the end too!
diff --git a/gcc/testsuite/gcc.dg/dg.exp b/gcc/testsuite/gcc.dg/dg.exp
new file mode 100644
index 00000000000..6edb5dcae01
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dg.exp
@@ -0,0 +1,69 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# GCC testsuite that uses the `dg.exp' driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Utility for scanning compiler result, invoked via dg-final.
+# Call pass if pattern is present, otherwise fail.
+proc scan-assembler { testcase pattern } {
+    global subdir
+
+    set fd [open [file rootname $testcase].s r]
+    set text [read $fd]
+    close $fd
+
+    if [regexp -- $pattern $text] {
+	pass "$subdir/$testcase scan-assembler"
+    } else {
+	fail "$subdir/$testcase scan-assembler"
+    }
+}
+
+# Call pass if pattern is not present, otherwise fail.
+proc scan-assembler-not { testcase pattern } {
+    global subdir
+
+    set fd [open [file rootname $testcase].s r]
+    set text [read $fd]
+    close $fd
+
+    if ![regexp -- $pattern $text] {
+	pass "$subdir/$testcase scan-assembler-not"
+    } else {
+	fail "$subdir/$testcase scan-assembler-not"
+    }
+}
+
+# If a testcase doesn't have special options, use these.
+global DEFAULT_CFLAGS
+if ![info exists DEFAULT_CFLAGS] then {
+    set DEFAULT_CFLAGS " -ansi -pedantic-errors"
+}
+
+# Initialize `dg'.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] "" $DEFAULT_CFLAGS
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gcc.dg/dll-1.c b/gcc/testsuite/gcc.dg/dll-1.c
new file mode 100644
index 00000000000..72c6ba5b24e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dll-1.c
@@ -0,0 +1,9 @@
+/* { dg-do compile { target arm*-*-pe* } } */
+/* { dg-options -mno-nop-fun-dllimport } */
+
+__declspec (dllimport) void imp ();
+
+__declspec (dllexport) void exp () { imp (); }
+
+/* { dg-final { scan-assembler dll-1.c "__imp_imp.*\.section\[ \t\]*.drectve\n\[^\n\]*-export:exp" } } */
+/* { dg-final { scan-assembler-not dll-1.c "__imp_exp" } } */
diff --git a/gcc/testsuite/gcc.dg/dll-2.c b/gcc/testsuite/gcc.dg/dll-2.c
new file mode 100644
index 00000000000..e49f6e2027d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dll-2.c
@@ -0,0 +1,23 @@
+/* These dllimport and dllexport appearing for a symbol.
+   The desired behaviour is that if both dllimport
+   and dllexport appear (in either order) the result is dllexport.
+
+   Microsoft's MSVC 2.0 allows dllimport followed by dllexport for variables,
+   but does not allow dllexport followed by dllimport.
+
+   In C, it's ok to redeclare a variable so this works for variables
+   and functions.  In C++, it only works for functions.  */
+
+/* { dg-do compile { target arm*-*-pe* } } */
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();
+
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();
+
+__declspec (dllimport) int bar1;
+__declspec (dllexport) int bar1;
+
+__declspec (dllexport) int bar2;
+__declspec (dllimport) int bar2;
diff --git a/gcc/testsuite/gcc.dg/dll-3.c b/gcc/testsuite/gcc.dg/dll-3.c
new file mode 100644
index 00000000000..4976ebbbcc6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dll-3.c
@@ -0,0 +1,15 @@
+/* Ensure dllexport overrides dllimport.  */
+
+/* { dg-do compile { target arm*-*-pe* } } */
+
+__declspec (dllimport) int foo1 ();
+__declspec (dllexport) int foo1 ();
+
+__declspec (dllexport) int foo2 ();
+__declspec (dllimport) int foo2 ();
+
+__declspec (dllexport) int foo1 () { return foo2 (); }
+__declspec (dllexport) int foo2 () { return foo1 (); }
+
+/* { dg-final { scan-assembler dll-3.c "\.section\[ \t\]*\.drectve\n\[^\n\]*-export:foo1.*\.section\[ \t\]*\.drectve\n\[^\n\]*-export:foo2" } } */
+/* { dg-final { scan-assembler-not dll-3.c "(__imp_foo1|__imp_foo2)" } } */
diff --git a/gcc/testsuite/gcc.dg/dll-4.c b/gcc/testsuite/gcc.dg/dll-4.c
new file mode 100644
index 00000000000..ae617861951
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/dll-4.c
@@ -0,0 +1,13 @@
+/* { dg-do compile { target arm*-*-pe* } } */
+
+__declspec (dllimport) int foo1;
+int foo1;
+
+__declspec (dllimport) int foo2;
+int foo2 = 5;
+
+int f () { return foo1 + foo2; }
+
+/* FIXME: We should scan the output of nm for this case.  */
+/* { dg-final { scan-assembler dll-4.c "(\.comm\[ \t\]*foo1.*\nfoo2:|\nfoo2:.*\.comm\[ \t\]*foo1)" } } */
+/* { dg-final { scan-assembler-not dll-4.c "__imp_" } } */
diff --git a/gcc/testsuite/gcc.dg/splet-1.c b/gcc/testsuite/gcc.dg/splet-1.c
new file mode 100644
index 00000000000..03dbb2e3a3c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/splet-1.c
@@ -0,0 +1,21 @@
+/* Test inl-sparc.h.  */
+
+/* { dg-do run { target sparclet-*-* } } */
+/* { dg-options -mcpu=sparclet } */
+
+#include <inl-sparc.h>
+
+main ()
+{
+  int a,b;
+
+  a = scan (1, 2);
+  if (a != 3)
+    abort ();
+
+  b = shuffle (4, 5);
+  if (b != 6)
+    abort ();
+
+  exit (0);
+}
diff --git a/gcc/testsuite/gcc.dg/struct-ret-1.c b/gcc/testsuite/gcc.dg/struct-ret-1.c
new file mode 100644
index 00000000000..f581aad07d2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/struct-ret-1.c
@@ -0,0 +1,45 @@
+/* { dg-do run { target hppa*-*-* } } */
+/* { dg-options { -O2 } { target hppa*-*-* } } */
+typedef struct {
+        int             x;
+        int             y;
+}               point_t;
+
+int main(int argc, char *argv[]);
+int printPoints(point_t a, point_t b);
+point_t toPoint(int x1, int y1);
+
+int
+main(int argc, char *argv[])
+{
+
+        if (printPoints(toPoint(0, 0), toPoint(1000, 1000)) != 1)
+                abort();
+        else
+                exit();
+
+        return 0;
+}
+
+int
+printPoints(point_t a, point_t b)
+{
+        if (a.x != 0
+            || a.y != 0
+            || b.x != 1000
+            || b.y != 1000)
+                return 0;
+        else
+                return 1;
+}
+
+point_t
+toPoint(int x1, int y1)
+{
+        point_t         p;
+
+        p.x = x1;
+        p.y = y1;
+
+        return p;
+}
diff --git a/gcc/testsuite/gcc.failure/940409-1.c b/gcc/testsuite/gcc.failure/940409-1.c
new file mode 100644
index 00000000000..3c945dab7fb
--- /dev/null
+++ b/gcc/testsuite/gcc.failure/940409-1.c
@@ -0,0 +1,2 @@
+int f (register struct S {volatile int field;} arg);
+int g (register struct S { int volatile member; });
diff --git a/gcc/testsuite/gcc.failure/940409-1.cexp b/gcc/testsuite/gcc.failure/940409-1.cexp
new file mode 100644
index 00000000000..aac01277616
--- /dev/null
+++ b/gcc/testsuite/gcc.failure/940409-1.cexp
@@ -0,0 +1,6 @@
+# gcc doesn't handle compile/940409-1.cexp properly, but it's an obscure bug
+# so rather than constantly seeing it fail, just record it as expected to
+# fail.
+
+set torture_compile_xfail "*-*-*"
+return 0 ;# `0' says we didn't handle the testcase ourselves so continue
diff --git a/gcc/testsuite/gcc.failure/failure.exp b/gcc/testsuite/gcc.failure/failure.exp
new file mode 100644
index 00000000000..bfd9f3487ea
--- /dev/null
+++ b/gcc/testsuite/gcc.failure/failure.exp
@@ -0,0 +1,58 @@
+#
+# 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.
+#
+
+#
+# The main logic is in ../lib/c-torture.exp. This was done to eliminate
+# redundant code that otherwise lived in each of these driver files.
+#
+foreach testcase [glob -nocomplain $srcdir/$subdir/*.c] {
+    
+    # let c-torture.exp figure out the path. this lets users add new
+    # special tests without having to remeber to use $srcdir/$subdir
+    
+    if [file exists [file rootname $testcase].exp] then {
+	verbose "INFO:\"[file rootname $testcase].exp\"exists, skipping test" 1
+	continue
+    } else {
+	c-torture [file tail $testcase]
+    }
+}
+
diff --git a/gcc/testsuite/gcc.misc-tests/Makefile.in b/gcc/testsuite/gcc.misc-tests/Makefile.in
new file mode 100644
index 00000000000..e6209dbc6c2
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/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/testsuite/gcc.misc-tests/acker1.c b/gcc/testsuite/gcc.misc-tests/acker1.c
new file mode 100644
index 00000000000..9e77e42bedd
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/acker1.c
@@ -0,0 +1,20 @@
+int acker(int, int);
+
+void main()
+{
+    acker(3,6);
+    /* */
+    exit(0);
+    /* */
+}
+
+int
+acker(int x,int y)
+{
+    if (x==0)
+	return(y+1);
+    else if (y==0)
+	return(acker(x-1,1));
+    else
+	return(acker(x-1, acker(x, y-1)));
+}
diff --git a/gcc/testsuite/gcc.misc-tests/acker1.exp b/gcc/testsuite/gcc.misc-tests/acker1.exp
new file mode 100644
index 00000000000..3462d66bbc4
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/acker1.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase acker1.c $run $groups
diff --git a/gcc/testsuite/gcc.misc-tests/configure.in b/gcc/testsuite/gcc.misc-tests/configure.in
new file mode 100644
index 00000000000..e4cc69d249e
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/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/testsuite/gcc.misc-tests/dg-1.c b/gcc/testsuite/gcc.misc-tests/dg-1.c
new file mode 100644
index 00000000000..319f8a20a7b
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-1.c
@@ -0,0 +1,14 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do compile } */
+
+main () { return 0; }
+
+/* { dg-final { if ![file exists dg-1.s] { fail "dg-1.c (compile)"; return; } } } */
+
+/* { dg-final { set tmp [grep dg-1.s main line]			} } */
+/* { dg-final { if ![string match "" $tmp] \{			} } */
+/* { dg-final {     pass "dg-1.c (main function present)"	} } */
+/* { dg-final { \} else \{					} } */
+/* { dg-final {     fail "dg-1.c (main function not present)"	} } */
+/* { dg-final { \}						} } */
diff --git a/gcc/testsuite/gcc.misc-tests/dg-10.c b/gcc/testsuite/gcc.misc-tests/dg-10.c
new file mode 100644
index 00000000000..6d7b3441623
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-10.c
@@ -0,0 +1,12 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-options "-Wall" } */
+
+/* FIXME: we want to test dg-lose here.  Anyone know of a good way to
+   crash the compiler?  */
+
+int
+main (int argc, char *argv[])
+{
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.misc-tests/dg-11.c b/gcc/testsuite/gcc.misc-tests/dg-11.c
new file mode 100644
index 00000000000..e4f86ba2b12
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-11.c
@@ -0,0 +1,9 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run { target sparc-sun-solaris2* } } */
+/* The \n is left out of the pattern because tcl's exec will remove it.  */
+/* { dg-output {^Hello world[.]$} } */
+
+#include <stdio.h>
+
+main () { printf ("Hello world.\n"); return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-12.c b/gcc/testsuite/gcc.misc-tests/dg-12.c
new file mode 100644
index 00000000000..ad0870d88cc
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-12.c
@@ -0,0 +1,9 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run { target foo-bar-eh } } */
+/* The \n is left out of the pattern because tcl's exec will remove it.  */
+/* { dg-output {^Hello world[.]$} } */
+
+#include <stdio.h>
+
+main () { printf ("Hello world.\n"); return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-2.c b/gcc/testsuite/gcc.misc-tests/dg-2.c
new file mode 100644
index 00000000000..bb40387e632
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-2.c
@@ -0,0 +1,11 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do assemble } */
+
+main () { return 0; }
+
+/* { dg-final { if [file exists dg-2.o] \{			} } */
+/* { dg-final {     pass "dg-2.c (assemble: produce .o test)"	} } */
+/* { dg-final { \} else \{					} } */
+/* { dg-final {     fail "dg-2.c (assemble: produce .o test)"	} } */
+/* { dg-final { \}						} } */
diff --git a/gcc/testsuite/gcc.misc-tests/dg-3.c b/gcc/testsuite/gcc.misc-tests/dg-3.c
new file mode 100644
index 00000000000..017ab279f8e
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-3.c
@@ -0,0 +1,11 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do link } */
+
+main () { return 0; }
+
+/* { dg-final { if [file exists a.out] \{			} } */
+/* { dg-final {     pass "dg-2.c (link: produce a.out test)"	} } */
+/* { dg-final { \} else \{					} } */
+/* { dg-final {     fail "dg-2.c (link: produce a.out test)"	} } */
+/* { dg-final { \}						} } */
diff --git a/gcc/testsuite/gcc.misc-tests/dg-4.c b/gcc/testsuite/gcc.misc-tests/dg-4.c
new file mode 100644
index 00000000000..806bdfbf91a
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-4.c
@@ -0,0 +1,5 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run } */
+
+main () { return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-5.c b/gcc/testsuite/gcc.misc-tests/dg-5.c
new file mode 100644
index 00000000000..33a5b4e893b
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-5.c
@@ -0,0 +1,9 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run } */
+/* The \n is left out of the pattern because tcl's exec will remove it.  */
+/* { dg-output {^Hello world[.]$} } */
+
+#include <stdio.h>
+
+main () { printf ("Hello world.\n"); return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-6.c b/gcc/testsuite/gcc.misc-tests/dg-6.c
new file mode 100644
index 00000000000..f9273f873ee
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-6.c
@@ -0,0 +1,9 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run { target *-*-* } } */
+/* The \n is left out of the pattern because tcl's exec will remove it.  */
+/* { dg-output {^Hello world[.]$} { xfail *-*-* } } */
+
+#include <stdio.h>
+
+main () { printf ("Hello world (oops).\n"); return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-7.c b/gcc/testsuite/gcc.misc-tests/dg-7.c
new file mode 100644
index 00000000000..068749f71b2
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-7.c
@@ -0,0 +1,5 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-do run { xfail *-*-* } } */
+
+main () { abort (); return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-8.c b/gcc/testsuite/gcc.misc-tests/dg-8.c
new file mode 100644
index 00000000000..63a5b0e73fa
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-8.c
@@ -0,0 +1,9 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-options "-Wall" } */
+/* { dg-do run } */
+/* { dg-excess-errors "excess errors" } */
+
+/* should get warning about defaulting return type - excess error */
+
+main () { return 0; }
diff --git a/gcc/testsuite/gcc.misc-tests/dg-9.c b/gcc/testsuite/gcc.misc-tests/dg-9.c
new file mode 100644
index 00000000000..43b7ab34b0d
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-9.c
@@ -0,0 +1,15 @@
+/* Test the tester.  */
+/* { dg-prms-id 42 } */
+/* { dg-options "-Wall" } */
+
+f ()
+{	/* { dg-warning "return-type" "warning test" } */
+}	/* { dg-warning "control reaches end" "warning test" } */
+
+main (int argc, char *argv[])
+{		/* { dg-warning "return-type" "warning test" } */
+  foo a;	/* { dg-error "syntax" "error test" } */
+		/* { dg-bogus "foobar" "bogus fail test" } */
+
+  return a;	/* { dg-bogus "undeclared|identifier|appears" "bogus pass test" { xfail *-*-* } } */
+}		/* { dg-warning "control reaches end" "warning test" } */
diff --git a/gcc/testsuite/gcc.misc-tests/dg-test.exp b/gcc/testsuite/gcc.misc-tests/dg-test.exp
new file mode 100644
index 00000000000..42364252b63
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dg-test.exp
@@ -0,0 +1,41 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# Test the dg.exp driver.
+# This is a testsuite tester tester.  As such we *want* to test things like
+# expected failure handling.  But expected failures must continually be
+# monitored and so in the normal case we create unnecessary work.  So only
+# run these tests if DG_TEST is defined to "yes".
+
+global DG_TEST
+if { ![info exists DG_TEST] || "$DG_TEST" != "yes" } {
+    return
+}
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Initialize harness.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/dg-*.c]] "" ""
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gcc.misc-tests/dhry.c b/gcc/testsuite/gcc.misc-tests/dhry.c
new file mode 100644
index 00000000000..ae29a693654
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dhry.c
@@ -0,0 +1,602 @@
+/*
+ ****************************************************************************
+ *
+ *                   "DHRYSTONE" Benchmark Program
+ *                   -----------------------------
+ *                                                                            
+ *  Version:    C, Version 2.1
+ *                                                                            
+ *  File:       dhry_1.c (part 2 of 3)
+ *
+ *  Date:       May 25, 1988
+ *
+ *  Author:     Reinhold P. Weicker
+ *
+ ****************************************************************************
+ */
+
+#include "dhry.h"
+
+/* Global Variables: */
+
+Rec_Pointer     Ptr_Glob,
+                Next_Ptr_Glob;
+int             Int_Glob;
+Boolean         Bool_Glob;
+char            Ch_1_Glob,
+                Ch_2_Glob;
+int             Arr_1_Glob [50];
+int             Arr_2_Glob [50] [50];
+
+extern char     *malloc ();
+Enumeration     Func_1 ();
+  /* forward declaration necessary since Enumeration may not simply be int */
+
+#ifndef REG
+        Boolean Reg = false;
+#define REG
+        /* REG becomes defined as empty */
+        /* i.e. no register variables   */
+#else
+        Boolean Reg = true;
+#endif
+
+/* variables for time measurement: */
+
+/*
+#ifdef TIMES
+struct tms      time_info;
+extern  int     times ();
+#endif
+*/           
+/*
+#ifdef TIME
+extern long     time();
+#endif
+*/
+#define Too_Small_Time 2
+                /* Measurements should last at least 2 seconds */
+
+long            Begin_Time,
+                End_Time,
+                User_Time;
+float           Microseconds,
+                Dhrystones_Per_Second;
+
+/* end of variables for time measurement */
+
+
+main ()
+/*****/
+
+  /* main program, corresponds to procedures        */
+  /* Main and Proc_0 in the Ada version             */
+{
+        One_Fifty       Int_1_Loc;
+  REG   One_Fifty       Int_2_Loc;
+        One_Fifty       Int_3_Loc;
+  REG   char            Ch_Index;
+        Enumeration     Enum_Loc;
+        Str_30          Str_1_Loc;
+        Str_30          Str_2_Loc;
+  REG   int             Run_Index;
+  REG   int             Number_Of_Runs;
+
+  /* Initializations */
+
+  Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+  Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
+
+  Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
+  Ptr_Glob->Discr                       = Ident_1;
+  Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
+  Ptr_Glob->variant.var_1.Int_Comp      = 40;
+  strcpy (Ptr_Glob->variant.var_1.Str_Comp, 
+          "DHRYSTONE PROGRAM, SOME STRING");
+  strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
+
+  Arr_2_Glob [8][7] = 10;
+        /* Was missing in published program. Without this statement,    */
+        /* Arr_2_Glob [8][7] would have an undefined value.             */
+        /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */
+        /* overflow may occur for this array element.                   */
+
+/*
+  printf ("\n");
+  printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n");
+  printf ("\n");
+*/
+  if (Reg)
+  {
+/*
+    printf ("Program compiled with 'register' attribute\n");
+    printf ("\n");
+*/
+  }
+  else
+  {
+/*
+    printf ("Program compiled without 'register' attribute\n");
+    printf ("\n");
+*/
+  }
+/*
+  printf ("Please give the number of runs through the benchmark: ");
+*/
+  {
+    int n;
+/*
+    scanf ("%d", &n);
+*/
+    Number_Of_Runs = n=1000;
+  }
+/*
+  printf ("\n");
+
+  printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs);
+*/
+
+  /***************/
+  /* Start timer */
+  /***************/
+
+/* 
+#ifdef TIMES
+  times (&time_info);
+  Begin_Time = (long) time_info.tms_utime;
+#endif
+#ifdef TIME
+  Begin_Time = time ( (long *) 0);
+#endif
+*/
+
+  for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
+  {
+
+    Proc_5();
+    Proc_4();
+      /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
+    Int_1_Loc = 2;
+    Int_2_Loc = 3;
+    strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
+    Enum_Loc = Ident_2;
+    Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
+      /* Bool_Glob == 1 */
+    while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
+    {
+      Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
+        /* Int_3_Loc == 7 */
+      Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
+        /* Int_3_Loc == 7 */
+      Int_1_Loc += 1;
+    } /* while */
+      /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+    Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
+      /* Int_Glob == 5 */
+    Proc_1 (Ptr_Glob);
+    for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
+                             /* loop body executed twice */
+    {
+      if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+          /* then, not executed */
+        {
+        Proc_6 (Ident_1, &Enum_Loc);
+        strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+        Int_2_Loc = Run_Index;
+        Int_Glob = Run_Index;
+        }
+    }
+      /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+    Int_2_Loc = Int_2_Loc * Int_1_Loc;
+    Int_1_Loc = Int_2_Loc / Int_3_Loc;
+    Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
+      /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
+    Proc_2 (&Int_1_Loc);
+      /* Int_1_Loc == 5 */
+
+  } /* loop "for Run_Index" */
+
+  /**************/
+  /* Stop timer */
+  /**************/
+ 
+/* 
+#ifdef TIMES
+  times (&time_info);
+  End_Time = (long) time_info.tms_utime;
+#endif
+#ifdef TIME
+  End_Time = time ( (long *) 0);
+#endif
+*/
+
+/*
+  printf ("Execution ends\n");
+  printf ("\n");
+  printf ("Final values of the variables used in the benchmark:\n");
+  printf ("\n");
+  printf ("Int_Glob:            %d\n", Int_Glob);
+  printf ("        should be:   %d\n", 5);
+  printf ("Bool_Glob:           %d\n", Bool_Glob);
+  printf ("        should be:   %d\n", 1);
+  printf ("Ch_1_Glob:           %c\n", Ch_1_Glob);
+  printf ("        should be:   %c\n", 'A');
+  printf ("Ch_2_Glob:           %c\n", Ch_2_Glob);
+  printf ("        should be:   %c\n", 'B');
+  printf ("Arr_1_Glob[8]:       %d\n", Arr_1_Glob[8]);
+  printf ("        should be:   %d\n", 7);
+  printf ("Arr_2_Glob[8][7]:    %d\n", Arr_2_Glob[8][7]);
+  printf ("        should be:   Number_Of_Runs + 10\n");
+  printf ("Ptr_Glob->\n");
+  printf ("  Ptr_Comp:          %d\n", (int) Ptr_Glob->Ptr_Comp);
+  printf ("        should be:   (implementation-dependent)\n");
+  printf ("  Discr:             %d\n", Ptr_Glob->Discr);
+  printf ("        should be:   %d\n", 0);
+  printf ("  Enum_Comp:         %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
+  printf ("        should be:   %d\n", 2);
+  printf ("  Int_Comp:          %d\n", Ptr_Glob->variant.var_1.Int_Comp);
+  printf ("        should be:   %d\n", 17);
+  printf ("  Str_Comp:          %s\n", Ptr_Glob->variant.var_1.Str_Comp);
+  printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
+  printf ("Next_Ptr_Glob->\n");
+  printf ("  Ptr_Comp:          %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
+  printf ("        should be:   (implementation-dependent), same as above\n");
+  printf ("  Discr:             %d\n", Next_Ptr_Glob->Discr);
+  printf ("        should be:   %d\n", 0);
+  printf ("  Enum_Comp:         %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
+  printf ("        should be:   %d\n", 1);
+  printf ("  Int_Comp:          %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
+  printf ("        should be:   %d\n", 18);
+  printf ("  Str_Comp:          %s\n",
+                                Next_Ptr_Glob->variant.var_1.Str_Comp);
+  printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
+  printf ("Int_1_Loc:           %d\n", Int_1_Loc);
+  printf ("        should be:   %d\n", 5);
+  printf ("Int_2_Loc:           %d\n", Int_2_Loc);
+  printf ("        should be:   %d\n", 13);
+  printf ("Int_3_Loc:           %d\n", Int_3_Loc);
+  printf ("        should be:   %d\n", 7);
+  printf ("Enum_Loc:            %d\n", Enum_Loc);
+  printf ("        should be:   %d\n", 1);
+  printf ("Str_1_Loc:           %s\n", Str_1_Loc);
+  printf ("        should be:   DHRYSTONE PROGRAM, 1'ST STRING\n");
+  printf ("Str_2_Loc:           %s\n", Str_2_Loc);
+  printf ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
+  printf ("\n");
+*/
+
+  User_Time = End_Time - Begin_Time;
+
+  if (User_Time < Too_Small_Time)
+  {
+/*
+    printf ("Measured time too small to obtain meaningful results\n");
+    printf ("Please increase number of runs\n");
+    printf ("\n");
+*/
+  }
+  else
+  {
+#ifdef TIME
+/*
+    Microseconds = (float) User_Time * Mic_secs_Per_Second 
+                        / (float) Number_Of_Runs;
+    Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time;
+*/
+#else
+/*
+    Microseconds = (float) User_Time * Mic_secs_Per_Second 
+                        / ((float) HZ * ((float) Number_Of_Runs));
+    Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs)
+                        / (float) User_Time;
+*/
+#endif
+/*
+    printf ("Microseconds for one run through Dhrystone: ");
+    printf ("%6.1f \n", Microseconds);
+    printf ("Dhrystones per Second:                      ");
+    printf ("%6.1f \n", Dhrystones_Per_Second);
+    printf ("\n");
+*/
+  }
+
+  exit (0);
+}
+
+
+Proc_1 (Ptr_Val_Par)
+/******************/
+
+REG Rec_Pointer Ptr_Val_Par;
+    /* executed once */
+{
+  REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;  
+                                        /* == Ptr_Glob_Next */
+  /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
+  /* corresponds to "rename" in Ada, "with" in Pascal           */
+  
+  structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); 
+  Ptr_Val_Par->variant.var_1.Int_Comp = 5;
+  Next_Record->variant.var_1.Int_Comp 
+        = Ptr_Val_Par->variant.var_1.Int_Comp;
+  Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
+  Proc_3 (&Next_Record->Ptr_Comp);
+    /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp 
+                        == Ptr_Glob->Ptr_Comp */
+  if (Next_Record->Discr == Ident_1)
+    /* then, executed */
+  {
+    Next_Record->variant.var_1.Int_Comp = 6;
+    Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, 
+           &Next_Record->variant.var_1.Enum_Comp);
+    Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
+    Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, 
+           &Next_Record->variant.var_1.Int_Comp);
+  }
+  else /* not executed */
+    structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
+} /* Proc_1 */
+
+
+Proc_2 (Int_Par_Ref)
+/******************/
+    /* executed once */
+    /* *Int_Par_Ref == 1, becomes 4 */
+
+One_Fifty   *Int_Par_Ref;
+{
+  One_Fifty  Int_Loc;  
+  Enumeration   Enum_Loc;
+
+  Int_Loc = *Int_Par_Ref + 10;
+  do /* executed once */
+    if (Ch_1_Glob == 'A')
+      /* then, executed */
+    {
+      Int_Loc -= 1;
+      *Int_Par_Ref = Int_Loc - Int_Glob;
+      Enum_Loc = Ident_1;
+    } /* if */
+  while (Enum_Loc != Ident_1); /* true */
+} /* Proc_2 */
+
+
+Proc_3 (Ptr_Ref_Par)
+/******************/
+    /* executed once */
+    /* Ptr_Ref_Par becomes Ptr_Glob */
+
+Rec_Pointer *Ptr_Ref_Par;
+
+{
+  if (Ptr_Glob != Null)
+    /* then, executed */
+    *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
+  Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
+} /* Proc_3 */
+
+
+Proc_4 () /* without parameters */
+/*******/
+    /* executed once */
+{
+  Boolean Bool_Loc;
+
+  Bool_Loc = Ch_1_Glob == 'A';
+  Bool_Glob = Bool_Loc | Bool_Glob;
+  Ch_2_Glob = 'B';
+} /* Proc_4 */
+
+
+Proc_5 () /* without parameters */
+/*******/
+    /* executed once */
+{
+  Ch_1_Glob = 'A';
+  Bool_Glob = false;
+} /* Proc_5 */
+
+
+        /* Procedure for the assignment of structures,          */
+        /* if the C compiler doesn't support this feature       */
+#ifdef  NOSTRUCTASSIGN
+memcpy (d, s, l)
+register char   *d;
+register char   *s;
+register int    l;
+{
+        while (l--) *d++ = *s++;
+}
+#endif
+
+
+/*
+ ****************************************************************************
+ *
+ *                   "DHRYSTONE" Benchmark Program
+ *                   -----------------------------
+ *                                                                            
+ *  Version:    C, Version 2.1
+ *                                                                            
+ *  File:       dhry_2.c (part 3 of 3)
+ *
+ *  Date:       May 25, 1988
+ *
+ *  Author:     Reinhold P. Weicker
+ *
+ ****************************************************************************
+ */
+
+#ifndef REG
+#define REG
+        /* REG becomes defined as empty */
+        /* i.e. no register variables   */
+#endif
+
+extern  int     Int_Glob;
+extern  char    Ch_1_Glob;
+
+
+Proc_6 (Enum_Val_Par, Enum_Ref_Par)
+/*********************************/
+    /* executed once */
+    /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
+
+Enumeration  Enum_Val_Par;
+Enumeration *Enum_Ref_Par;
+{
+  *Enum_Ref_Par = Enum_Val_Par;
+  if (! Func_3 (Enum_Val_Par))
+    /* then, not executed */
+    *Enum_Ref_Par = Ident_4;
+  switch (Enum_Val_Par)
+  {
+    case Ident_1: 
+      *Enum_Ref_Par = Ident_1;
+      break;
+    case Ident_2: 
+      if (Int_Glob > 100)
+        /* then */
+      *Enum_Ref_Par = Ident_1;
+      else *Enum_Ref_Par = Ident_4;
+      break;
+    case Ident_3: /* executed */
+      *Enum_Ref_Par = Ident_2;
+      break;
+    case Ident_4: break;
+    case Ident_5: 
+      *Enum_Ref_Par = Ident_3;
+      break;
+  } /* switch */
+} /* Proc_6 */
+
+
+Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
+/**********************************************/
+    /* executed three times                                      */ 
+    /* first call:      Int_1_Par_Val == 2, Int_2_Par_Val == 3,  */
+    /*                  Int_Par_Ref becomes 7                    */
+    /* second call:     Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
+    /*                  Int_Par_Ref becomes 17                   */
+    /* third call:      Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
+    /*                  Int_Par_Ref becomes 18                   */
+One_Fifty       Int_1_Par_Val;
+One_Fifty       Int_2_Par_Val;
+One_Fifty      *Int_Par_Ref;
+{
+  One_Fifty Int_Loc;
+
+  Int_Loc = Int_1_Par_Val + 2;
+  *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
+} /* Proc_7 */
+
+
+Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
+/*********************************************************************/
+    /* executed once      */
+    /* Int_Par_Val_1 == 3 */
+    /* Int_Par_Val_2 == 7 */
+Arr_1_Dim       Arr_1_Par_Ref;
+Arr_2_Dim       Arr_2_Par_Ref;
+int             Int_1_Par_Val;
+int             Int_2_Par_Val;
+{
+  REG One_Fifty Int_Index;
+  REG One_Fifty Int_Loc;
+
+  Int_Loc = Int_1_Par_Val + 5;
+  Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
+  Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
+  Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
+  for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
+    Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
+  Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
+  Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
+  Int_Glob = 5;
+} /* Proc_8 */
+
+
+Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
+/*************************************************/
+    /* executed three times                                         */
+    /* first call:      Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R'    */
+    /* second call:     Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C'    */
+    /* third call:      Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C'    */
+
+Capital_Letter   Ch_1_Par_Val;
+Capital_Letter   Ch_2_Par_Val;
+{
+  Capital_Letter        Ch_1_Loc;
+  Capital_Letter        Ch_2_Loc;
+
+  Ch_1_Loc = Ch_1_Par_Val;
+  Ch_2_Loc = Ch_1_Loc;
+  if (Ch_2_Loc != Ch_2_Par_Val)
+    /* then, executed */
+    return (Ident_1);
+  else  /* not executed */
+  {
+    Ch_1_Glob = Ch_1_Loc;
+    return (Ident_2);
+   }
+} /* Func_1 */
+
+
+Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
+/*************************************************/
+    /* executed once */
+    /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
+    /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
+
+Str_30  Str_1_Par_Ref;
+Str_30  Str_2_Par_Ref;
+{
+  REG One_Thirty        Int_Loc;
+      Capital_Letter    Ch_Loc;
+
+  Int_Loc = 2;
+  while (Int_Loc <= 2) /* loop body executed once */
+    if (Func_1 (Str_1_Par_Ref[Int_Loc],
+                Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
+      /* then, executed */
+    {
+      Ch_Loc = 'A';
+      Int_Loc += 1;
+    } /* if, while */
+  if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
+    /* then, not executed */
+    Int_Loc = 7;
+  if (Ch_Loc == 'R')
+    /* then, not executed */
+    return (true);
+  else /* executed */
+  {
+    if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
+      /* then, not executed */
+    {
+      Int_Loc += 7;
+      Int_Glob = Int_Loc;
+      return (true);
+    }
+    else /* executed */
+      return (false);
+  } /* if Ch_Loc */
+} /* Func_2 */
+
+
+Boolean Func_3 (Enum_Par_Val)
+/***************************/
+    /* executed once        */
+    /* Enum_Par_Val == Ident_3 */
+Enumeration Enum_Par_Val;
+{
+  Enumeration Enum_Loc;
+
+  Enum_Loc = Enum_Par_Val;
+  if (Enum_Loc == Ident_3)
+    /* then, executed */
+    return (true);
+  else /* not executed */
+    return (false);
+} /* Func_3 */
+
diff --git a/gcc/testsuite/gcc.misc-tests/dhry.exp b/gcc/testsuite/gcc.misc-tests/dhry.exp
new file mode 100644
index 00000000000..890f25018a8
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dhry.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase dhry.c $run $groups
diff --git a/gcc/testsuite/gcc.misc-tests/dhry.h b/gcc/testsuite/gcc.misc-tests/dhry.h
new file mode 100644
index 00000000000..8d42da0094d
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/dhry.h
@@ -0,0 +1,431 @@
+/*
+ ****************************************************************************
+ *
+ *                   "DHRYSTONE" Benchmark Program
+ *                   -----------------------------
+ *                                                                            
+ *  Version:    C, Version 2.1
+ *                                                                            
+ *  File:       dhry.h (part 1 of 3)
+ *
+ *  Date:       May 25, 1988
+ *
+ *  Author:     Reinhold P. Weicker
+ *                      Siemens AG, AUT E 51
+ *                      Postfach 3220
+ *                      8520 Erlangen
+ *                      Germany (West)
+ *                              Phone:  [+49]-9131-7-20330
+ *                                      (8-17 Central European Time)
+ *                              Usenet: ..!mcsun!unido!estevax!weicker
+ *
+ *              Original Version (in Ada) published in
+ *              "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
+ *              pp. 1013 - 1030, together with the statistics
+ *              on which the distribution of statements etc. is based.
+ *
+ *              In this C version, the following C library functions are used:
+ *              - strcpy, strcmp (inside the measurement loop)
+ *              - printf, scanf (outside the measurement loop)
+ *              In addition, Berkeley UNIX system calls "times ()" or "time ()"
+ *              are used for execution time measurement. For measurements
+ *              on other systems, these calls have to be changed.
+ *
+ *  Collection of Results:
+ *              Reinhold Weicker (address see above) and
+ *              
+ *              Rick Richardson
+ *              PC Research. Inc.
+ *              94 Apple Orchard Drive
+ *              Tinton Falls, NJ 07724
+ *                      Phone:  (201) 389-8963 (9-17 EST)               
+ *                      Usenet: ...!uunet!pcrat!rick
+ *
+ *      Please send results to Rick Richardson and/or Reinhold Weicker.
+ *      Complete information should be given on hardware and software used.
+ *      Hardware information includes: Machine type, CPU, type and size
+ *      of caches; for microprocessors: clock frequency, memory speed
+ *      (number of wait states).
+ *      Software information includes: Compiler (and runtime library)
+ *      manufacturer and version, compilation switches, OS version.
+ *      The Operating System version may give an indication about the
+ *      compiler; Dhrystone itself performs no OS calls in the measurement loop.
+ *
+ *      The complete output generated by the program should be mailed
+ *      such that at least some checks for correctness can be made.
+ *
+ ***************************************************************************
+ *
+ *  History:    This version C/2.1 has been made for two reasons:
+ *
+ *              1) There is an obvious need for a common C version of
+ *              Dhrystone, since C is at present the most popular system
+ *              programming language for the class of processors
+ *              (microcomputers, minicomputers) where Dhrystone is used most.
+ *              There should be, as far as possible, only one C version of
+ *              Dhrystone such that results can be compared without
+ *              restrictions. In the past, the C versions distributed
+ *              by Rick Richardson (Version 1.1) and by Reinhold Weicker
+ *              had small (though not significant) differences.
+ *
+ *              2) As far as it is possible without changes to the Dhrystone
+ *              statistics, optimizing compilers should be prevented from
+ *              removing significant statements.
+ *
+ *              This C version has been developed in cooperation with
+ *              Rick Richardson (Tinton Falls, NJ), it incorporates many
+ *              ideas from the "Version 1.1" distributed previously by
+ *              him over the UNIX network Usenet.
+ *              I also thank Chaim Benedelac (National Semiconductor),
+ *              David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
+ *              Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
+ *              for their help with comments on earlier versions of the
+ *              benchmark.
+ *
+ *  Changes:    In the initialization part, this version follows mostly
+ *              Rick Richardson's version distributed via Usenet, not the
+ *              version distributed earlier via floppy disk by Reinhold Weicker.
+ *              As a concession to older compilers, names have been made
+ *              unique within the first 8 characters.
+ *              Inside the measurement loop, this version follows the
+ *              version previously distributed by Reinhold Weicker.
+ *
+ *              At several places in the benchmark, code has been added,
+ *              but within the measurement loop only in branches that 
+ *              are not executed. The intention is that optimizing compilers
+ *              should be prevented from moving code out of the measurement
+ *              loop, or from removing code altogether. Since the statements
+ *              that are executed within the measurement loop have NOT been
+ *              changed, the numbers defining the "Dhrystone distribution"
+ *              (distribution of statements, operand types and locality)
+ *              still hold. Except for sophisticated optimizing compilers,
+ *              execution times for this version should be the same as
+ *              for previous versions.
+ *              
+ *              Since it has proven difficult to subtract the time for the
+ *              measurement loop overhead in a correct way, the loop check
+ *              has been made a part of the benchmark. This does have
+ *              an impact - though a very minor one - on the distribution
+ *              statistics which have been updated for this version.
+ *
+ *              All changes within the measurement loop are described
+ *              and discussed in the companion paper "Rationale for
+ *              Dhrystone version 2".
+ *
+ *              Because of the self-imposed limitation that the order and
+ *              distribution of the executed statements should not be
+ *              changed, there are still cases where optimizing compilers
+ *              may not generate code for some statements. To a certain
+ *              degree, this is unavoidable for small synthetic benchmarks.
+ *              Users of the benchmark are advised to check code listings
+ *              whether code is generated for all statements of Dhrystone.
+ *
+ *              Version 2.1 is identical to version 2.0 distributed via
+ *              the UNIX network Usenet in March 1988 except that it corrects
+ *              some minor deficiencies that were found by users of version 2.0.
+ *              The only change within the measurement loop is that a
+ *              non-executed "else" part was added to the "if" statement in
+ *              Func_3, and a non-executed "else" part removed from Proc_3.
+ *
+ ***************************************************************************
+ *
+ * Defines:     The following "Defines" are possible:
+ *              -DREG=register          (default: Not defined)
+ *                      As an approximation to what an average C programmer
+ *                      might do, the "register" storage class is applied
+ *                      (if enabled by -DREG=register)
+ *                      - for local variables, if they are used (dynamically)
+ *                        five or more times
+ *                      - for parameters if they are used (dynamically)
+ *                        six or more times
+ *                      Note that an optimal "register" strategy is
+ *                      compiler-dependent, and that "register" declarations
+ *                      do not necessarily lead to faster execution.
+ *              -DNOSTRUCTASSIGN        (default: Not defined)
+ *                      Define if the C compiler does not support
+ *                      assignment of structures.
+ *              -DNOENUMS               (default: Not defined)
+ *                      Define if the C compiler does not support
+ *                      enumeration types.
+ *              -DTIMES                 (default)
+ *              -DTIME
+ *                      The "times" function of UNIX (returning process times)
+ *                      or the "time" function (returning wallclock time)
+ *                      is used for measurement. 
+ *                      For single user machines, "time ()" is adequate. For
+ *                      multi-user machines where you cannot get single-user
+ *                      access, use the "times ()" function. If you have
+ *                      neither, use a stopwatch in the dead of night.
+ *                      "printf"s are provided marking the points "Start Timer"
+ *                      and "Stop Timer". DO NOT use the UNIX "time(1)"
+ *                      command, as this will measure the total time to
+ *                      run this program, which will (erroneously) include
+ *                      the time to allocate storage (malloc) and to perform
+ *                      the initialization.
+ *              -DHZ=nnn
+ *                      In Berkeley UNIX, the function "times" returns process
+ *                      time in 1/HZ seconds, with HZ = 60 for most systems.
+ *                      CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
+ *                      A VALUE.
+ *
+ ***************************************************************************
+ *
+ *  Compilation model and measurement (IMPORTANT):
+ *
+ *  This C version of Dhrystone consists of three files:
+ *  - dhry.h (this file, containing global definitions and comments)
+ *  - dhry_1.c (containing the code corresponding to Ada package Pack_1)
+ *  - dhry_2.c (containing the code corresponding to Ada package Pack_2)
+ *
+ *  The following "ground rules" apply for measurements:
+ *  - Separate compilation
+ *  - No procedure merging
+ *  - Otherwise, compiler optimizations are allowed but should be indicated
+ *  - Default results are those without register declarations
+ *  See the companion paper "Rationale for Dhrystone Version 2" for a more
+ *  detailed discussion of these ground rules.
+ *
+ *  For 16-Bit processors (e.g. 80186, 80286), times for all compilation
+ *  models ("small", "medium", "large" etc.) should be given if possible,
+ *  together with a definition of these models for the compiler system used.
+ *
+ **************************************************************************
+ *
+ *  Dhrystone (C version) statistics:
+ *
+ *  [Comment from the first distribution, updated for version 2.
+ *   Note that because of language differences, the numbers are slightly
+ *   different from the Ada version.]
+ *
+ *  The following program contains statements of a high level programming
+ *  language (here: C) in a distribution considered representative:           
+ *
+ *    assignments                  52 (51.0 %)
+ *    control statements           33 (32.4 %)
+ *    procedure, function calls    17 (16.7 %)
+ *
+ *  103 statements are dynamically executed. The program is balanced with
+ *  respect to the three aspects:                                             
+ *
+ *    - statement type
+ *    - operand type
+ *    - operand locality
+ *         operand global, local, parameter, or constant.                     
+ *
+ *  The combination of these three aspects is balanced only approximately.    
+ *
+ *  1. Statement Type:                                                        
+ *  -----------------             number
+ *
+ *     V1 = V2                     9
+ *       (incl. V1 = F(..)
+ *     V = Constant               12
+ *     Assignment,                 7
+ *       with array element
+ *     Assignment,                 6
+ *       with record component
+ *                                --
+ *                                34       34
+ *
+ *     X = Y +|-|"&&"|"|" Z        5
+ *     X = Y +|-|"==" Constant     6
+ *     X = X +|- 1                 3
+ *     X = Y *|/ Z                 2
+ *     X = Expression,             1
+ *           two operators
+ *     X = Expression,             1
+ *           three operators
+ *                                --
+ *                                18       18
+ *
+ *     if ....                    14
+ *       with "else"      7
+ *       without "else"   7
+ *           executed        3
+ *           not executed    4
+ *     for ...                     7  |  counted every time
+ *     while ...                   4  |  the loop condition
+ *     do ... while                1  |  is evaluated
+ *     switch ...                  1
+ *     break                       1
+ *     declaration with            1
+ *       initialization
+ *                                --
+ *                                34       34
+ *
+ *     P (...)  procedure call    11
+ *       user procedure      10
+ *       library procedure    1
+ *     X = F (...)
+ *             function  call      6
+ *       user function        5                                         
+ *       library function     1                                               
+ *                                --                                          
+ *                                17       17
+ *                                        ---
+ *                                        103
+ *
+ *    The average number of parameters in procedure or function calls
+ *    is 1.82 (not counting the function values as implicit parameters).
+ *
+ *
+ *  2. Operators
+ *  ------------
+ *                          number    approximate
+ *                                    percentage
+ *
+ *    Arithmetic             32          50.8                                 
+ *
+ *       +                     21          33.3                              
+ *       -                      7          11.1                              
+ *       *                      3           4.8
+ *       / (int div)            1           1.6
+ *
+ *    Comparison             27           42.8
+ *
+ *       ==                     9           14.3
+ *       /=                     4            6.3
+ *       >                      1            1.6
+ *       <                      3            4.8
+ *       >=                     1            1.6
+ *       <=                     9           14.3
+ *
+ *    Logic                   4            6.3
+ *
+ *       && (AND-THEN)          1            1.6
+ *       |  (OR)                1            1.6
+ *       !  (NOT)               2            3.2
+ * 
+ *                           --          -----
+ *                           63          100.1
+ *
+ *
+ *  3. Operand Type (counted once per operand reference):
+ *  ---------------
+ *                          number    approximate
+ *                                    percentage
+ *
+ *     Integer               175        72.3 %
+ *     Character              45        18.6 %
+ *     Pointer                12         5.0 %
+ *     String30                6         2.5 %
+ *     Array                   2         0.8 %
+ *     Record                  2         0.8 %
+ *                           ---       -------
+ *                           242       100.0 %
+ *
+ *  When there is an access path leading to the final operand (e.g. a record
+ *  component), only the final data type on the access path is counted.       
+ *
+ *
+ *  4. Operand Locality:                                                      
+ *  -------------------
+ *                                number    approximate
+ *                                          percentage
+ *
+ *     local variable              114        47.1 %
+ *     global variable              22         9.1 %
+ *     parameter                    45        18.6 %
+ *        value                        23         9.5 %
+ *        reference                    22         9.1 %
+ *     function result               6         2.5 %
+ *     constant                     55        22.7 %
+ *                                 ---       -------
+ *                                 242       100.0 %
+ *
+ *
+ *  The program does not compute anything meaningful, but it is syntactically
+ *  and semantically correct. All variables have a value assigned to them
+ *  before they are used as a source operand.
+ *
+ *  There has been no explicit effort to account for the effects of a
+ *  cache, or to balance the use of long or short displacements for code or
+ *  data.
+ *
+ ***************************************************************************
+ */
+
+/* Compiler and system dependent definitions: */
+/*
+#ifndef TIME
+#define TIMES
+#endif
+*/                /* Use times(2) time function unless    */
+                /* explicitly defined otherwise         */
+
+/*
+ #ifndef HZ
+ #define HZ      60
+ #endif
+*/
+
+/*
+#ifdef TIMES
+#include <sys/types.h>
+#include <sys/times.h>
+*/                /* for "times" */
+/*
+#endif
+*/
+#define Mic_secs_Per_Second     1000000.0
+                /* Berkeley UNIX C returns process times in seconds/HZ */
+
+#ifdef  NOSTRUCTASSIGN
+#define structassign(d, s)      memcpy(&(d), &(s), sizeof(d))
+#else
+#define structassign(d, s)      d = s
+#endif
+
+#ifdef  NOENUM
+#define Ident_1 0
+#define Ident_2 1
+#define Ident_3 2
+#define Ident_4 3
+#define Ident_5 4
+  typedef int   Enumeration;
+#else
+  typedef       enum    {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
+                Enumeration;
+#endif
+        /* for boolean and enumeration types in Ada, Pascal */
+
+/* General definitions: */
+
+#include <stdio.h>
+                /* for strcpy, strcmp */
+
+#define Null 0 
+                /* Value of a Null pointer */
+#define true  1
+#define false 0
+
+typedef int     One_Thirty;
+typedef int     One_Fifty;
+typedef char    Capital_Letter;
+typedef int     Boolean;
+typedef char    Str_30 [31];
+typedef int     Arr_1_Dim [50];
+typedef int     Arr_2_Dim [50] [50];
+
+typedef struct record 
+    {
+    struct record *Ptr_Comp;
+    Enumeration    Discr;
+    union {
+          struct {
+                  Enumeration Enum_Comp;
+                  int         Int_Comp;
+                  char        Str_Comp [31];
+                  } var_1;
+          struct {
+                  Enumeration E_Comp_2;
+                  char        Str_2_Comp [31];
+                  } var_2;
+          struct {
+                  char        Ch_1_Comp;
+                  char        Ch_2_Comp;
+                  } var_3;
+          } variant;
+      } Rec_Type, *Rec_Pointer;
+
+
diff --git a/gcc/testsuite/gcc.misc-tests/gcov-1.c b/gcc/testsuite/gcc.misc-tests/gcov-1.c
new file mode 100644
index 00000000000..20fc950dddc
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/gcov-1.c
@@ -0,0 +1,20 @@
+/* Test Gcov basics.  */
+
+/* { dg-options "-fprofile-arcs -ftest-coverage" } */
+/* { dg-do run { target native } } */
+
+noop ()
+{
+}
+
+main ()
+{
+  int i;
+
+  for (i = 0; i < 10; i++)	/* count(11) */
+    noop ();			/* count(10) */
+
+  return 0;			/* count(1) */
+}
+
+/* { dg-final { run-gcov gcov-1.c } } */
diff --git a/gcc/testsuite/gcc.misc-tests/gcov-2.c b/gcc/testsuite/gcc.misc-tests/gcov-2.c
new file mode 100644
index 00000000000..3d64d8cad4e
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/gcov-2.c
@@ -0,0 +1,21 @@
+/* Test Gcov basics.  */
+
+/* { dg-prms-id 8294 } */
+/* { dg-options "-fprofile-arcs -ftest-coverage -g" } */
+/* { dg-do run { target native } } */
+
+noop ()
+{
+}
+
+main ()
+{
+  int i;
+
+  for (i = 0; i < 10; i++)	/* count(11) */
+    noop ();			/* count(10) */
+
+  return 0;			/* count(1) */
+}
+
+int a_variable = 0;
diff --git a/gcc/testsuite/gcc.misc-tests/gcov.exp b/gcc/testsuite/gcc.misc-tests/gcov.exp
new file mode 100644
index 00000000000..747465d82ce
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/gcov.exp
@@ -0,0 +1,95 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# Gcov test driver.
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+global GCC_UNDER_TEST
+
+# For now find gcov in the same directory as $GCC_UNDER_TEST.
+if { ![is_remote host] && [string match "*/*" [lindex $GCC_UNDER_TEST 0]] } {
+    set GCOV [file dirname [lindex $GCC_UNDER_TEST 0]]/gcov
+} else {
+    set GCOV gcov
+}
+
+# Proc to delete the working files created by the compiler for gcov.
+
+proc clean-gcov { testcase } {
+    set basename [file tail $testcase]
+    set base [file rootname $basename]
+    remote_file host delete $base.bb $base.bbg $base.da $basename.gcov
+}
+
+# Called by dg-final to run gcov and analyze the results.
+
+proc run-gcov { testcase } {
+    global GCOV
+
+    verbose "Running $GCOV $testcase" 2
+    set testcase [remote_download host $testcase];
+    set result [remote_exec host $GCOV $testcase];
+    if { [lindex $result 0] != 0 } {
+	fail "gcov failed: [lindex $result 1]"
+	clean-gcov $testcase
+	return
+    }
+
+    remote_upload host $testcase.gcov $testcase.gcov;
+    set output [grep $testcase.gcov ".*count\\(\[0-9\]+\\)" line]
+    #send_user "output:$output\n"
+    set failed 0
+    foreach line $output {
+	verbose "Processing count line: $line" 3
+	#send_user "line:$line\n"
+	if [regexp "(\[0-9\]+) *(\[0-9\]+).*count\\((\[0-9\]+)\\)" "$line" all n is shouldbe] {
+	    #send_user "n $n:is $is:shouldbe $shouldbe\n"
+	    if { $is == "" } {
+		fail "$testcase:$n:no data available for this line"
+		incr failed
+	    } elseif { $is != $shouldbe } {
+		fail "$testcase:$n:is $is:should be $shouldbe"
+		incr failed
+	    }
+	} else {
+	    fail "$testcase: can't parse $line (in wrong place?)"
+	    incr failed
+	}
+    }
+    clean-gcov $testcase
+    if !$failed {
+	pass "gcov $testcase"
+    }
+}
+
+# Initialize harness.
+dg-init
+
+# Delete old .da files.
+set files [glob -nocomplain gcov-*.da];
+if { $files != "" } {
+    eval "remote_file build delete $files";
+}
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/gcov-*.c]] "" ""
+
+dg-finish
diff --git a/gcc/testsuite/gcc.misc-tests/m-un-1.c b/gcc/testsuite/gcc.misc-tests/m-un-1.c
new file mode 100644
index 00000000000..ad84d44ca15
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/m-un-1.c
@@ -0,0 +1,37 @@
+/* m-un-1.c: "un" for "uninitialized" */
+
+/*
+From: Jim Wilson <wilson@cygnus.com>
+Date: Wed, 6 Jul 1994 13:11:47 -0700
+To: dje@cygnus.com
+Subject: Re: devo/gcc ChangeLog.fsf stmt.c
+Cc: cvs-gcc@cygnus.com, tege@cygnus.com
+
+	How about a test case?  :-)
+
+Compile with -O -Wall and the broken compiler gives you:
+tmp.c:6: warning: `k' might be used uninitialized in this function
+The fixed compiler (and gcc 2.5.8) gives no warning.
+
+This happens to fix a performance regression in the code generated for
+while loops, but that is presumably much much harder to test for.
+*/
+
+/* { dg-do compile } */
+/* { dg-options "-O -Wall" } */
+
+int
+sub ()
+{
+  int i = 0;
+  int j = 0;
+  int k;	/* { dg-bogus "`k' might be used uninitialized" "uninitialized warning regression" } */
+
+  while (i == 0 && j == 0)
+    {
+      k = 10;
+      i = sub ();
+    }
+
+  return k;
+}
diff --git a/gcc/testsuite/gcc.misc-tests/matrix1.c b/gcc/testsuite/gcc.misc-tests/matrix1.c
new file mode 100644
index 00000000000..62c71150791
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/matrix1.c
@@ -0,0 +1,46 @@
+/*       Matrix operations      */
+
+#define BOUND 100
+
+int a[BOUND][BOUND],b[BOUND][BOUND],c[BOUND][BOUND];
+
+main()
+{
+int i,j,k;
+
+
+        
+        for (i=0; i<BOUND; i++)
+        {
+                for (j=0; j<BOUND; j++)
+                {
+                        a[i][j] = 1;
+                        b[i][j] = 1;
+                }
+        }
+        for (i=0; i<BOUND; i++)
+        {
+                for (j=0; j<BOUND; j++)
+                {
+                        c[i][j] = 0;
+                        for (k=0; k<BOUND; k++)
+                        {
+                                c[i][j] = c[i][j] + a[i][k] * b[k][j];
+                        }
+                }
+        }
+        for (i=0; i<BOUND; i++)
+        {
+                for (j=0; j<BOUND; j++)
+                {
+                        if (c[i][j] != BOUND)
+                        {
+                                /*printf("ERROR\n");*/
+                                return 0;
+                        }
+                }
+        }
+	i=5;
+
+	exit (0);
+}
diff --git a/gcc/testsuite/gcc.misc-tests/matrix1.exp b/gcc/testsuite/gcc.misc-tests/matrix1.exp
new file mode 100644
index 00000000000..a90ae5c64fe
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/matrix1.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase matrix1.c $run $groups
diff --git a/gcc/testsuite/gcc.misc-tests/mg.c b/gcc/testsuite/gcc.misc-tests/mg.c
new file mode 100644
index 00000000000..5359714572f
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/mg.c
@@ -0,0 +1,8 @@
+/* PR 2981 */
+
+#include "nonexist.h"
+int
+main ()
+{
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.misc-tests/mg.exp b/gcc/testsuite/gcc.misc-tests/mg.exp
new file mode 100644
index 00000000000..845e3e6eb6c
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/mg.exp
@@ -0,0 +1,27 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# Test the -MG flag.
+
+load_lib mike-gcc.exp
+
+prebase
+set actions none-of-the-above
+set compiler_output "mg.o ?: .*mg.c \[ \\\n\]*nonexist.h"
+postbase mg.c "" "" "-MM -MG 2>/dev/null"
diff --git a/gcc/testsuite/gcc.misc-tests/msgs.exp b/gcc/testsuite/gcc.misc-tests/msgs.exp
new file mode 100644
index 00000000000..dbe3f24a78e
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/msgs.exp
@@ -0,0 +1,33 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# Test gcc warning and error messages.
+# Our testcases are named m-*.c ("m" and not "msg" to avoid DOS problems).
+
+# Load support procs.
+load_lib gcc-dg.exp
+
+# Initialize harness.
+dg-init
+
+# Main loop.
+dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/m-*.c]] "" ""
+
+# All done.
+dg-finish
diff --git a/gcc/testsuite/gcc.misc-tests/optbench.c b/gcc/testsuite/gcc.misc-tests/optbench.c
new file mode 100644
index 00000000000..9cee4305b64
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/optbench.c
@@ -0,0 +1,288 @@
+/* ----------------------------------------------------- * 
+ |                                                       | 
+ |    PC Tech Journal Benchmark Series                   | 
+ |    C Code Optimization Benchmark                      | 
+ |                                                       | 
+ |    Copyright (c) 1988 Ziff-Davis Publishing Company   | 
+ |                                                       | 
+ |    This benchmark code is designed to test the        | 
+ |    code optimization techniques applied by a C        | 
+ |    compiler.  It does not produce meaningful results  | 
+ |    when executed, or represent good style.            | 
+ |                                                       | 
+ * ----------------------------------------------------- */ 
+ 
+#include <string.h> 
+
+#define max_vector   2 
+#define constant5    5 
+ 
+typedef    unsigned char   uchar; 
+ 
+int    i,  j,  k , l,  m; 
+int    i2, j2, k2; 
+int    g3, h3, i3, k3, m3; 
+int    i4, j4; 
+int    i5, j5, k5; 
+ 
+double flt_1, flt_2, flt_3, flt_4, flt_5, flt_6; 
+ 
+int    ivector[ 3 ]; 
+uchar  ivector2[ 3 ]; 
+short  ivector4[ 6 ]; 
+int    ivector5[ 203 ]; 
+ 
+#ifndef NO_PROTOTYPES 
+void   dead_code( int, char * ); 
+void   unnecessary_loop( void ); 
+void   loop_jamming( int ); 
+void   loop_unrolling( int ); 
+int    jump_compression ( int, int, int, int, int ); 
+#else 
+void   dead_code(); 
+void   unnecessary_loop(); 
+void   loop_jamming(); 
+void   loop_unrolling(); 
+int    jump_compression(); 
+#endif 
+ 
+ 
+int     main( argc, argv )      /* optbench */ 
+        int  argc; 
+        char     **argv; 
+        { 
+        /* ------------------------------ * 
+         | Constant and copy propagation  | 
+         * ------------------------------ */ 
+ 
+        j4 = 2; 
+        if( i2 < j4 && i4 < j4 ) 
+           i5 = 2; 
+ 
+        j4 = k5; 
+        if( i2 < j4 && i4 < j4 ) 
+           i5 = 3; 
+        
+        /* ---------------------------------------- * 
+         |  Constant folding, arithmetic identities | 
+         |  and redundant load/store operations     | 
+         * ---------------------------------------- */ 
+ 
+        i3 = 1 + 2; 
+        flt_1 = 2.4 + 6.3; 
+        i2 = 5;               
+        j2 = i + 0; 
+        k2 = i / 1; 
+        i4 = i * 1; 
+        i5 = i * 0; 
+ 
+#ifndef NO_ZERO_DIVIDE 
+        /* 
+         *   Some compilers correctly recognize a zero divide 
+         *   error and do not generate any object code. 
+         */ 
+/*
+        i2 = i / 0;            
+        flt_2 = flt_1 / 0.0; 
+*/
+#else    
+/*
+        printf( "This compiler handles divide-by-zero as an
+error\n"); 
+*/;
+#endif 
+        flt_3 = 2.4 / 1.0;  
+        flt_4 = 1.0 + 0.0000001; 
+        flt_5 = flt_6 * 0.0; 
+        flt_6 = flt_2 * flt_3; 
+  
+        /* ------------ * 
+         |  Dead store  | 
+         * ------------ */ 
+ 
+         k3 = 1; 
+         k3 = 1; 
+ 
+        /* --------------------- * 
+         |  Strength reduction   | 
+         * --------------------- */ 
+ 
+        k2 = 4 * j5; 
+           for( i = 0; i <= 5; i++ )
+              ivector4[ i ] = i * 2; 
+    
+        /* ----------- * 
+         | Simple loop | 
+         * ----------- */ 
+ 
+        j5 = 0; 
+        k5 = 10000; 
+        do { 
+              k5 = k5 - 1; 
+              j5 = j5 + 1; 
+              i5 = ( k5 * 3 ) / ( j5 * constant5 ); 
+           } while ( k5 > 0 ); 
+ 
+        /* ----------------------------------- * 
+         | Loop induction variable handling    | 
+         * ----------------------------------- */ 
+ 
+        for( i = 0; i < 100; i++) 
+           ivector5[ i * 2 + 3 ] = 5; 
+ 
+        /* ----------------------------- * 
+         | Very busy expression handling | 
+         * ----------------------------- */ 
+ 
+        if( i < 10 ) 
+           j5 = i5 + i2; 
+        else 
+           k5 = i5 + i2; 
+ 
+        /* -------------------------------------------- * 
+         | Check how the compiler generates the address | 
+         | of a variable with a constant subscript,     | 
+         | copy propagation, and register propagation.  | 
+         * -------------------------------------------- */ 
+ 
+         ivector[ 0  ] = 1;  /* constant address generation */ 
+         ivector[ i2 ] = 2;  /* i2 should be a propagated value
+*/ 
+         ivector[ i2 ] = 2;  /* register propagation */ 
+         ivector[ 2  ] = 3;  /* constant address generation */ 
+     
+     
+         /* ---------------------------------- * 
+          | Common subexpression elimination   | 
+          * ---------------------------------- */ 
+  
+        if(( h3 + k3 ) < 0 || ( h3 + k3 ) > 5 )
+        /* 
+               printf("Common subexpression elimination\n"); 
+        
+        */;
+        else { 
+               m3 = ( h3 + k3 ) / i3; 
+               g3 = i3 + (h3 + k3); 
+         } 
+        /* --------------------------------------- * 
+         | Invariant code motion                   | 
+         |  (j * k) can be moved outside the loop. |  
+         * --------------------------------------- */ 
+  
+        for( i4 = 0; i4 <= max_vector; i4++ )    
+           ivector2[ i4 ] = j * k; 
+  
+        /* ---------------------------- * 
+         | Function call with arguments | 
+         * ---------------------------- */ 
+ 
+        dead_code( 1, "This line should not be printed" ); 
+ 
+        /* ------------------------------- * 
+         | Function call without arguments | 
+         * ------------------------------- */ 
+ 
+        unnecessary_loop(); 
+
+	exit (0);
+    
+        }  /* end of main */ 
+ 
+            
+/* --------------------------------------------- * 
+ | Function: dead_code                           | 
+ |           Test for dead code and dead stores. | 
+ |           NO code should be generated.        | 
+ * ----------------------------------------------*/ 
+ 
+void   dead_code( a, b ) 
+       int a; 
+       char *b; 
+       { 
+         int idead_store; 
+ 
+         idead_store = a; 
+         if( 0 )
+         /* 
+           printf( "%s\n", b );
+          */; 
+       }  /* end of dead_code */ 
+ 
+/* ----------------------------------------------- * 
+ | Function: unnecessary_loop                      | 
+ |           The loop in the following function is | 
+ |           not necessary since the value of the  | 
+ |           assignment is constant. Ideally, the  | 
+ |           loop should be optimized out.         | 
+ * ----------------------------------------------- */ 
+ 
+void   unnecessary_loop() 
+       { 
+           int x;  
+ 
+           x = 0; 
+           for( i = 0; i < 5; i++ ) /* loop should not be generated */ 
+           k5 = x + j5;                  
+       }   /* end of unnecessary_loop */ 
+ 
+/* --------------------------------------------- * 
+ | Function: loop_jamming                        | 
+ |           The two loop in this function share | 
+ |           the same loop conditions and could  | 
+ |           be coalesced together.              | 
+ * --------------------------------------------- */ 
+ 
+void   loop_jamming( x ) 
+       int x; 
+       { 
+          for( i = 0; i < 5; i++ ) 
+             k5 = x + j5 * i; 
+          for( i = 0; i < 5; i++ ) 
+             i5 = x * k5 * i; 
+       }  /* end of loop_jamming */ 
+ 
+/* ------------------------------------------------ * 
+ | Function: loop_unrolling                         | 
+ |           The loop in this function should be    | 
+ |           replaced with three inline word stores | 
+ |           using constant array arithmetic or by  | 
+ |           specialized machine instructions used  | 
+ |           for block memory initializiation.      | 
+ * ------------------------------------------------ */ 
+ 
+void  loop_unrolling( x ) 
+      int x; 
+      { 
+         for( i = 0; i < 6; i++ ) 
+           ivector4[ i ] = 0; 
+       }  /* end of loop_unrolling */ 
+ 
+/* ------------------------------------------------------ * 
+ | Function: jump_compression                             | 
+ |           This awkward code is useful to illustrate    | 
+ |           jump chain compression. The goto 'end_1' can | 
+ |           be replaced by a direct jump to 'beg_1'.     | 
+ *------------------------------------------------------ */ 
+ 
+int  jump_compression ( i, j, k, l, m ) 
+int i,j ,l, m; 
+        { 
+beg_1: 
+           if( i < j ) 
+               if( j < k ) 
+                   if( k < l ) 
+                       if ( l < m ) 
+                           l += m; 
+                       else 
+                           goto end_1;
+                   else 
+                       k += l; 
+               else { 
+                   j += k; 
+end_1:            goto beg_1; 
+               } 
+           else 
+               i += j; 
+          return( i + j + k + l + m ); 
+        }   /* end of jump_compression */ 
diff --git a/gcc/testsuite/gcc.misc-tests/optbench.exp b/gcc/testsuite/gcc.misc-tests/optbench.exp
new file mode 100644
index 00000000000..a54fd2dc468
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/optbench.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase optbench.c $run $groups
diff --git a/gcc/testsuite/gcc.misc-tests/sieve.c b/gcc/testsuite/gcc.misc-tests/sieve.c
new file mode 100644
index 00000000000..41897f178c4
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/sieve.c
@@ -0,0 +1,26 @@
+
+#define TRUE 1
+#define FALSE 0
+#define SIZE 8190
+
+char flags[SIZE+1];
+
+main()
+{
+	register int i, prime, k, count, iter;
+	for (iter=1;iter<=100;iter++) 		{
+		count=0;
+		for (i=0;i<=SIZE;i++)
+			flags[i]=TRUE;
+		for (i=0;i<=SIZE;i++) {
+			if (flags[i]) {
+				prime=i+i+3;
+				for (k=i+prime;k<=SIZE;k+=prime)
+					flags[k]=FALSE;
+				count++;
+			}
+		}
+	}
+/* */	exit(0); /* */
+}
+
diff --git a/gcc/testsuite/gcc.misc-tests/sieve.exp b/gcc/testsuite/gcc.misc-tests/sieve.exp
new file mode 100644
index 00000000000..a6c7665bc52
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/sieve.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase sieve.c $run $groups
diff --git a/gcc/testsuite/gcc.misc-tests/sort2.c b/gcc/testsuite/gcc.misc-tests/sort2.c
new file mode 100644
index 00000000000..3d86e1ecc24
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/sort2.c
@@ -0,0 +1,54 @@
+/* Simple test program:   bubble sort of a fixed table. 	*/
+/* This demonstrates some of the compiler's common-subexpression*/
+/* elimination capabilities.  For example, inspect the code	*/
+/* generated for procedure Sort_array.	See the Programmer's    */
+/* Guide for how to request an assembly listing on your host.	*/
+
+typedef unsigned char boolean;
+
+void Sort_array();
+int Tab[100];
+
+main () {
+   int I,J,K,L;
+
+for (L = 0; L < 1000; L++) {
+   /* Initialize the table that will be sorted. */
+   K = 0;
+   for (I = 9; I >= 0; I--)
+      for (J = I*10; J < (I+1)*10; J++)
+	 Tab[K++] = J&1 ? J+1 : J-1;
+
+/*   Print_array(); */
+   Sort_array(Tab,99);	   /* Sort it. */
+/*   Print_array(); */
+}
+/* */ exit(0); /* */
+}
+
+void Sort_array(Tab,Last) int Tab[]; int Last; {
+   boolean Swap;
+   int Temp,I;
+   do {
+      Swap = 0;
+      for (I = 0; I<Last; I++)
+	 if (Tab[I] > Tab[I+1]) {
+	    Temp = Tab[I];
+	    Tab[I] = Tab[I+1];
+	    Tab[I+1] = Temp;
+	    Swap = 1;
+	    }
+      }
+   while (Swap);
+}
+
+
+void Print_array() {
+   int I,J;
+   /*printf("\nArray Contents:\n");*/
+   for (I=0; I<=9; I++) {
+      /*printf("%5d:",10*I); */
+      for (J=0; J<=9; J++); /*printf("%5d",Tab[10*I+J]); */
+      /* printf("\n");*/
+      }
+}
diff --git a/gcc/testsuite/gcc.misc-tests/sort2.exp b/gcc/testsuite/gcc.misc-tests/sort2.exp
new file mode 100644
index 00000000000..ab5f0996426
--- /dev/null
+++ b/gcc/testsuite/gcc.misc-tests/sort2.exp
@@ -0,0 +1,31 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+global PERF_TEST
+if { ![info exists PERF_TEST] || "$PERF_TEST" != "yes" } {
+    return
+}
+
+load_lib mike-gcc.exp
+
+prebase
+set actions run
+set compiler_output "^$"
+set program_output "^$"
+postbase sort2.c $run $groups
diff --git a/gcc/testsuite/lib/c-torture.exp b/gcc/testsuite/lib/c-torture.exp
new file mode 100644
index 00000000000..76732eceeea
--- /dev/null
+++ b/gcc/testsuite/lib/c-torture.exp
@@ -0,0 +1,319 @@
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-dejagnu.prep.ai.mit.edu
+
+# This file was written by Rob Savoye. (rob@cygnus.com)
+
+# The default option list can be overridden by
+# TORTURE_OPTIONS="{ { list1 } ... { listN } }"
+
+if ![info exists TORTURE_OPTIONS] {
+    # FIXME: We should test -g at least once.
+    set TORTURE_OPTIONS [list \
+	{ -O0 } { -O1 } { -O2 } \
+	{ -O2 -fomit-frame-pointer -finline-functions } \
+	{ -O2 -fomit-frame-pointer -finline-functions -funroll-loops } \
+	{ -O2 -fomit-frame-pointer -finline-functions -funroll-all-loops }]
+}
+
+
+# Split TORTURE_OPTIONS into two choices: one for testcases with loops and
+# one for testcases without loops.
+
+set torture_with_loops $TORTURE_OPTIONS
+set torture_without_loops ""
+foreach option $TORTURE_OPTIONS {
+    if ![string match "*loop*" $option] {
+	lappend torture_without_loops $option
+    }
+}
+
+#
+# c-torture-compile -- runs the Tege C-torture test
+#
+# SRC is the full pathname of the testcase.
+# OPTION is the specific compiler flag we're testing (eg: -O2).
+#
+proc c-torture-compile { src option } {
+    global output
+    global srcdir tmpdir
+    global host_triplet
+
+    set output "$tmpdir/[file tail [file rootname $src]].o"
+
+    regsub "^$srcdir/?" $src "" testcase
+    # If we couldn't rip $srcdir out of `src' then just do the best we can.
+    # The point is to reduce the unnecessary noise in the logs.  Don't strip
+    # out too much because different testcases with the same name can confuse
+    # `test-tool'.
+    if [string match "/*" $testcase] {
+	set testcase "[file tail [file dirname $src]]/[file tail $src]"
+    }
+
+    verbose "Testing $testcase, $option" 1
+
+    # Run the compiler and analyze the results.
+    set options ""
+    lappend options "additional_flags=-w $option"
+
+    set comp_output [gcc_target_compile "$src" "$output" object $options];
+    
+    # Set a few common compiler messages.
+    set fatal_signal "*cc: Internal compiler error: program*got fatal signal"
+ 
+    if [string match "$fatal_signal 6" $comp_output] then {
+	gcc_fail $testcase "Got Signal 6, $option"
+	remote_file build delete $output
+	return
+    }
+
+    if [string match "$fatal_signal 11" $comp_output] then {
+	gcc_fail $testcase "Got Signal 11, $option"
+	remote_file build delete $output
+	return
+    }
+
+    # We shouldn't get these because of -w, but just in case.
+    if [string match "*cc:*warning:*" $comp_output] then {
+	warning "$testcase: (with warnings) $option"
+	send_log "$comp_output\n"
+	unresolved "$testcase, $option"
+	remote_file build delete $output
+	return
+    }
+
+    set comp_output [prune_warnings $comp_output]
+
+    set unsupported_message [gcc_check_unsupported_p $comp_output]
+    if { $unsupported_message != "" } {
+	unsupported "$testcase: $unsupported_message"
+	remote_file build delete $output
+	return
+    }
+
+    # remove any leftover LF/CR to make sure any output is legit
+    regsub -all -- "\[\r\n\]*" $comp_output "" comp_output
+    # If any message remains, we fail.
+    if ![string match "" $comp_output] then {
+	gcc_fail $testcase $option
+	remote_file build delete $output
+	return
+    }
+
+    gcc_pass $testcase $option
+    remote_file build delete $output
+}
+
+#
+# c-torture-execute -- utility to compile and execute a testcase
+#
+# SRC is the full pathname of the testcase.
+#
+# If the testcase has an associated .cexp file, we source that to run the
+# test instead.  We use .cexp instead of .exp so that the testcase is still
+# controlled by the main .exp driver (this is useful when one wants to only
+# run the compile.exp tests for example - one need only pass compile.exp to
+# dejagnu, and not compile.exp, foo1.exp, foo2.exp, etc.).
+#
+proc c-torture-execute { src } {
+    global tmpdir tool srcdir output 
+
+    # Check for alternate driver.
+    if [file exists [file rootname $src].cexp] {
+	verbose "Using alternate driver [file rootname [file tail $src]].cexp" 2
+	set done_p 0
+	catch "set done_p \[source [file rootname $src].cexp\]"
+	if { $done_p } {
+	    return
+	}
+    }
+   
+    # Look for a loop within the source code - if we don't find one,
+    # don't pass -funroll[-all]-loops.
+    global torture_with_loops torture_without_loops
+    if [expr [search_for $src "for*("]+[search_for $src "while*("]] then {
+	set option_list $torture_with_loops
+    } else {
+	set option_list $torture_without_loops
+    }
+
+    set executable $tmpdir/[file tail [file rootname $src].x]
+
+    regsub "^$srcdir/?" $src "" testcase
+    # If we couldn't rip $srcdir out of `src' then just do the best we can.
+    # The point is to reduce the unnecessary noise in the logs.  Don't strip
+    # out too much because different testcases with the same name can confuse
+    # `test-tool'.
+    if [string match "/*" $testcase] {
+	set testcase "[file tail [file dirname $src]]/[file tail $src]"
+    }
+
+    foreach option $option_list {
+	# torture_{compile,execute}_xfail are set by the .cexp script
+	# (if present)
+	if [info exists torture_compile_xfail] {
+	    setup_xfail $torture_compile_xfail
+	}
+	remote_file build delete $executable
+	verbose "Testing $testcase, $option" 1
+
+	set options ""
+	lappend options "additional_flags=-w $option"
+	set comp_output [gcc_target_compile "$src" "$executable" executable $options];
+
+	# Set a few common compiler messages.
+	set fatal_signal "*cc: Internal compiler error: program*got fatal signal"
+	
+	if [string match "$fatal_signal 6" $comp_output] then {
+	    gcc_fail $testcase "Got Signal 6, $option"
+	    remote_file build delete $executable
+	    continue
+	}
+	
+	if [string match "$fatal_signal 11" $comp_output] then {
+	    gcc_fail $testcase "Got Signal 11, $option"
+	    remote_file build delete $executable
+	    continue
+	}
+	
+	# We shouldn't get these because of -w, but just in case.
+	if [string match "*cc:*warning:*" $comp_output] then {
+	    warning "$testcase: (with warnings) $option"
+	    send_log "$comp_output\n"
+	    unresolved "$testcase, $option"
+	    remote_file build delete $executable
+	    continue
+	}
+	
+	set comp_output [prune_warnings $comp_output]
+	
+	set unsupported_message [gcc_check_unsupported_p $comp_output]
+
+	if { $unsupported_message != "" } {
+	    unsupported "$testcase: $unsupported_message"
+	    continue
+	} elseif ![file exists $executable] {
+	    if ![is3way] {
+		fail "$testcase compilation, $option"
+		untested "$testcase execution, $option"
+		continue
+	    } else {
+		# FIXME: since we can't test for the existance of a remote
+		# file without short of doing an remote file list, we assume
+		# that since we got no output, it must have compiled.
+		pass "$testcase compilation, $option"		
+	    }
+	} else {
+	    pass "$testcase compilation, $option"
+	}
+
+	# See if this source file uses "long long" types, if it does, and
+	# no_long_long is set, skip execution of the test.
+	if [target_info exists no_long_long] then {
+	    if [expr [search_for $src "long long"]] then {
+		untested "$testcase execution, $option"
+		continue
+	    }
+	}
+
+	if [info exists torture_execute_xfail] {
+	    setup_xfail $torture_execute_xfail
+	}
+	
+	set result [gcc_load "$executable" "" ""]
+	set status [lindex $result 0];
+	set output [lindex $result 1];
+        if { $status == "pass" } {
+	    remote_file build delete $executable
+        }
+	$status "$testcase execution, $option"
+    }
+}
+
+#
+# search_for -- looks for a string match in a file
+#
+proc search_for { file pattern } {
+    set fd [open $file r]
+    while { [gets $fd cur_line]>=0 } {
+	if [string match "*$pattern*" $cur_line] then {
+	    close $fd
+	    return 1
+	}
+    }
+    close $fd
+    return 0
+}
+
+#
+# c-torture -- the c-torture testcase source file processor
+#
+# This runs compilation only tests (no execute tests).
+# SRC is the full pathname of the testcase, or just a file name in which case
+# we prepend $srcdir/$subdir.
+#
+# If the testcase has an associated .cexp file, we source that to run the
+# test instead.  We use .cexp instead of .exp so that the testcase is still
+# controlled by the main .exp driver (this is useful when one wants to only
+# run the compile.exp tests for example - one need only pass compile.exp to
+# dejagnu, and not compile.exp, foo1.exp, foo2.exp, etc.).
+#
+proc c-torture { args } {
+    global srcdir subdir
+
+    set src [lindex $args 0];
+    if { [llength $args] > 1 } {
+	set options [lindex $args 1];
+    } else {
+	set options ""
+    }
+
+    # Prepend $srdir/$subdir if missing.
+    if ![string match "*/*" $src] {
+	set src "$srcdir/$subdir/$src"
+    }
+
+    # Check for alternate driver.
+    if [file exists [file rootname $src].cexp] {
+	verbose "Using alternate driver [file rootname [file tail $src]].cexp" 2
+	set done_p 0
+	catch "set done_p \[source [file rootname $src].cexp\]"
+	if { $done_p } {
+	    return
+	}
+    }
+   
+    # Look for a loop within the source code - if we don't find one,
+    # don't pass -funroll[-all]-loops.
+    global torture_with_loops torture_without_loops
+    if [expr [search_for $src "for*("]+[search_for $src "while*("]] then {
+	set option_list $torture_with_loops
+    } else {
+	set option_list $torture_without_loops
+    }
+
+    # loop through all the options
+    foreach option $option_list {
+	# torture_compile_xfail is set by the .cexp script (if present)
+	if [info exists torture_compile_xfail] {
+	    setup_xfail $torture_compile_xfail
+	}
+
+	c-torture-compile $src "$option $options"
+    }
+}
diff --git a/gcc/testsuite/lib/chill.exp b/gcc/testsuite/lib/chill.exp
new file mode 100644
index 00000000000..bd8c4f64f2b
--- /dev/null
+++ b/gcc/testsuite/lib/chill.exp
@@ -0,0 +1,365 @@
+#
+# Expect script for Chill Regression Tests
+#   Copyright (C) 1993, 1996, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# Written by Jeffrey Wheat (cassidy@cygnus.com)
+#
+
+#
+# chill support library procedures and testsuite specific instructions
+#
+
+#
+# default_chill_version 
+# 	extract and print the version number of the chill compiler
+#	exits if compiler does not exist
+#
+proc default_chill_version { } {
+    global GCC_UNDER_TEST
+    
+    # ignore any arguments after the command 
+    set compiler [lindex $GCC_UNDER_TEST 0]
+    
+    # verify that the compiler exists
+    if {[which $compiler] != 0} then {
+        set tmp [ exec $compiler -v ]
+        regexp "version.*$" $tmp version
+	
+        if [info exists version] then {
+            clone_output "[which $compiler] $version\n"
+        }
+    } else {
+        warning "$compiler does not exist"
+	exit -1
+    }
+}
+
+#
+# chill_compile
+#	compile the specified file
+#
+#	returns values:
+#		return 0 on success
+#		return 1 on failure with $result containing compiler output
+#		exit with -1 if compiler doesn't exist
+#
+#	verbosity output:
+#		1 - indicate compile in progress
+#		2 - indicate compile, target name
+#		3 - indicate compile, target name, exec command, and result
+#
+proc chill_compile { src obj } {
+    global GCC_UNDER_TEST
+    global CFLAGS
+    
+    global errno
+    global result
+    global verbose
+
+    global subdir
+    global tmpdir
+   
+    set errno 0 
+    set cflags $CFLAGS
+    set dumpfile [file rootname $obj].cmp    ;# name of file to dump stderr in
+
+    # verify that the compiler exists
+    if { [which $GCC_UNDER_TEST] == 0 } then {
+	warning "$GCC_UNDER_TEST does not exist"
+	exit -1
+    }
+    
+    if { $verbose == 1 } then {
+	send_user "Compiling... "
+    } else {
+	verbose " -  CMPL: Compiling [file tail $src]" 2
+    }
+   
+    # if object type is a grt file, then only build a grant file
+    if [string match "*.grt" $obj] then {
+	set cflags [concat $cflags -fgrant-only]
+    }
+
+    # build command line
+    set commandline "$GCC_UNDER_TEST $cflags -I$subdir -c $src"
+
+    # write command line to logfile
+    send_log "\n### EXEC: $commandline\n"
+    
+    # tell us whats going on if verbose 
+    verbose "### EXEC: $commandline" 3
+    
+    # exec the compiler with the appropriate flags
+    set errno [catch "exec $commandline" result]
+
+    # dump compiler's stderr output into $dumpfile - this is a gross hack
+    set dumpfile [open $dumpfile w+]; puts $dumpfile $result; close $dumpfile
+
+    # log any compiler output unless its null
+    if ![string match "" $result] then { send_log "\n$result\n" }
+    unset cflags
+    return
+}
+
+#
+# chill_link
+#	link the specified files
+#
+#	returns values:
+#		return 0 on success
+#		return 1 on failure with $result containing compiler output
+#		exit with -1 if compiler doesn't exist
+#
+#	verbosity output:
+#		1 - indicate linking in progress
+#		2 - indicate linking, target name
+#		3 - indicate linking, target name, exec command, and result
+#
+proc chill_link { target } {
+    global GCC_UNDER_TEST
+    global CFLAGS
+    
+    global errno 
+    global result
+    global verbose
+    global tmptarget
+    
+    global crt0
+    global libs
+    global objs
+    
+    set errno 0
+    
+    # verify that the compiler exists
+    if { [which $GCC_UNDER_TEST] == 0 } then {
+	warning "$GCC_UNDER_TEST does not exist"
+	exit -1
+    }
+    
+    if { $verbose == 1 } then {
+	send_user "Linking... "
+    } else {
+	verbose " -  LINK: Linking [file tail $target]" 2
+    }
+    
+    # verify that the object exists
+    if ![file exists $target.o] then {
+	set errno 1
+	set result "file $target.o doesn'timeout exist"
+	return
+    }
+    
+    # build command line
+    set commandline "$GCC_UNDER_TEST $CFLAGS -o $target $target.o $objs $crt0 $libs"
+
+    # write command line to logfile
+    send_log "\n### EXEC: $commandline\n"
+    
+    # tell us whats going on if we are verbose	
+    verbose "### EXEC: $commandline" 3
+    
+    # link the objects, sending any linker output to $result
+    set errno [catch "exec $commandline > $tmptarget.lnk" result]
+ 
+    # log any linker output unless its null
+    if ![string match "" $result] then { send_log "\n$result\n" }
+    return
+}
+
+#
+# default_chill_start
+#
+proc default_chill_start { } {
+    global srcdir
+    global subdir
+    global tmpdir
+    global verbose
+  
+    if { $verbose > 1 } then { send_user "Configuring testsuite... " }
+
+    # tmpdir is obtained from $objdir/site.exp. if not, set it to /tmp
+    if ![info exists tmpdir] then { set tmpdir /tmp }
+
+    # save and convert $srcdir to an absolute pathname, stomp on the old value
+    # stomp on $subdir and set to the absolute path to the subdirectory
+    global osrcdir; set osrcdir $srcdir; set srcdir [cd $srcdir; pwd]
+    global osubdir; set osubdir $subdir; set subdir $srcdir/$subdir
+
+    # cd the temporary directory, $tmpdir
+    cd $tmpdir; verbose "### PWD: [pwd]" 5
+
+    # copy init files to the tmpdir
+    foreach initfile [glob -nocomplain $subdir/*.init] {
+	set targfile $tmpdir/[file tail [file rootname $initfile]]
+	verbose "### EXEC: cp $initfile $targfile" 5
+	if [catch "exec cp $initfile $targfile"] then {
+	    send_user "\nConfigure failed.\n"
+	    exit -1
+	}
+    }
+    if { $verbose > 1 } then { send_user "Configuring finished.\n" }
+}
+    
+#
+# default_chill_exit
+#
+#
+proc default_chill_exit { } {
+    global srcdir
+    global objdir
+    global tmpdir
+    global osrcdir
+    global osubdir
+    
+    # reset directory variables
+    set srcdir $osrcdir; set subdir $osubdir
+
+    # remove all generated targets and objects	
+    verbose "### EXEC: rm -f $tmpdir/*" 3
+    catch "exec rm -f $tmpdir/*" result
+
+    # change back to the main object directory
+    cd $objdir
+    verbose "### SANITY: [pwd]" 5
+}
+
+#
+# chill_diff
+#	compare two files line-by-line
+#
+#	returns values:
+#		return 0 on success
+#		return 1 if different
+#		return -1 if output file doesn't exist
+#
+#	verbosity output:
+#		1 - indicate diffing in progress
+#		2 - indicate diffing, target names
+#		3 - indicate diffing, target names, and result
+#
+proc chill_diff { file_1 file_2 } {
+    global errno
+    global result
+    global target
+    global tmptarget
+
+    global verbose
+    
+    set eof -1
+    set errno 0
+    set differences 0
+    
+    if { $verbose == 1 } then {
+	send_user "Diffing... "
+    } else {
+	verbose " -  DIFF: Diffing [file tail $file_1] [file tail $file_2]" 2
+    }
+    
+    # write command line to logfile
+    send_log "### EXEC: diff $file_1 $file_2\n"
+    
+    # tell us whats going on if we are verbose	
+    verbose "### EXEC: diff $file_1 $file_2" 3
+    
+    # verify file exists and open it
+    if [file exists $file_1] then {
+	set file_a [open $file_1 r]
+    } else {
+	set errno -1; set result "$file_1 doesn't exist"
+	return
+    }
+    
+    # verify file exists and is not zero length, and then open it
+    if [file exists $file_2] then {
+        if [file size $file_2]!=0 then {
+	    set file_b [open $file_2 r]
+        } else {
+	    set errno -1; set result "$file_2 is zero bytes"; return
+        }
+    } else {
+	set errno -1; set result "$file_2 doesn't exist"; return
+    }
+    
+    # spoof the diff routine
+    lappend list_a $target
+
+    while { [gets $file_a line] != $eof } {
+	if [regexp "^#.*$" $line] then {
+	    continue
+	} else {
+	    lappend list_a $line
+	}
+    }
+    close $file_a
+
+    # spoof the diff routine
+    lappend list_b $target
+
+    while { [gets $file_b line] != $eof } {
+	if [regexp "^#.*$" $line] then {
+	    continue
+	} else {
+	    # use [file tail $line] to strip off pathname
+	    lappend list_b [file tail $line]
+	}
+    }
+    close $file_b
+    
+    for { set i 0 } { $i < [llength $list_a] } { incr i } {
+	set line_a [lindex $list_a $i]
+	set line_b [lindex $list_b $i]
+	
+	if [string compare $line_a $line_b] then {
+	    set errno 1
+	    set count [expr $i+1]
+	    set linenum [format %dc%d $count $count]
+	    verbose "$linenum" 3	    
+	    verbose "< $line_a" 3
+	    verbose "---" 3
+	    verbose "> $line_b" 3
+	    
+	    send_log "$file_1: < $count: $line_a\n"
+	    send_log "$file_2: > $count: $line_b\n"
+	    set result "differences found"
+	}
+    }
+    return
+}
+
+#
+# chill_fail
+#	a wrapper around the framework fail proc
+#
+proc chill_fail { target result } {
+    global verbose
+
+    if { $verbose == 1 } then { send_user "\n" }
+    fail $target
+    verbose "--------------------------------------------------" 3
+    verbose "### RESULT: $result" 3
+}
+
+#
+# chill_pass
+#       a wrapper around the framework fail proc
+#
+proc chill_pass { target } {
+    global verbose
+
+    if { $verbose == 1 } then { send_user "\n" }
+    pass $target
+}
diff --git a/gcc/testsuite/lib/g++.exp b/gcc/testsuite/lib/g++.exp
new file mode 100644
index 00000000000..2433e03be01
--- /dev/null
+++ b/gcc/testsuite/lib/g++.exp
@@ -0,0 +1,229 @@
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-g++@prep.ai.mit.edu
+
+# This file was written by Rob Savoye (rob@cygnus.com)
+# Many modifications by Jeffrey Wheat (cassidy@cygnus.com)
+# With modifications by Mike Stump <mrs@cygnus.com>.
+
+#
+# g++ support library routines
+#
+
+#
+# GXX_UNDER_TEST is the compiler under test.
+#
+
+
+set gpp_compile_options ""
+
+#
+# g++_version -- extract and print the version number of the compiler
+#
+proc g++_version { } {
+    global GXX_UNDER_TEST
+    
+    # ignore any arguments after the command
+    set compiler [lindex $GXX_UNDER_TEST 0]
+    
+    # verify that the compiler exists
+    if { [is_remote host] || [which $compiler] != 0 } then {
+	set tmp [remote_exec host "$compiler -v"]
+	set status [lindex $tmp 0];
+	set output [lindex $tmp 1];
+	regexp "version.*$" $output version
+	if { $status == 0 && [info exists version] } then {
+	    if [is_remote host] {
+		clone_output "$compiler $version\n"
+	    } else {
+		clone_output "[which $compiler] $version\n"
+	    }
+	} else {
+	    clone_output "Couldn't determine version of [which $compiler]\n"
+	}
+    } else {
+	# compiler does not exist (this should have already been detected)
+	warning "$compiler does not exist"
+    }
+}
+
+#
+# g++_init -- called at the start of each subdir of tests
+#
+
+proc g++_init { args } {
+    global subdir
+    global gpp_initialized
+    global base_dir
+    global tmpdir
+    global libdir
+    global gluefile wrap_flags;
+    global objdir srcdir
+    global ALWAYS_CXXFLAGS
+    global TOOL_EXECUTABLE TOOL_OPTIONS
+    global GXX_UNDER_TEST
+
+    if ![info exists GXX_UNDER_TEST] then {
+	if [info exists TOOL_EXECUTABLE] {
+	    set GXX_UNDER_TEST $TOOL_EXECUTABLE;
+	} else {
+	    if [is_remote host] {
+		set GXX_UNDER_TEST [transform c++]
+	    } else {
+		set GXX_UNDER_TEST [findfile $base_dir/../xgcc "$base_dir/../xgcc -B$base_dir/../" [transform c++]]
+	    }
+	}
+    }
+
+    # Bleah, nasty. Bad taste.
+    if [ishost "*-dos-*" ] {
+	regsub "c\\+\\+" "$GXX_UNDER_TEST" "gcc" GXX_UNDER_TEST
+    }
+
+    if ![is_remote host] {
+	if { [which $GXX_UNDER_TEST] == 0 } then {
+	    perror "GXX_UNDER_TEST does not exist"
+	    exit 1
+	}
+    }
+    if ![info exists tmpdir] {
+	set tmpdir "/tmp"
+    }
+
+    if [info exists gluefile] {
+	unset gluefile
+    }
+
+    if { [target_info needs_status_wrapper] != "" } {
+	set gluefile ${tmpdir}/testglue.o;
+	set result [build_wrapper $gluefile];
+	if { $result != "" } {
+	    set gluefile [lindex $result 0];
+	    set wrap_flags [lindex $result 1];
+	} else {
+	    unset gluefile
+	}
+    }
+
+    set ALWAYS_CXXFLAGS ""
+
+    if ![is_remote host] {
+	lappend ALWAYS_CXXFLAGS "additional_flags=[g++_include_flags]";
+	lappend ALWAYS_CXXFLAGS "ldflags=[g++_link_flags]";
+	lappend ALWAYS_CXXFLAGS "incdir=$base_dir/../include"
+    }
+
+    if [info exists TOOL_OPTIONS] {
+	lappend ALWAYS_CXXFLAGS "additional_flags=$TOOL_OPTIONS";
+    }
+
+    verbose -log "ALWAYS_CXXFLAGS set to $ALWAYS_CXXFLAGS"
+
+    verbose "g++ is initialized" 3
+}
+
+
+proc g++_target_compile { source dest type options } {
+    global tmpdir;
+    global gpp_compile_options
+    global gluefile wrap_flags
+    global ALWAYS_CXXFLAGS;
+    global GXX_UNDER_TEST;
+
+    if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } {
+	lappend options "libs=${gluefile}"
+	lappend options "ldflags=${wrap_flags}"
+    }
+
+    lappend options "additional_flags=[libio_include_flags]"
+    lappend options "compiler=$GXX_UNDER_TEST";
+
+    set options [concat $options $gpp_compile_options]
+
+    set options [concat $options "$ALWAYS_CXXFLAGS"];
+
+    return [target_compile $source $dest $type $options]
+}
+
+proc g++_exit { args } {
+    global gluefile;
+
+    if [info exists gluefile] {
+	file_on_build delete $gluefile;
+	unset gluefile;
+    }
+}
+
+# If this is an older version of dejagnu (without runtest_file_p),
+# provide one and assume the old syntax: foo1.exp bar1.c foo2.exp bar2.c.
+# This can be deleted after the next dejagnu release.
+
+if { [info procs runtest_file_p] == "" } then {
+    proc runtest_file_p { runtests testcase } {
+	if { $runtests != "" && [regexp "\[.\]\[cC\]" $runtests] } then {
+	    if { [lsearch $runtests [file tail $testcase]] >= 0 } then {
+		return 1
+	    } else {
+		return 0
+	    }
+	}
+	return 1
+    }
+}
+
+# Provide a definition of this if missing (delete after next dejagnu release).
+
+if { [info procs prune_warnings] == "" } then {
+    proc prune_warnings { text } {
+	return $text
+    }
+}
+
+# Utility used by mike-g++.exp and old-dejagnu.exp.
+# Check the compiler(/assembler/linker) output for text indicating that
+# the testcase should be marked as "unsupported".
+#
+# When dealing with a large number of tests, it's difficult to weed out the
+# ones that are too big for a particular cpu (eg: 16 bit with a small amount
+# of memory).  There are various ways to deal with this.  Here's one.
+# Fortunately, all of the cases where this is likely to happen will be using
+# gld so we can tell what the error text will look like.
+
+proc ${tool}_check_unsupported_p { output } {
+    if [regexp "(^|\n)\[^\n\]*: region \[^\n\]* is full" $output] {
+	return "memory full"
+    }
+    return ""
+}
+
+proc ${tool}_option_help { } {
+    send_user "--additional_options,OPTIONS\t\tUse OPTIONS to compile the testcase files. OPTIONS should be comma-separated."
+}
+
+proc ${tool}_option_proc { option } {
+    if[regexp "^--additional_options," $option] {
+	global gpp_compile_options
+	regsub "--additional_options," $option "" option
+	foreach x [split $option ","] {
+	    lappend gpp_compile_options "additional_flags=$x"
+	}
+	return 1;
+    } else {
+	return 0
+    }
+}
diff --git a/gcc/testsuite/lib/gcc-dg.exp b/gcc/testsuite/lib/gcc-dg.exp
new file mode 100644
index 00000000000..9c66a5068c3
--- /dev/null
+++ b/gcc/testsuite/lib/gcc-dg.exp
@@ -0,0 +1,84 @@
+#   Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+# Define gcc callbacks for dg.exp.
+
+load_lib dg.exp
+
+proc gcc-dg-test { prog do_what extra_tool_flags } {
+    # Set up the compiler flags, based on what we're going to do.
+
+    switch $do_what {
+	"preprocess" {
+	    set compile_type "preprocess"
+	    set output_file "[file rootname [file tail $prog]].i"
+	}
+	"compile" {
+	    set compile_type "object"
+	    set output_file "[file rootname [file tail $prog]].s"
+	}
+	"assemble" {
+	    set compile_type "assembly"
+	    set output_file "[file rootname [file tail $prog]].o"
+	}
+	"link" {
+	    set compile_type "executable"
+	    set output_file "a.out"
+	    # The following line is needed for targets like the i960 where
+	    # the default output file is b.out.  Sigh.
+	}
+	"run" {
+	    set compile_type "executable"
+	    # FIXME: "./" is to cope with "." not being in $PATH.
+	    # Should this be handled elsewhere?
+	    # YES.
+	    set output_file "./a.out"
+	    # This is the only place where we care if an executable was
+	    # created or not.  If it was, dg.exp will try to run it.
+	    remote_file build delete $output_file;
+	}
+	default {
+	    perror "$do_what: not a valid dg-do keyword"
+	    return ""
+	}
+    }
+    set options ""
+    if { $extra_tool_flags != "" } {
+	lappend options "additional_flags=$extra_tool_flags"
+    }
+
+    set comp_output [gcc_target_compile "$prog" "$output_file" "$compile_type" $options];
+
+    return [list $comp_output $output_file]
+}
+
+
+proc gcc-dg-prune { system text } {
+    set text [prune_gcc_output $text]
+
+    # If we see "region xxx is full" then the testcase is too big for ram.
+    # This is tricky to deal with in a large testsuite like c-torture so
+    # deal with it here.  Just mark the testcase as unsupported.
+    if [regexp "(^|\n)\[^\n\]*: region \[^\n\]* is full" $text] {
+	# The format here is important.  See dg.exp.
+	return "::unsupported::memory full"
+    }
+
+    return $text
+}
diff --git a/gcc/testsuite/lib/gcc.exp b/gcc/testsuite/lib/gcc.exp
new file mode 100644
index 00000000000..ac11d0ba26d
--- /dev/null
+++ b/gcc/testsuite/lib/gcc.exp
@@ -0,0 +1,268 @@
+# Copyright (C) 1992, 1993, 1994, 1996, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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)
+# Currently maintained by Doug Evans (dje@cygnus.com)
+
+# This file is loaded by the tool init file (eg: unix.exp).  It provides
+# default definitions for gcc_start, etc. and other supporting cast members.
+
+# These globals are used by gcc_start if no compiler arguments are provided.
+# They are also used by the various testsuites to define the environment:
+# where to find stdio.h, libc.a, etc.
+
+# we want to use libgloss so we can get find_gcc.
+load_lib libgloss.exp
+
+#
+# GCC_UNDER_TEST is the compiler under test.
+#
+
+#
+# default_gcc_version -- extract and print the version number of the compiler
+#
+
+proc default_gcc_version { } {
+    global GCC_UNDER_TEST
+
+    gcc_init;
+
+    # ignore any arguments after the command
+    set compiler [lindex $GCC_UNDER_TEST 0]
+
+    if ![is_remote host] {
+	set compiler_name [which $compiler];
+    } else {
+	set compiler_name $compiler;
+    }
+
+    # verify that the compiler exists
+    if { $compiler_name != 0 } then {
+	set tmp [remote_exec host "$compiler -v"]
+	set status [lindex $tmp 0];
+	set output [lindex $tmp 1];
+	regexp "version.*$" $output version
+	if { $status == 0 && [info exists version] } then {
+	    clone_output "$compiler_name $version\n"
+	} else {
+	    clone_output "Couldn't determine version of $compiler_name: $output\n"
+	}
+    } else {
+	# compiler does not exist (this should have already been detected)
+	warning "$compiler does not exist"
+    }
+}
+
+#
+# Call gcc_version. We do it this way so we can override it if needed.
+#
+proc gcc_version { } {
+    default_gcc_version;
+}
+
+#
+# gcc_init -- called at the start of each .exp script.
+#
+# There currently isn't much to do, but always using it allows us to
+# make some enhancements without having to go back and rewrite the scripts.
+#
+
+set gcc_initialized 0
+
+proc gcc_init { args } {
+    global tmpdir
+    global libdir
+    global gluefile wrap_flags
+    global gcc_initialized
+    global GCC_UNDER_TEST
+    global TOOL_EXECUTABLE
+
+    if { $gcc_initialized == 1 } { return; }
+
+    if ![info exists GCC_UNDER_TEST] {
+	if [info exists TOOL_EXECUTABLE] {
+	    set GCC_UNDER_TEST $TOOL_EXECUTABLE;
+	} else {
+	    set GCC_UNDER_TEST "[find_gcc]"
+	}
+    }
+
+    if ![info exists tmpdir] then {
+	set tmpdir /tmp
+    }
+    if { [target_info needs_status_wrapper]!="" && ![info exists gluefile] } {
+	set gluefile ${tmpdir}/testglue.o;
+	set result [build_wrapper $gluefile];
+	if { $result != "" } {
+	    set gluefile [lindex $result 0];
+	    set wrap_flags [lindex $result 1];
+	} else {
+	    unset gluefile
+	}
+    }
+}
+
+proc gcc_target_compile { source dest type options } {
+    global tmpdir;
+    global gluefile wrap_flags;
+    global GCC_UNDER_TEST
+    global TOOL_OPTIONS
+
+    if { [target_info needs_status_wrapper]!="" && [info exists gluefile] } {
+	lappend options "libs=${gluefile}"
+	lappend options "ldflags=$wrap_flags"
+    }
+
+    if [target_info exists gcc,stack_size] {
+	lappend options "additional_flags=-DSTACK_SIZE=[target_info gcc,stack_size]"
+    }
+    if [target_info exists gcc,no_trampolines] {
+	lappend options "additional_flags=-DNO_TRAMPOLINES"
+    }
+    if [target_info exists gcc,no_label_values] {
+	lappend options "additional_flags=-DNO_LABEL_VALUES"
+    }
+    if [info exists TOOL_OPTIONS] {
+	lappend options "additional_flags=$TOOL_OPTIONS"
+    }
+    if [target_info exists gcc,no_varargs] {
+	lappend options "additional_flags=-DNO_VARARGS"
+    }
+    lappend options "compiler=$GCC_UNDER_TEST"
+    return [target_compile $source $dest $type $options]
+}
+
+#
+# gcc_pass -- utility to record a testcase passed
+#
+
+proc gcc_pass { testcase cflags } {
+    if { "$cflags" == "" } {
+	pass "$testcase"
+    } else {
+	pass "$testcase, $cflags"
+    }
+}
+
+#
+# gcc_fail -- utility to record a testcase failed
+#
+
+proc gcc_fail { testcase cflags } {
+    if { "$cflags" == "" } {
+	fail "$testcase"
+    } else {
+	fail "$testcase, $cflags"
+    }
+}
+
+#
+# gcc_finish -- called at the end of every .exp script that calls gcc_init
+#
+# The purpose of this proc is to hide all quirks of the testing environment
+# from the testsuites.  It also exists to undo anything that gcc_init did
+# (that needs undoing).
+#
+
+proc gcc_finish { } {
+    # The testing harness apparently requires this.
+    global errorInfo;
+
+    if [info exists errorInfo] then {
+	unset errorInfo
+    }
+
+    # Might as well reset these (keeps our caller from wondering whether
+    # s/he has to or not).
+    global prms_id bug_id
+    set prms_id 0
+    set bug_id 0
+}
+
+proc gcc_exit { } {
+    global gluefile;
+
+    if [info exists gluefile] {
+	file_on_build delete $gluefile;
+	unset gluefile;
+    }
+}
+    
+# If this is an older version of dejagnu (without runtest_file_p),
+# provide one and assume the old syntax: foo1.exp bar1.c foo2.exp bar2.c.
+# This can be deleted after next dejagnu release.
+
+if { [info procs runtest_file_p] == "" } then {
+    proc runtest_file_p { runtests testcase } {
+	if { $runtests != "" && [regexp "\[.\]\[cC\]" $runtests] } then {
+	    if { [lsearch $runtests [file tail $testcase]] >= 0 } then {
+		return 1
+	    } else {
+		return 0
+	    }
+	}
+	return 1
+    }
+}
+
+# Provide a definition of this if missing (delete after next dejagnu release).
+
+if { [info procs prune_warnings] == "" } then {
+    proc prune_warnings { text } {
+	return $text
+    }
+}
+
+# Utility used by mike-gcc.exp and c-torture.exp.
+# Check the compiler(/assembler/linker) output for text indicating that
+# the testcase should be marked as "unsupported".
+#
+# When dealing with a large number of tests, it's difficult to weed out the
+# ones that are too big for a particular cpu (eg: 16 bit with a small amount
+# of memory).  There are various ways to deal with this.  Here's one.
+# Fortunately, all of the cases where this is likely to happen will be using
+# gld so we can tell what the error text will look like.
+
+proc ${tool}_check_unsupported_p { output } {
+    if [regexp "(^|\n)\[^\n\]*: region \[^\n\]* is full" $output] {
+	return "memory full"
+    }
+    return ""
+}
+
+# Prune messages from gcc that aren't useful.
+
+proc prune_gcc_output { text } {
+    #send_user "Before:$text\n"
+    regsub -all "(^|\n)\[^\n\]*: In (function|method) \[^\n\]*" $text "" text
+    regsub -all "(^|\n)\[^\n\]*: At top level:\[^\n\]*" $text "" text
+
+    # It would be nice to avoid passing anything to gcc that would cause it to
+    # issue these messages (since ignoring them seems like a hack on our part),
+    # but that's too difficult in the general case.  For example, sometimes
+    # you need to use -B to point gcc at crt0.o, but there are some targets
+    # that don't have crt0.o.
+    regsub -all "(^|\n)\[^\n\]*file path prefix \[^\n\]* never used" $text "" text
+    regsub -all "(^|\n)\[^\n\]*linker input file unused since linking not done" $text "" text
+
+    #send_user "After:$text\n"
+
+    return $text
+}
+
diff --git a/gcc/testsuite/lib/mike-g++.exp b/gcc/testsuite/lib/mike-g++.exp
new file mode 100644
index 00000000000..10a1d2bcbb9
--- /dev/null
+++ b/gcc/testsuite/lib/mike-g++.exp
@@ -0,0 +1,264 @@
+# Copyright (C) 1988, 90, 91, 92, 95, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# This file was written by Mike Stump <mrs@cygnus.com>
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-g++@prep.ai.mit.edu
+
+#
+# mike_cleanup -- remove any files that are created by the testcase
+#
+proc mike_cleanup { src_code output_file assembly_file } {
+    remote_file build delete $output_file $assembly_file;
+}
+
+#
+# prebase -- sets up a Mike Stump (mrs@cygnus.com) style G++ test
+#
+proc prebase { } {
+    global compiler_output
+    global not_compiler_output
+    global compiler_result
+    global not_compiler_result
+    global program_output
+    global groups
+    global run 
+    global actions
+    global target_regexp
+
+    set compiler_output "^$"
+    set not_compiler_output ".*Internal compiler error.*"
+    set compiler_result ""
+    set not_compiler_result ""
+    set program_output ".*PASS.*"
+    set groups {}
+    set run no
+    set actions assemble
+    set target_regexp ".*"
+}
+
+#
+# run the test
+#
+proc postbase  { src_code run groups args } {
+    global verbose
+    global srcdir
+    global subdir
+    global not_compiler_output
+    global compiler_output
+    global compiler_result
+    global not_compiler_result
+    global program_output
+    global actions
+    global target_regexp
+    global host_triplet
+    global target_triplet
+    global tool
+    global tmpdir
+    global objdir
+    global base_dir
+
+    if ![regexp $target_regexp $target_triplet] {
+	unsupported $subdir/$src_code
+	return
+    }
+
+    if { [llength $args] > 0 } {
+	set comp_options [lindex $args 0];
+    } else {
+	set comp_options ""
+    }
+
+    set fail_message $subdir/$src_code
+    set pass_message $subdir/$src_code
+
+    if [info exists GROUP] {
+	if {[lsearch $groups $GROUP] == -1} {
+	    return
+	}
+    }
+
+    if [string match $run yes] {
+	set actions run
+    }
+
+    set output_file "$tmpdir/[file tail [file rootname $src_code]]"
+    set assembly_file "$output_file"
+    append assembly_file ".S"
+
+    set compile_type "none"
+
+    case $actions {
+	compile
+	{
+	    set compile_type "assembly";
+	    set output_file $assembly_file;
+	}
+	assemble
+	{
+	    set compile_type "object";
+	    append output_file ".o";
+	}
+	link
+	{
+	    set compile_type "executable";
+	    set output_file "$tmpdir/a.out";
+	}
+	run
+	{
+	    set compile_type "executable";
+	    set output_file "$tmpdir/a.out";
+	    set run yes;
+	}
+	default
+	{
+	    set output_file "";
+	    set compile_type "none";
+	}
+    }
+
+    set src_file "$srcdir/$subdir/$src_code"
+    set options ""
+
+    if { $comp_options != "" } {
+	lappend options "additional_flags=$comp_options"
+    }
+
+    if ![ishost "*-dos-*"] {
+	lappend options "libs=-lstdc++ -lg++"
+    } else {
+	lappend options "libs=-lstdcxx -lgxx"
+    }
+
+    set comp_output [g++_target_compile $src_file $output_file $compile_type $options]
+
+    set pass no
+
+    # Delete things like "ld.so warning" messages.
+    set comp_output [prune_warnings $comp_output]
+
+    if [regexp -- $not_compiler_output $comp_output] {
+	if { $verbose > 1 } {
+	    send_user "\nChecking:\n$not_compiler_output\nto make sure it does not match:\n$comp_output\nbut it does.\n\n"
+	} else {
+	    send_log "\nCompiler output:\n$comp_output\n\n"
+	}
+	fail $fail_message
+	# The framework doesn't like to see any error remnants,
+	# so remove them.
+	uplevel {
+	    if [info exists errorInfo] {
+		unset errorInfo
+	    }
+	}
+	mike_cleanup $src_code $output_file $assembly_file
+	return
+    }
+
+    # remove any leftover CRs.
+    regsub -all -- "\r" $comp_output "" comp_output
+
+    regsub -all "(^|\n)\[^\n\]*linker input file unused since linking not done" $comp_output "" comp_output
+    regsub -all "(^|\n)\[^\n\]*file path prefix \[^\n\]* never used" $comp_output "" comp_output
+
+    set unsupported_message [${tool}_check_unsupported_p $comp_output]
+    if { $unsupported_message != "" } {
+	unsupported "$subdir/$src_code: $unsupported_message"
+	mike_cleanup $src_code $output_file $assembly_file
+	return
+    }
+
+    if { $verbose > 1 } {
+	send_user "\nChecking:\n$compiler_output\nto see if it matches:\n$comp_output\n"
+    } else {
+	send_log "\nCompiler output:\n$comp_output\n\n"
+    }
+    if [regexp -- $compiler_output $comp_output] {
+	if { $verbose > 1 } {
+	    send_user "Yes, it matches.\n\n"
+	}
+	set pass yes
+	if [file exists [file rootname [file tail $src_code]].s] {
+	    set fd [open [file rootname [file tail $src_code]].s r]
+	    set dot_s [read $fd]
+	    close $fd
+	    if { $compiler_result != "" } {
+		verbose "Checking .s file for $compiler_result" 2
+		if [regexp -- $compiler_result $dot_s] {
+		    verbose "Yes, it matches." 2
+		} else {
+		    verbose "Nope, doesn't match." 2
+		    verbose $dot_s 4
+		    set pass no
+		}
+	    }
+	    if { $not_compiler_result != "" } {
+		verbose "Checking .s file for not $not_compiler_result" 2
+		if ![regexp -- $not_compiler_result $dot_s] {
+		    verbose "Nope, not found (that's good)." 2
+		} else {
+		    verbose "Uh oh, it was found." 2
+		    verbose $dot_s 4
+		    set pass no
+		}
+	    }
+	}
+	if [string match $run yes] {
+	    set result [g++_load $output_file]
+	    set status [lindex $result 0];
+	    set output [lindex $result 1];
+
+	    if { $status == -1 } {
+		mike_cleanup $src_code $output_file $assembly_file;
+		return;
+	    }
+	    if { $verbose > 1 } {
+		send_user "Checking:\n$program_output\nto see if it matches:\n$output\n\n"
+	    }
+	    if ![regexp -- $program_output $output] {
+		set pass no
+		if { $verbose > 1 } {
+		    send_user "Nope, does not match.\n\n"
+		}
+	    } else {
+		if { $verbose > 1 } {
+		    send_user "Yes, it matches.\n\n"
+		}
+	    }
+	}
+    } else {
+	if { $verbose > 1 } {
+	    send_user "Nope, does not match.\n\n"
+	}
+    }
+
+    if [string match $pass "yes"] {
+	pass $pass_message
+    } else {
+	fail $fail_message
+    }
+
+    # The framework doesn't like to see any error remnants,
+    # so remove them.
+    uplevel {
+	if [info exists errorInfo] {
+	    unset errorInfo
+	}
+    }
+
+    mike_cleanup $src_code $output_file $assembly_file
+}
diff --git a/gcc/testsuite/lib/mike-gcc.exp b/gcc/testsuite/lib/mike-gcc.exp
new file mode 100644
index 00000000000..f9c766a9026
--- /dev/null
+++ b/gcc/testsuite/lib/mike-gcc.exp
@@ -0,0 +1,262 @@
+# Copyright (C) 1988, 90, 91, 92, 95, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# This file was derived from mike-g++.exp written by Mike Stump <mrs@cygnus.com>
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gcc@prep.ai.mit.edu
+
+#
+# mike_cleanup -- remove any files that are created by the testcase
+#
+proc mike_cleanup { src_code output_file assembly_file } {
+    remote_file build delete $output_file $assembly_file;
+}
+
+#
+# prebase -- sets up a Mike Stump (mrs@cygnus.com) style gcc test
+#
+proc prebase { } {
+    global compiler_output
+    global not_compiler_output
+    global compiler_result
+    global not_compiler_result
+    global program_output
+    global groups
+    global run 
+    global actions
+    global target_regexp
+
+    set compiler_output "^$"
+    set not_compiler_output ".*Internal compiler error.*"
+    set compiler_result ""
+    set not_compiler_result ""
+    set program_output ".*PASS.*"
+    set groups {}
+    set run no
+    set actions assemble
+    set target_regexp ".*"
+}
+
+#
+# run the test
+#
+proc postbase  { src_code run groups args } {
+    global verbose
+    global srcdir
+    global subdir
+    global not_compiler_output
+    global compiler_output
+    global compiler_result
+    global not_compiler_result
+    global program_output
+    global actions
+    global target_regexp
+    global host_triplet
+    global target_triplet
+    global tool
+    global tmpdir
+    global GCC_UNDER_TEST
+    global GROUP
+
+    if ![info exists GCC_UNDER_TEST] {
+	error "No compiler specified for testing."
+    }
+
+    if ![regexp $target_regexp $target_triplet] {
+	unsupported $subdir/$src_code
+	return
+    }
+
+    if { [llength $args] > 0 } {
+	set comp_options [lindex $args 0];
+    } else {
+	set comp_options ""
+    }
+
+    set fail_message $subdir/$src_code
+    set pass_message $subdir/$src_code
+
+    if [info exists GROUP] {
+	if {[lsearch $groups $GROUP] == -1} {
+	    return
+	}
+    }
+
+    if [string match $run yes] {
+	set actions run
+    }
+
+    set output_file "$tmpdir/[file tail [file rootname $src_code]]"
+    set assembly_file "$output_file"
+    append assembly_file ".S"
+
+    set compile_type "none"
+
+    case $actions {
+	compile
+	{
+	    set compile_type "assembly";
+	    set output_file $assembly_file;
+	}
+	assemble
+	{
+	    set compile_type "object";
+	    append output_file ".o";
+	}
+	link
+	{
+	    set compile_type "executable";
+	    set output_file "$tmpdir/a.out";
+	}
+	run
+	{
+	    set compile_type "executable";
+	    set output_file "$tmpdir/a.out";
+	    set run yes;
+	}
+	default
+	{
+	    set output_file "";
+	    set compile_type "none";
+	}
+    }
+
+    set src_file "$srcdir/$subdir/$src_code"
+    set options ""
+    lappend options "compiler=$GCC_UNDER_TEST"
+
+    if { $comp_options != "" } {
+	lappend options "additional_flags=$comp_options"
+    }
+
+    set comp_output [gcc_target_compile $src_file $output_file $compile_type $options];
+
+    set pass no
+
+    # Delete things like "ld.so warning" messages.
+    set comp_output [prune_warnings $comp_output]
+
+    if [regexp -- $not_compiler_output $comp_output] {
+	if { $verbose > 1 } {
+	    send_user "\nChecking:\n$not_compiler_output\nto make sure it does not match:\n$comp_output\nbut it does.\n\n"
+	} else {
+	    send_log "\nCompiler output:\n$comp_output\n\n"
+	}
+	fail $fail_message
+	# The framework doesn't like to see any error remnants,
+	# so remove them.
+	uplevel {
+	    if [info exists errorInfo] {
+		unset errorInfo
+	    }
+	}
+	mike_cleanup $src_code $output_file $assembly_file
+	return
+    }
+
+    # remove any leftover CRs.
+    regsub -all -- "\r" $comp_output "" comp_output
+
+    regsub -all "(^|\n)\[^\n\]*linker input file unused since linking not done" $comp_output "" comp_output
+    regsub -all "(^|\n)\[^\n\]*file path prefix \[^\n\]* never used" $comp_output "" comp_output
+
+    set unsupported_message [${tool}_check_unsupported_p $comp_output]
+    if { $unsupported_message != "" } {
+	unsupported "$subdir/$src_code: $unsupported_message"
+	mike_cleanup $src_code $output_file $assembly_file
+	return
+    }
+
+    if { $verbose > 1 } {
+	send_user "\nChecking:\n$compiler_output\nto see if it matches:\n$comp_output\n"
+    } else {
+	send_log "\nCompiler output:\n$comp_output\n\n"
+    }
+    if [regexp -- $compiler_output $comp_output] {
+	if { $verbose > 1 } {
+	    send_user "Yes, it matches.\n\n"
+	}
+	set pass yes
+	if [file exists [file rootname [file tail $src_code]].s] {
+	    set fd [open [file rootname [file tail $src_code]].s r]
+	    set dot_s [read $fd]
+	    close $fd
+	    if { $compiler_result != "" } {
+		verbose "Checking .s file for $compiler_result" 2
+		if [regexp -- $compiler_result $dot_s] {
+		    verbose "Yes, it matches." 2
+		} else {
+		    verbose "Nope, doesn't match." 2
+		    verbose $dot_s 4
+		    set pass no
+		}
+	    }
+	    if { $not_compiler_result != "" } {
+		verbose "Checking .s file for not $not_compiler_result" 2
+		if ![regexp -- $not_compiler_result $dot_s] {
+		    verbose "Nope, not found (that's good)." 2
+		} else {
+		    verbose "Uh oh, it was found." 2
+		    verbose $dot_s 4
+		    set pass no
+		}
+	    }
+	}
+	if [string match $run yes] {
+	    set result [gcc_load $output_file]
+	    set status [lindex $result 0];
+	    set output [lindex $result 1];
+	    if { $status == -1 } {
+		mike_cleanup $src_code $output_file $assembly_file;
+		return;
+	    }
+	    if { $verbose > 1 } {
+		send_user "Checking:\n$program_output\nto see if it matches:\n$output\n\n"
+	    }
+	    if ![regexp -- $program_output $output] {
+		set pass no
+		if { $verbose > 1 } {
+		    send_user "Nope, does not match.\n\n"
+		}
+	    } else {
+		if { $verbose > 1 } {
+		    send_user "Yes, it matches.\n\n"
+		}
+	    }
+	}
+    } else {
+	if { $verbose > 1 } {
+	    send_user "Nope, does not match.\n\n"
+	}
+    }
+
+    if [string match $pass "yes"] {
+	pass $pass_message
+    } else {
+	fail $fail_message
+    }
+
+    # The framework doesn't like to see any error remnants,
+    # so remove them.
+    uplevel {
+	if [info exists errorInfo] {
+	    unset errorInfo
+	}
+    }
+
+    mike_cleanup $src_code $output_file $assembly_file
+}
diff --git a/gcc/testsuite/lib/old-dejagnu.exp b/gcc/testsuite/lib/old-dejagnu.exp
new file mode 100644
index 00000000000..cd7f46b4f17
--- /dev/null
+++ b/gcc/testsuite/lib/old-dejagnu.exp
@@ -0,0 +1,536 @@
+# Copyright (C) 1988, 90, 91, 92, 1994, 1996, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-g++@prep.ai.mit.edu
+
+# This file was written by Rob Savoye. (rob@cygnus.com)
+# With modifications by Mike Stump <mrs@cygnus.com>.
+
+# These tests come from the original DejaGnu test suite 
+# developed at Cygnus Support. If this isn't deja gnu, I
+# don't know what is.
+#
+# Language independence is achieved by:
+#
+# 1) Using global $tool to indicate the language (eg: gcc, g++, etc.).
+#    This should only be used to look up other objects.  We don't want to
+#    have to add code for each new language that is supported.  If this is
+#    done right, no code needs to be added here for each new language.
+#
+# 2) Passing compiler options in as arguments.
+#
+# We require a bit of smarts in our caller to isolate us from the vagaries of
+# each language.  See old-deja.exp for the g++ example.
+
+# Useful subroutines.
+
+# process-option -- Look for and process a test harness option in the testcase.
+#
+# PROG is the pathname of the testcase.
+# OPTION is the string to look for.
+# MESSAGE is what to print if $verbose > 1.
+# FLAG_NAME is one of ERROR, WARNING, etc.
+# PATTERN is ???
+
+proc process-option { prog option message flag_name pattern } {
+    global verbose
+
+    set result ""
+
+    set tmp [grep $prog "$option.*" line]
+    if ![string match "" $tmp] then {
+	foreach i $tmp {
+	    #send_user "Found: $i\n"
+	    set xfail_test 0
+	    set triplet_match 0
+	    regsub "\\*/$" [string trim $i] "" i
+	    if [regexp "LINE +\[0-9\]+" $i xopt] then {
+		regsub "LINE" $xopt "" xopt;
+		regsub "LINE +\[0-9\]+" $i "" i
+		set i [lreplace $i 0 0 [expr "${xopt}-0"]];
+	    }
+	    if [regexp "XFAIL( +\[^ \]+-\[^ \]+-\[^ \]+)*" $i xopt] then {
+		set xfail_test 1
+		regsub "XFAIL( +\[^ \]+-\[^ \]+-\[^ \]+)*" $i "" i
+		regsub "XFAIL" $xopt "" xopt
+		if ![string match "" [string trim $xopt]] then {
+		    foreach triplet $xopt {
+			if [istarget $triplet] {
+			    set triplet_match 1;
+			    break;
+			}
+		    }
+		} else {
+		    set triplet_match 1
+		}
+	    }
+	    set compos [expr [llength $option] + 1] ;# Start of comment, if any
+	    if { $xfail_test && $triplet_match } then {
+		lappend result [list [lindex $i 0] "X$flag_name" [lrange $i $compos end] "$pattern"]
+	    } else {
+		lappend result [list [lindex $i 0] "$flag_name" [lrange $i $compos end] "$pattern"]
+	    }
+	    if { $verbose > 1 } then {
+		if [string match "" [lrange $i $compos end]] then {
+		    send_user "Found $message for line [lindex $i 0]\n"
+		} else {
+		    send_user "Found $message \"[lrange $i $compos end]\" for line [lindex $i 0]\n"
+		}
+	    }
+	}
+    }
+
+    #send_user "Returning: $result\n"
+    return $result
+}
+
+# old-dejagnu-init -- set up some statistics collectors
+#
+# There currently isn't much to do, but always calling it allows us to add
+# enhancements without having to update our callers.
+# It must be run before calling `old-dejagnu'.
+
+proc old-dejagnu-init { } {
+}
+
+# old-dejagnu-stat -- print the stats of this run
+#
+# ??? This is deprecated, and can be removed.
+
+proc old-dejagnu-stat { } {
+}
+
+# old-dejagnu -- runs an old style DejaGnu test.
+#
+# Returns 0 if successful, 1 if their were any errors.
+# PROG is the full path name of the file to compile.
+#
+# CFLAGS_VAR is the name of the global variable containing compiler flags.
+# We ignore this now.
+#
+# CFLAGS is the options to always pass to the compiler.
+# This is also ignored.
+#
+# DEFAULT_CFLAGS are additional options if the testcase has none.
+#
+# LIBS_VAR is the name of the global variable containing libraries (-lxxx's).
+# This is also ignored.
+#
+# LIBS is any additional libraries to link with.  This *cannot* be specified
+# with the compiler flags because otherwise gcc will issue, for example, a
+# "-lg++ argument not used since linking not done" warning which will screw up
+# the test for excess errors.  We could ignore such messages instead.
+#
+# Think of "cflags" here as "compiler flags", not "C compiler flags".
+
+proc old-dejagnu { compiler prog cflagsx default_cflags libs } {
+    global verbose
+    global tool
+    global subdir		;# eg: g++.old-dejagnu
+    global host_triplet
+    global tmpdir
+
+    set runflag 1
+    set execbug_flag 0
+    set excessbug_flag 0
+    set pattern ""
+    set text "\[- A-Za-z0-9\.\;\"\_\:\'\`\(\)\!\#\=\+\?\&\*]*"
+
+    if ![info exists tmpdir] then {
+	set tmpdir "/tmp"
+    }
+
+# look for keywords that change the compiler options
+#
+# There are two types of test, negative and affirmative. Negative
+# tests have the keyword of "ERROR - " or "WARNING - " on the line
+# expected to produce an error. This is followed by the pattern. If
+# the desired error or warning message appears, then the test passes.
+# 
+# Affirmative test can have the following keywords "gets bogus error",
+# "causes invalid C code", "invalid assembly code", "causes abort",
+# "causes segfault", "causes linker error", "execution test fails". If
+# the pattern after the keyword matches, then the test is a failure.
+#
+# One can specify particular targets for expected failures of the above
+# keywords by putting "XFAIL target-triplet" after the keyword.
+#
+# Example:
+#
+# void f ()
+#{
+#  int i[2], j;
+#  A a (int (i[1]), j);		// gets bogus error - late parsing XFAIL *-*-*
+#  A b (int (i[1]), int j);	// function
+#  a.k = 0;			// gets bogus error - late parsing XFAIL *-*-*
+#  b (i, j);
+#}
+#
+# Note also, that one can add a comment with the keyword ("late parsing"
+# in the above example).
+#
+# If any of the tests contain the special pattern "FIXME -" that test is
+# not run because it will produce incorrect output.
+#
+# Testcases can supply special options to the compiler with a line containing
+# "Special.*Options: ...", where ".*" can be anything (eg: g++) and "..." are
+# the additional options to pass to the compiler.  Nothing else may appear
+# after the options.  IE: for a C testcase
+# /* Special Options: -fomit-frame-pointer */  /* Oops! */
+# is wrong,
+# /* Special Options: -fomit-frame-pointer */
+# is right.  If no such Special Options are found, $default_cflags is used.
+# FIXME: Can there be multiple lines of these?
+#
+# Other keywords: "Build don't link:", "Build don't run:".
+
+    # FIXME: none of the current test cases use this, so It's not implemented
+    # set tmp [grep $prog "remove -sanitize"]
+
+    set name "[file tail [file dirname $prog]]/[file tail $prog]"
+
+    set tmp [grep $prog "FIXME -.*"]
+    if ![string match "" $tmp] then {
+	foreach i $tmp {
+	    warning "[file tail [file dirname $prog]]/[file tail $prog] [lrange $i 2 end]"
+	}
+	return 1
+    }
+
+    set tmp [lindex [grep $prog "Special.*Options:.*"] 0]
+    set cflags ""
+
+    regsub -all "\n\[^\n\]+(\n|$)" $tmp "\n" tmp
+    set tmp [string trim $tmp]
+    if ![string match "" $tmp] then {
+	regsub "^.*Special.*Options:" $tmp "" tmp
+	lappend cflags "additional_flags=$tmp"
+	verbose "Adding special options $tmp" 2
+    } else {
+	lappend cflags "additional_flags=$default_cflags"
+    }
+
+    if { $cflagsx != "" } {
+	lappend cflags "additional_flags=$cflagsx"
+    }
+
+    lappend cflags "compiler=$compiler"
+
+    set output "$tmpdir/a.out"
+    set compile_type "executable"
+
+    set tmp [lindex [grep $prog "Build don.t link:"] 0]
+    if ![string match "" $tmp] then {
+	set compile_type "object"
+	set runflag 0
+	set output "$tmpdir/[file tail [file rootname $prog]].o"
+	verbose "Will compile $prog to object" 3
+    }
+
+    set tmp [lindex [grep $prog "Build don.t run:"] 0]
+    if ![string match "" $tmp] then {
+	set runflag 0
+	verbose "Will compile $prog to binary" 3
+    }
+
+    set tmp [grep $prog "Skip if (|not )feature:.*"];
+    if { $tmp != "" } {
+	foreach line $tmp {
+	    if [regexp "Skip if not feature" $line] {
+		set not 1;
+	    } else {
+		set not 0;
+	    }
+	    regsub "^.*Skip if (|not )feature:\[ 	\]*" "$line" "" i;
+	    set is_set 0;
+	    foreach j $i {
+		if [target_info exists $j] {
+		    set is_set 1;
+		    break;
+		}
+	    }
+	    if { $is_set != $not } {
+		untested "$name: Test skipped: ${line}($j set)"
+		return;
+	    }
+	}
+    }
+
+    set tmp [grep $prog "Skip if (|not )target:.*"];
+    if { $tmp != "" } {
+	foreach line $tmp {
+	    if [regexp "Skip if not target:" $line] {
+		set not 1;
+	    } else {
+		set not 0;
+	    }
+	    regsub "^.*Skip if (|not )target:\[ 	\]*" "$line" "" i;
+	    set ist 0;
+	    foreach j $i {
+		if [istarget $j] {
+		    set ist 1;
+		    break;
+		}
+	    }
+	    if { $ist != $not } {
+		untested "$name: Test skipped: ${line}"
+		return;
+	    }
+	}
+    }
+
+    if ![isnative] {
+	set tmp [lindex [grep $prog "Skip if not native"] 0];
+	if { $tmp != "" } {
+	    untested "$name: Test skipped because not native";
+	    return;
+	}
+    } else {
+	set tmp [lindex [grep $prog "Skip if native"] 0];
+	if { $tmp != "" } {
+	    untested "$name: Test skipped because native";
+	    return;
+	}
+    }
+
+    lappend cflags "libs=$libs"
+
+#
+# Look for the other keywords and extract the error messages.
+# `message' contains all the things we found.
+# ??? We'd like to use lappend below instead of concat, but that doesn't
+# work (adds an extra level of nesting to $tmp).
+#
+
+    set message ""
+
+    set tmp [process-option $prog "ERROR - " "an error message" ERROR "$text error$text"]
+    if ![string match "" $tmp] then {
+	set runflag 0
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "WARNING - " "a warning message" WARNING "warning"]
+    if ![string match "" $tmp] then {
+	set runflag 0
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "gets bogus error" "a bogus error" BOGUS $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "causes invalid C code" "a bad C translation" BADC $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "invalid assembly code" "some invalid assembly code" BADASM $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "causes abort" "an abort cause" ABORT $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "causes segfault" "a segfault cause" SEGFAULT $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "causes linker error" "a linker error" LINKER $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "execution test fails" "an execution failure" EXEC $text]
+    if ![string match "" $tmp] then {
+	set execbug_flag 1
+	set message [concat $message $tmp]
+    }
+
+    set tmp [process-option $prog "excess errors test fails" "an excess error failure" EXCESSO $text]
+    if ![string match "" $tmp] then {
+	set excessbug_flag 1
+	set message [concat $message $tmp]
+	warning "please use excess errors test - XFAIL *-*-* in $prog instead"
+    }
+
+    set tmp [process-option $prog "excess errors test - " "an excess error failure" EXCESS $text]
+    if ![string match "" $tmp] then {
+	set message [concat $message $tmp]
+    }
+
+#
+#  run the compiler and analyze the results
+#
+
+    # Since we don't check return status of the compiler, make sure
+    # we can't run a.out when the compilation fails.
+    remote_file build delete $output
+    set comp_output [${tool}_target_compile $prog $output $compile_type $cflags]
+
+    # Delete things like "ld.so: warning" messages.
+    set comp_output [prune_warnings $comp_output]
+
+    if [string match "*Internal compiler error: program*got fatal signal 6" $comp_output] then {
+	fail "$name Got Signal 6"
+	remote_file build delete $output
+	return 1
+    }
+    if [string match "*Internal compiler error: program*got fatal signal 11" $comp_output] then {
+	fail "$name Got Signal 11"
+	remote_file build delete $output
+	return 1
+    }
+
+    #send_user "\nold_dejagnu.exp: comp_output1 = :$comp_output:\n\n"
+    #send_user "\nold_dejagnu.exp: message = :$message:\n\n"
+    #send_user "\nold_dejagnu.exp: message length = [llength $message]\n\n"
+
+    foreach i $message {
+
+	#send_user "\nold_dejagnu.exp: i = :$i:\n\n"
+
+	# Remove all error messages for the line [lindex $i 0]
+	# in the source file.  If we find any, success!
+	set line [lindex $i 0]
+	set pattern [lindex $i 2]
+	if [regsub -all "(^|\n)\[^\n\]+:$line:\[^\n\]*" $comp_output "" comp_output] then {
+            set comp_output [string trimleft $comp_output]
+	    set ok pass
+	    set uhoh fail
+	} else {
+	    set ok fail
+	    set uhoh pass
+	}
+
+	case [lindex $i 1] {
+	    "ERROR" {
+		$ok "$name $pattern (test for errors, line $line)"
+	    }
+	    "XERROR" {
+		x$ok "$name $pattern (test for errors, line $line)"
+	    }
+	    "WARNING" {
+		$ok "$name $pattern (test for warnings, line $line)"
+	    }
+	    "XWARNING" {
+		x$ok "$name $pattern (test for warnings, line $line)"
+	    }
+	    "BOGUS" {
+		$uhoh "$name $pattern (test for bogus messages, line $line)"
+	    }
+	    "XBOGUS" {
+		x$uhoh "$name $pattern (test for bogus messages, line $line)"
+	    }
+	    "ABORT" {
+		$uhoh "$name $pattern (test for compiler aborts, line $line)"
+	    }
+	    "XABORT" {
+		x$uhoh "$name $pattern (test for compiler aborts, line $line)"
+	    }
+	    "SEGFAULT" {
+		$uhoh "$name $pattern (test for compiler segfaults, line $line)"
+	    }
+	    "XSEGFAULT" {
+		x$uhoh "$name $pattern (test for compiler segfaults, line $line)"
+	    }
+	    "LINKER" {
+		$uhoh "$name $pattern (test for linker problems, line $line)"
+	    }
+	    "XLINKER" {
+		x$uhoh "$name $pattern (test for linker problems, line $line)"
+	    }
+	    "BADC" {
+		$uhoh "$name $pattern (test for Bad C code, line $line)"
+	    }
+	    "XBADC" {
+		x$uhoh "$name $pattern (test for Bad C code, line $line)"
+	    }
+	    "BADASM" {
+		$uhoh "$name $pattern (test for bad assembler, line $line)"
+	    }
+	    "XBADASM" {
+		x$uhoh "$name $pattern (test for bad assembler, line $line)"
+	    }
+	    "XEXEC" { }
+	    "XEXCESS" {
+		set excessbug_flag 1
+	    }
+	}
+	#send_user "\nold_dejagnu.exp: comp_output2= :$comp_output:\n\n"
+    }
+    #send_user "\nold_dejagnu.exp: comp_output3 = :$comp_output:\n\n"
+
+    #look to see if this is all thats left, if so, all messages have been handled
+    #send_user "comp_output: $comp_output\n"
+    regsub -all "(^|\n)\[^\n\]*: In (function|method) \[^\n\]*" $comp_output "" comp_output
+    regsub -all "(^|\n)\[^\n\]*: At top level:\[^\n\]*" $comp_output "" comp_output
+    regsub -all "(^|\n)\[^\n\]*file path prefix \[^\n\]* never used" $comp_output "" comp_output
+    regsub -all "(^|\n)\[^\n\]*linker input file unused since linking not done" $comp_output "" comp_output
+
+    set unsupported_message [${tool}_check_unsupported_p $comp_output]
+    if { $unsupported_message != "" } {
+	unsupported "$name: $unsupported_message"
+	return
+    }
+
+    # someone forgot to delete the extra lines
+    regsub -all "\n+" $comp_output "\n" comp_output
+    regsub "^\n+" $comp_output "" comp_output
+    #send_user "comp_output: $comp_output\n"
+    
+    # excess errors
+    if $excessbug_flag then {
+	setup_xfail "*-*-*"
+    }
+    if ![string match "" $comp_output] then {
+	fail "$name (test for excess errors)"
+	send_log "$comp_output\n"
+    } else {
+	pass "$name (test for excess errors)"
+    }
+
+    # run the executable image
+    if $runflag then {
+	set executable $output
+	if ![file exists $executable] then {
+	    # Since we couldn't run it, we consider it an expected failure,
+	    # so that test cases don't appear to disappear, and reappear.
+	    setup_xfail "*-*-*"
+	    fail "$name $pattern Execution test"
+	} else {
+	    set status -1
+	    set result [eval [format "%s_load %s" $tool $executable]]
+	    set status [lindex $result 0];
+	    set output [lindex $result 1];
+	    remote_file build delete $executable;
+	    if { $execbug_flag || $excessbug_flag } then {
+		setup_xfail "*-*-*"
+	    }
+	    $status "$name $pattern Execution test"
+	}
+    }
+
+    verbose "deleting $output"
+    remote_file build delete $output
+    return 0
+}