path: root/gcc/f/gbe/2.7.2.3.diff

IMPORTANT: After applying this patch, you must rebuild the
Info documentation derived from the Texinfo files in the
gcc distribution, as this patch does not include patches
to any derived files (due to differences in the way gcc
version 2.7.2.2 is obtained by users).  Use the following
command sequence after applying this patch:

  cd gcc-2.7.2.3; make -f Makefile.in gcc.info

If that fails due to `makeinfo' not being installed, obtain
texinfo-3.11.tar.gz from a GNU distribution site, unpack,
build, and install it, and try the above command sequence
again.

NOTE: You probably will have trouble with the `ChangeLog'
file in this patch.  That's because gcc version 2.7.2.2 itself
had an incomplete patch file (gcc-2.7.2.2-2.7.2.3.diff.gz
omitted the patch to gcc/ChangeLog), which in turn "infected"
both forms of the 2.7.2.3 distribution (the .tar.gz and .diff.gz
file, neither of which has the proper gcc/ChangeLog file).

The following patch's gcc/ChangeLog patchlet assumes a
"fixed" gcc-2.7.2.3/ChangeLog, and then further "fixes" it
to sort the pertinent entries in the usual chronological order.

If you start with the gcc-2.7.2.2.tar.gz distribution, apply
the gcc-2.7.2.2-2.7.2.3.diff.gz patch, "fix up" the gcc/ChangeLog
file so the new material ends up "above" the single large
2.7.2.2 release entry (dated "Tue Jan 29 02:47:13 1997"), then
you *should* be able to apply this patch file cleanly.

In any case, don't worry; the contents of gcc/ChangeLog aren't
really important to non-developers of gcc.


diff -rcp2N gcc-2.7.2.3/ChangeLog gcc-2.7.2.3.f.2/ChangeLog
*** gcc-2.7.2.3/ChangeLog	Sun Mar 15 10:46:38 1998
--- gcc-2.7.2.3.f.2/ChangeLog	Tue Mar  3 18:05:03 1998
***************
*** 1,6 ****
--- 1,111 ----
+ Sun Mar  1 01:11:48 1998  Craig Burley  <burley@gnu.org>
+ 
+ 	* genattrtab.c (pc_rtx): Define global here, so linking works.
+ 
+ Sun Mar  1 01:10:16 1998  Bernd Schmidt  <crux@pool.informatik.rwth-aachen.de>
+ 
+ 	* basic-block.h (basic_block_computed_jump_target): Declare.
+ 	* flags.h: (current_function_has_computed_jump): Declare.
+ 	* flow.c: (basic_block_computed_jump_target): Define.
+ 	(flow_analysis): Allocate it. Set current_function_has_computed_jump
+ 	to 0.
+ 	(find_basic_blocks): Set current_function_has_computed_jump and
+ 	elements of basic_block_computed_jump_target to 1 as appropriate.
+ 	* function.c: (current_function_has_computed_jump): Define.
+ 	* global.c (global_conflicts): Don't allocate pseudos into stack regs
+ 	at the start of a block that is reachable by a computed jump.
+ 	* reg-stack.c (stack_reg_life_analysis): If must restart, do so
+ 	immediately.
+ 	(subst_stack_regs): Undo change from Aug 26 1997.
+ 	(uses_reg_or_mem): Now unused, deleted.
+ 	* stupid.c (stupid_life_analysis): Compute
+ 	current_function_has_computed_jump.
+ 	(stupid_find_reg): Don't allocate stack regs if the function has a
+ 	computed goto.
+ 
+ Thu Feb 26 16:13:44 1998  Craig Burley  <burley@gnu.org>
+ 
+ 	* emit-rtl.c (gen_lowpart_common): Install fix from
+ 	<chris@lslsun.epfl.ch> to get right subword.
+ 
+ Fri Feb 13 08:41:49 1998  Robert Lipe	<robertl@dgii.com>
+ 
+ 	* rtlanal.c (computed_jump_p): Remove unused variable 'computed_jump'.
+ 
+ Thu Dec  4 06:34:40 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* stmt.c (pushcase_range): Clean up handling of "infinite" values.
+ 
+ Mon Oct  6 18:27:12 1997  Richard Henderson  <rth@cygnus.com>
+ 
+ 	* alpha.h (FLOAT_STORE_FLAG_VALUE): It's 2.0 not 0.5.
+ 
+ Mon Sep 29 16:12:38 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* c-parse.gperf: Replace `restrict' with `__restrict__',
+ 	to avoid collisions with C programs that use `restrict'
+ 	as a variable name -- this makes `restrict' support much
+ 	more like `complex' support.
+ 
+ Sun Sep 28 17:13:34 1997  Richard Henderson  <rth@cygnus.com>
+ 
+ 	* alias.c (base_alias_check): Two symbols can conflict if they
+ 	are accessed via AND.
+ 	(memrefs_conflict_p): Likewise.
+ 
+ Tue Sep 23 00:59:54 1997  Jeffrey A Law  (law@cygnus.com)
+ 
+ 	* rtlanal.c (computed_jump_p): Fix typo in last change.
+ 
+ Sun Sep 21 17:45:45 1997  Jeffrey A Law  (law@cygnus.com)
+ 
+ 	* flow.c (jmp_uses_reg_or_mem): Deleted unused function.
+ 	(find_basic_blocks): Use computed_jump_p to determine if a
+ 	particular JUMP_INSN is a computed jump.
+ 	* reg-stack.c (find_blocks): Use computed_jump_p to determine
+ 	if a particular JUMP_INSN is a computed jump.
+ 	* rtlanal.c (jmp_uses_reg_or_mem): New function.
+ 	(computed_jump_p): Likewise.
+ 	* rtl.h (computed_jump_p): Declare.
+ 
+ Mon Sep 15 17:47:12 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* expr.c (safe_from_p_1): Fix thinko, avoid trashing stack
+ 	when compiling complicated (complex?) expressions.
+ 
+ Wed Sep  3 12:26:33 1997  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* alias.c (true_dependence): Address with AND can alias scalars.
+ 	(anti_dependence, output_dependence): Likewise.
+ 	
+ Wed Sep  3 10:36:51 1997  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* alias.c (true_dependence): Test x for BLKmode, in addition to mem.
+ 
+ Sat Aug 30 16:42:50 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* reload.c (find_reloads): Fix 1997-07-28 fix so the
+ 	loop to handle MATCH_DUPs is disabled when insn_code_number
+ 	is <= 0, because in that case recog_dup_loc is not
+ 	relevant.
+ 
+ Tue Aug 26 01:52:17 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	From Stan Cox <coxs@dg-rtp.dg.com>
+ 	* reg-stack.c (subst_stack_regs): Cope with computed goto
+ 	(`GOTO I' in FORTRAN; `goto *lab;' in GNU C).
+ 
  Thu Aug 22 23:47:38 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
  
  	* Version 2.7.2.3 released.
  
+ Fri Aug 22 21:31:54 1997  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* alias.c (true_dependence): Pass x_addr not x to varies.
+ 
+ Sun Aug 17 03:31:44 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* Makefile.in: Comment out lines containing just formfeeds.
+ 
  Wed Aug 13 08:28:18 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
  
*************** Wed Aug 13 08:28:18 1997  H.J. Lu  (hjl@
*** 26,33 ****
  	(FINALIZE_TRAMPOLINE, CLEAR_INSN_CACHE): New.
  
! Mon Mar 17 17:03:55 1997  J.T. Conklin  <jtc@cygnus.com>
  
! 	* m68k.md (beq0_di, bne0_di, bge0_di, blt0_di): Use cmpw #0
!  	instead of tstl when testing address registers on the 68000.
  
  Fri Aug  8 08:15:55 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
--- 131,156 ----
  	(FINALIZE_TRAMPOLINE, CLEAR_INSN_CACHE): New.
  
! Sun Aug 10 22:23:10 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
  
! 	* explow.c (probe_stack_range): Add USE for test_addr if -O0.
! 
! Sun Aug 10 18:14:24 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	Integrate C front end part of patch for better alias
! 	handling from John Carr <jfc@mit.edu>:
! 	* c-decl.c (grokdeclarator): Check for RID_RESTRICT
! 	flag; diagnose certain misuses; set DECL_RESTRICT as
! 	appropriate.
! 	* c-lex.c (init_lex): Set up RID_RESTRICT pointer.
! 	Unset `restrict' as reserved word.
! 	* c-lex.h: Replace RID_NOALIAS with RID_RESTRICT.
! 	* c-parse.gperf: Add `restrict' and `__restrict'
! 	keywords.
! 	* tree.h: Add DECL_RESTRICT flag.
! 
! Sun Aug 10 14:50:30 1997  Jim Wilson  <wilson@cygnus.com>
! 
! 	* sdbout.c (plain_type_1, case ARRAY_TYPE): Verify that TYPE_DOMAIN
! 	has integer TYPE_{MAX,MIN}_VALUE before using them.
  
  Fri Aug  8 08:15:55 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
*************** Fri Aug  8 08:15:55 1997  H.J. Lu  (hjl@
*** 38,41 ****
--- 161,218 ----
  	* install1.texi: New.
  
+ Mon Aug  4 17:49:14 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* combine.c (try_combine): If have PARALLEL of independent SETs
+ 	and have cc0, ensure insn using CC0 come first.
+ 
+ Sat Aug  2 08:03:04 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* varasm.c (compare_constant_1, case STRING_CST): Compare TYPE_MODE.
+ 	(record_constant_1, case STRING_CST): Record TYPE_MODE.
+ 
+ Sat Aug  2 08:03:04 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* tree.c (contains_this_placeholder_p): Delete.
+ 	(contains_placeholder_p): Now contains code from above function.
+ 	(contains_placeholder_p, case 'r'): Don't look at offset info.
+ 	* expr.c (expand_expr, case PLACEHOLDER_EXPR): Find innermost
+ 	matching and don't check contains_placeholder_p.
+ 
+ Mon Jul 28 15:35:38 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* combine.c (num_sign_bit_copies): Speed up the 961126-1.c
+ 	case of repeated (neg (neg (neg ...))) so c-torture runs
+ 	in less time.
+ 
+ 	* reload.c (find_reloads_toplev, find_reloads_address):
+ 	These now return whether replacement by a constant, so
+ 	caller can know to do other replacements.  Currently if
+ 	caller doesn't want that info and such replacement would
+ 	happen, we crash so as to investigate the problem and
+ 	learn more about it.  All callers updated.
+ 	(find_reloads): If pseudo replaced by constant, always
+ 	update duplicates of it.
+ 
+ Sun Jul 27 12:13:01 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* expr.c (expand_expr, case SAVE_EXPR): Handle top-level SAVE_EXPR by
+ 	moving into current function; abort if in odd context.
+ 	* fold-const.c (fold_truthop, fold): Avoid making SAVE_EXPR
+ 	if at top level.
+ 
+ 	* expr.c (get_inner_unaligned_p): Deleted.
+ 	(expand_assignment): Remove special-case of constant array.
+ 	(expand_expr, case ARRAY_REF): Likewise, and clean up remaining code.
+ 
+ 	* explow.c (probe_stack_range): Do probing with loop if more
+ 	than a small number.
+ 
+ Fri Jul 25 08:38:37 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* calls.c: (expand_call): If -fstack-check and temp needed
+ 	for arg is too large, use alloca.
+ 	* expr.c (expand_expr, case MODIFY_EXPR): Don't preexpand calls
+ 	if LHS is an indirect via a constant pointer.
+ 
  Mon Jul 21 22:47:13 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
  
*************** Mon Jul 21 22:47:13 1997  H.J. Lu  (hjl@
*** 43,46 ****
--- 220,288 ----
  	for Linux.
  
+ Mon Jul 21 00:00:24 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* fold-const.c (size_binop): Make sure overflows
+ 	are flagged properly, so as to avoid silently generating
+ 	bad code for, e.g., a too-large array.
+ 
+ Sun Jul 20 06:10:26 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* tree.c (contains_placeholder_p): Call contains_this_placeholder_p.
+ 	(contains_this_placeholder_p): Renamed from contains_placeholder_p.
+ 	Added new arg, PL.
+ 	Rework to make more consistent, check more codes, and avoid
+ 	undefined fields.
+ 	* expr.c (expand_expr, case PLACEHOLDER_EXPR): Pick outermost
+ 	object in placeholder_list of right type without a PLACEHOLDER_EXPR>
+ 
+ Sat Jul 19 17:54:28 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* alpha.h (STACK_CHECK_BUILTIN): New macro.
+ 
+ Thu Jul 17 07:02:10 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* expr.h (STACK_CHECK_*): Provide default values.
+ 	(probe_stack_range): New declaration.
+ 	* flags.h (flag_stack_check): Likewise.
+ 	* explow.c (allocate_dynamic_stack_space): Call probe_stack_range.
+ 	(emit_stack_probe, probe_stack_range): New functions.
+ 	* function.c (expand_function_end): If function is non-leaf and stack 
+ 	checking is requested, emit needed probes.
+ 	* reload1.c (reload): If checking stack, verify frame small enough.
+ 	* stmt.c (expand_decl): If stack checking, use alloca for large vars.
+ 	* toplev.c (flag_stack_check): New variable.
+ 	(f_options): Add "stack-check".
+ 
+ Sun Jul 13 22:23:14 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* stmt.c (expand_expr_stmt): Must generate code for
+ 	statements within an expression (gcc's `({ ... )}')
+ 	even if -fsyntax-only.
+ 
+ Sun Jul 13 15:14:48 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* m68k.md (tstdi, cmpdi): Disable.
+ 
+ Tue Jul  1 23:27:43 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+ 
+ 	* reorg.c (redundant_insn): If INSN or possible match has REG_UNUSED
+ 	note, don't have match.
+ 
+ Mon Jun 30 17:23:07 1997  Michael Meissner  <meissner@cygnus.com>
+ 
+ 	* gcc.c (process_command): If -save-temps and -pipe were specified
+ 	together, don't do -pipe.
+ 
+ Thu Jun 26 05:40:46 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* stor-layout.c (get_best_mode): Handle negative bitpos
+ 	correctly, so caller doesn't get into infinite recursion
+ 	trying to cope with a spurious VOIDmode.
+ 
+ Tue Jun 24 19:46:31 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* varasm.c (assemble_variable): If low part of size
+ 	doesn't fit in an int, variable is too large.
+ 
  Tue Jun 24 11:24:56 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
  
*************** Mon Jun 23 22:48:00 1997  Jim Wilson  <w
*** 69,92 ****
  	to biv_count for reduced givs.
  
! Tue Apr 16 16:59:49 1996  Richard Henderson  <rth@tamu.edu>
  
!  	* function.c (expand_function_end): Allow TRAMPOLINE_TEMPLATE
! 	to be omitted on systems for which it is not cost effective.
! 	* varasm.c (assemble_trampoline_template): No such function
! 	if no TRAMPOLINE_TEMPLATE.
! 	* m68k.h: Greatly simplify the run-time trampoline code:
! 	(TRAMPOLINE_TEMPLATE, TRANSFER_FROM_TRAMPOLINE): Delete define.
! 	(TRAMPOLINE_SIZE, INITIALIZE_TRAMPOLINE): Changed.
! 	(TRAMPOLINE_ALIGN): No point aligning to cache line.
! 	(FINISH_INIT_TRAMPOLINE): New define.
! 	* m68k/next.h: Instead of redefining INITIALIZE_TRAMPOLINE,
! 	make use of the new FINISH_INIT_TRAMPOLINE.
! 	* m68k/{m68k.h,next.h} (FINISH_INIT_TRAMPOLINE):
! 	Rename to FINALIZE_TRAMPOLINE.
  
! Mon Apr 15 08:49:20 1996  Tom May  (ftom@netcom.com)
  
! 	* cse.c (invalidate_skipped_set): Ignore CLOBBER after calling
! 	note_mem_written, not before.
  
  Tue Jan 29 02:47:13 1997  Richard Stallman  <rms@psilocin.gnu.ai.mit.edu>
--- 311,512 ----
  	to biv_count for reduced givs.
  
! Sat Jun 21 12:09:00 1997  Craig Burley  <burley@gnu.ai.mit.edu>
  
! 	* toplev.c (rest_of_compilation): Also temporarily set
! 	flag_unroll_all_loops to 0 during first of two calls
! 	to loop_optimize, and clean up code a bit to make it
! 	easier to read.
  
! 	* expr.c (safe_from_p_1, safe_from_p): Fix these to use
! 	TREE_SET_CODE instead of TREE_CODE.
  
! Thu Jun 19 19:30:47 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* config/alpha/alpha.c: Don't include <stamp.h> on
! 	GNU Linux machines.
! 
! 	* config/alpha/elf.c: New file for ELF systems.
! 
! 	* config/alpha/xm-alpha.h: Don't declare alloca()
! 	if it's already a macro (probably defined in stdlib.h).
! 
! 	* config/alpha/xm-linux.h (HAVE_STRERROR): #define
! 	this, according to what various people suggest.
! 
! 	* config.guess, configure: Make some (hopefully safe)
! 	changes, based mostly on gcc-2.8.0-in-development,
! 	in the hopes that these make some systems configure
! 	"out of the box" more easily, especially Alpha systems.
! 
! Mon Jun  9 04:26:53 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* expr.c (safe_from_p): Don't examine a given SAVE_EXPR
! 	node more than once, to avoid combinatorial explosion
! 	in complex expressions.  Fortran case that triggered
! 	this had a complicated *and* complex expression with
! 	293 unique nodes, resulting in 28 minutes of compile
! 	time mostly spent in a single top-level safe_from_p()
! 	call due to all the redundant SAVE_EXPR traversals.
! 	This change reduced the time to around 2 seconds.
! 	(safe_from_p_1): New helper function that does almost
! 	exactly what the old safe_from_p() did.
! 
! Fri May 30 11:40:10 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* rs6000.md (movdi): Emit a CLOBBER before the two movsi insns
! 	in constant case.
! 
! Thu May 29 15:42:59 1997  Stan Cox  <coxs@dg-rtp.dg.com>
! 
! 	* i386.h (ASM_OUTPUT_REG_{PUSH,POP}): add %% before register name.
! 
! Sun May 18 21:18:48 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* fold-const.c (fold): Clarify why TRUNC_DIV_EXPR
! 	and FLOOR_DIV_EXPR aren't rewritten to EXACT_DIV_EXPR,
! 	clean up related code.
! 
! Sat May 17 15:15:23 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* cse.c (cse_insn): Don't record a SRC that's a MEM and the same
! 	as a REG_EQUIV note if DEST is set more than once.
! 
! Sat May  3 13:53:00 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* config.sub: Change all `i[345]' to `i[3456]' to
! 	support Pentium Pro (this change was already made
! 	in configure for gcc-2.7.2.2).
! 
! 	From Toon Moene <toon@moene.indiv.nluug.nl>:
! 	* toplev.c (rest_of_compilation): Unroll loops
! 	only the final time through loop optimization.
! 
! Thu Apr 24 16:39:53 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* stmt.c (pushcase_range): Check for null range first.
! 
! Mon Apr 21 16:31:50 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* cse.c (fold_rtx, case PLUS): When seeing if negative of constant
! 	is around, make sure not dealing with largest negative.
! 
! Sun Apr 20 10:46:24 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* fold-const.c (operand_equal_p): Constants are not equal if there
! 	has been an overflow.
! 
! Sun Apr 20 10:45:35 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* final.c (profile_function): Only call ASM_OUTPUT_REG_{PUSH,POP}
! 	if defined.
! 
! Wed Apr 16 22:26:16 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* alias.c, cse.c, loop.c, rtl.c, rtl.h, sched.c:
! 	Make changes submitted by <jfc@mit.edu>.
! 
! Wed Apr 16 16:54:18 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* function.c (find_temp_slot_from_address): Compare slots using
! 	rtx_equal_p, not identity comparison.
! 	* expr.c (store_expr): Check if TEMP and TARGET are the
! 	same using rtx_equal_p.
! 
! Tue Apr 15 18:03:58 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* rs6000.c (rs6000_output_load_toc_table): New function.
! 	(output_prolog): Delete code from here and call new function.
! 	* rs6000.md (nonlocal_goto_receiver): New pattern.
! 
! 	* expr.c (expand_assignment, store_field): Use copy_rtx when
! 	need to copy rtx instead of change_address.
! 	(expand_expr, case CONSTRUCTOR, COMPONENT_REF): Likewise.
! 
! Sun Apr 13 19:32:53 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* fold-const.c (fold): If extra warnings enabled,
! 	warn about integer division by zero.
! 
! Sun Apr 13 08:15:31 1997  Bernd Schmidt  <crux@Pool.Informatik.RWTH-Aachen.DE>
! 
! 	* final.c (profile_function): Save the static chain register
! 	around the call to the profiler function.
! 
! Sat Apr 12 14:56:42 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* unroll.c (find_splittable_givs): Permit more cases
! 	of mult_val/add_val to agree by using rtx_equal_p
! 	to compare them instead of requiring them to be
! 	integers with the same value.  Also don't bother
! 	checking if ADDRESS_COST not defined (they will be
! 	equal in that case).
! 
! Fri Apr 11 03:30:04 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* unroll.c (find_splittable_givs): Must create a new
! 	register if the mult_val and add_val fields don't
! 	agree.
! 
! Fri Apr  4 23:00:55 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* fold-const.c (fold): Don't call multiple_of_p if
! 	arg1 is constant zero, to avoid crashing; simplify
! 	code accordingly.
! 
! Mon Mar 24 22:33:40 1997  Dave Love  <d.love@dl.ac.uk>
! 
! 	* config/i386/i386.h (STACK_BOUNDARY): Define as BIGGEST_ALIGNMENT
! 	so that -malign-double works for stack-allocated data.
! 
! Wed Mar 19 12:24:11 1997  Jim Wilson  <wilson@cygnus.com>
! 
! 	* combine.c (move_deaths): Handle partial REG_DEAD note for
! 	multi-reg hard register.
! 
! Mon Mar 17 17:03:55 1997  J.T. Conklin  <jtc@cygnus.com>
! 
! 	* m68k.md (beq0_di, bne0_di, bge0_di, blt0_di): Use cmpw #0
!  	instead of tstl when testing address registers on the 68000.
! 
! Sun Mar 16 19:53:13 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* expr.c (expand_expr, case PLACEHOLDER_EXPR): Refine which
! 	object is picked.
! 
! Mon Mar 10 16:01:44 1997  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
! 
! 	* emit-rtl.c (subreg_lowpart_p): Return 0 if SUBREG_REG is VOIDmode.
! 	* combine.c (simplify_rtx, case SUBREG): Fix direction of test when
! 	calling operand_subword; use inline code intead of subreg_lowpart_p.
! 
! Wed Feb 26 13:09:33 1997  Michael Meissner  <meissner@cygnus.com>
! 
! 	* reload.c (debug_reload): Fix format string to print
! 	reload_nocombine[r].
! 
! Sun Feb 23 15:26:53 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	* fold-const.c (multiple_of_p): Clean up and improve.
! 	(fold): Clean up invocation of multiple_of_p.
! 
! Sun Feb  9 14:03:53 1997  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
! 
! 	* function.c (assign_stack_temp): Clear MEM flags from reuse.
! 
! Sat Feb  8 04:53:27 1997  Craig Burley  <burley@gnu.ai.mit.edu>
! 
! 	From <jfc@jfc.tiac.net> Fri, 07 Feb 1997 22:02:21 -0500:
! 	* alias.c (init_alias_analysis): Reduce amount of time
! 	needed to simplify the reg_base_value array in the
! 	typical case (especially involving function inlining).
! 
! Fri Feb  7 07:56:12 1997  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
! 
! 	* function.c (instantiate_virtual_regs_1, case USE, CLOBBER):
! 	Fix error in last change.
! 
! Sat Feb  1 18:51:47 1997  Douglas B. Rupp  (rupp@gnat.com)
! 
! 	* gcc.c (process_command): Fix improper use of strncpy.
  
  Tue Jan 29 02:47:13 1997  Richard Stallman  <rms@psilocin.gnu.ai.mit.edu>
*************** Tue Jan 29 02:47:13 1997  Richard Stallm
*** 109,112 ****
--- 529,616 ----
  	[! LIBC_VERSION_1] (LIB_SPEC): New override definition.
  
+ Tue Jan 21 16:09:37 1997  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* function.c (mark_all_temps_used): Set KEEP as well.
+ 
+ Fri Jan 10 17:22:17 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	Minor improvements/fixes to better alias handling:
+ 	* Makefile.in (alias.o): Fix typo in rule (was RLT_H).
+ 	* cse.c, sched.c: Fix up some indenting.
+ 	* toplev.c: Add -fargument-alias flag, so Fortran users
+ 	can turn C-style aliasing on once g77 defaults to
+ 	-fargument-noalias-global.
+ 
+ 	Integrate patch for better alias handling from
+ 	John Carr <jfc@mit.edu>:
+ 	* Makefile.in (OBJS, alias.o): New module and rule.
+ 	* alias.c: New source module.
+ 	* calls.c (expand_call): Recognize alias status of calls
+ 	to malloc().
+ 	* combine.c (distribute_notes): New REG_NOALIAS note.
+ 	* rtl.h (REG_NOALIAS): Ditto.
+ 	Many other changes for new alias.c module.
+ 	* cse.c: Many changes, and much code moved into alias.c.
+ 	* flags.h (flag_alias_check, flag_argument_noalias):
+ 	New flags.
+ 	* toplev.c: New flags and related options.
+ 	* local-alloc.c (validate_equiv_mem_from_store):
+ 	Caller of true_dependence changed.
+ 	* loop.c (NUM_STORES): Increase to 50 from 20.
+ 	(prescan_loop): "const" functions don't alter unknown addresses.
+ 	(invariant_p): Caller of true_dependence changed.
+ 	(record_giv): Zero new unrolled and shared flags.
+ 	(emit_iv_add_mult): Record base value for register.
+ 	* sched.c: Many changes, mostly moving code to alias.c.
+ 	(sched_note_set): SCHED_SORT macro def form, but not function,
+ 	inexplicably changed.
+ 	* unroll.c: Record base values for registers, etc.
+ 
+ Fri Jan  3 04:01:00 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* loop.c (check_final_value): Handle insns with no luid's
+ 	appropriately, instead of crashing on INSN_LUID macro
+ 	invocations.
+ 
+ Mon Dec 23 00:49:19 1996  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* config/alpha/alpha.md: Fix pattern that matches if_then_else
+ 	involving DF target, DF comparison, SF source.
+ 
+ Fri Dec 20 15:42:52 1996  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* fold-const.c (multiple_of_p): New function.
+ 	(fold): Use new function to turn *_DIV_EXPR into EXACT_DIV_EXPR.
+ 
+ Tue Nov 26 14:50:54 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* expr.c (move_by_pieces): Abort only if length positive at end.
+ 
+ Tue Oct 22 18:32:20 1996  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* unroll.c (unroll_loop): Always reject loops with unbalanced blocks.
+ 
+ Tue Sep 24 19:37:00 1996  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* reload.c (push_secondary_reload): Do strip paradoxical SUBREG
+ 	even if reload_class is CLASS_CANNOT_CHANGE_SIZE.  Change reload_mode
+ 	to mode in SECONDARY_MEMORY_NEEDED and get_secondary_mem calls.
+ 
+ Mon Aug 12 07:48:54 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* expr.c (expand_builtin, case BUILT_IN_SETJMP): Add test
+ 	and call for nonlocal_goto_receiver pattern.
+ 	* stmt.c (expand_end_bindings): Likewise.
+ 
+ Mon Aug  5 16:53:36 1996  Doug Evans  <dje@fallis.cygnus.com>
+ 
+ 	* stor-layout.c (layout_record): Correct overflow test for 0 sized
+ 	fields.
+ 
+ Tue Jul 23 23:11:57 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* tree.h (struct tree_int_cst): Add field for TREE_CST_RTL.
+ 	* varasm.c (decode_addr_const, output_constant_def): Allow INTEGER_CST.
+ 
  Sat Jun 29 12:33:39 1996  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
  
*************** Tue Jun 11 20:18:03 1996  Per Bothner <b
*** 118,121 ****
--- 622,635 ----
  	* alpha.h (FIXPROTO_INIT):  Define new macro.
  
+ Thu Jun  6 18:24:39 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* fold-cont.c (fold): Don't do anything with evaluated SAVE_EXPR.
+ 
+ Sat May 18 20:17:27 1996  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* unroll.c (copy_loop_body): When update split DEST_ADDR giv,
+ 	check to make sure it was split.
+ 	(find_splittable_givs): Fix reversed test of verify_addresses result.
+ 
  Fri May 10 18:35:00 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
  
*************** Wed Apr 17 17:53:23 1996  Michael Meissn
*** 136,139 ****
--- 650,681 ----
  	bits.
  
+ Tue Apr 16 16:59:49 1996  Richard Henderson  <rth@tamu.edu>
+ 
+  	* function.c (expand_function_end): Allow TRAMPOLINE_TEMPLATE
+ 	to be omitted on systems for which it is not cost effective.
+ 	* varasm.c (assemble_trampoline_template): No such function
+ 	if no TRAMPOLINE_TEMPLATE.
+ 	* m68k.h: Greatly simplify the run-time trampoline code:
+ 	(TRAMPOLINE_TEMPLATE, TRANSFER_FROM_TRAMPOLINE): Delete define.
+ 	(TRAMPOLINE_SIZE, INITIALIZE_TRAMPOLINE): Changed.
+ 	(TRAMPOLINE_ALIGN): No point aligning to cache line.
+ 	(FINISH_INIT_TRAMPOLINE): New define.
+ 	* m68k/next.h: Instead of redefining INITIALIZE_TRAMPOLINE,
+ 	make use of the new FINISH_INIT_TRAMPOLINE.
+ 	* m68k/{m68k.h,next.h} (FINISH_INIT_TRAMPOLINE):
+ 	Rename to FINALIZE_TRAMPOLINE.
+ 
+ Mon Apr 15 08:49:20 1996  Tom May  (ftom@netcom.com)
+ 
+ 	* cse.c (invalidate_skipped_set): Ignore CLOBBER after calling
+ 	note_mem_written, not before.
+ 
+ Sat Apr 13 07:47:09 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* alpha.c (alpha_emit_set_const_1): Renamed from
+ 	alpha_emit_set_const and static.
+ 	Remove change of Nov 26; again use normal mechanism for SImode.
+ 	(alpha_emit_set_const): New function.
+ 
  Mon Apr  8 13:46:28 1996  Michael Meissner  <meissner@tiktok.cygnus.com>
  
*************** Mon Feb 19 07:35:07 1996  Torbjorn Granl
*** 176,179 ****
--- 718,726 ----
          * rs6000.md (not:SI with assign and compare): Fix typo.
  
+ Tue Feb 13 17:43:46 1996  Jim Wilson  <wilson@cygnus.com>
+ 
+ 	* integrate.c (save_constants_in_decl_trees): New function.
+ 	(save_for_inline_copying, save_for_inline_nocopy): Call it.
+ 
  Wed Jan 24 18:00:12 1996  Brendan Kehoe  <brendan@lisa.cygnus.com>
  
*************** Tue Jan 16 06:01:28 1996  Thomas Graiche
*** 191,198 ****
--- 738,770 ----
  	* i386/freebsd.h (ASM_WEAKEN_LABEL): Deleted; not supported.
  
+ Mon Jan 15 07:22:59 1996  Michel Delval  (mfd@ccv.fr)
+ 
+ 	* reload.c (find_equiv_reg): Apply single_set, not PATTERN, to WHERE.
+ 
  Sun Jan  7 17:11:11 1996  David Edelsohn  <edelsohn@mhpcc.edu>
  
  	* collect2.c (scan_libraries): Correct Import File ID interpretation.
  
+ Sat Jan  6 03:27:49 1996  Hans-Peter Nilsson  <Hans-Peter.Nilsson@axis.se>
+ 
+         * expr.c (emit_move_insn_1): Don't emit lobber when moving
+         by parts and source equals destination.
+ 
+ Sat Jan  6 03:27:49 1996  Hans-Peter Nilsson  <Hans-Peter.Nilsson@axis.se>
+ 
+         * optabs.c (expand_fix): Don't copy TARGET to TO if same.
+ 
+ Mon Jan  1 09:05:07 1996  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+         * local-alloc.c (reg_equiv_replacement): New variable.
+         (memref_referenced_p, case REG): Check for reg_equiv_replacement.
+         (update_equiv_regs): reg_equiv_replacement now file-scope.
+ 
+ Fri Dec 22 17:29:42 1995  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* reload.c (find_valid_class): New function.
+ 	(push_reload): Use it in cases where a SUBREG and its contents
+ 	both need to be reloaded.
+ 
  Thu Dec 28 22:24:53 1995  Michael Meissner  <meissner@tiktok.cygnus.com>
  
*************** Mon Dec 18 18:40:34 1995  Jim Wilson  <w
*** 209,212 ****
--- 781,789 ----
  	above.
  
+ Sun Dec 17 06:37:00 1995  Richard Kenner  (kenner@vlsi1.ultra.nyu.edu)
+ 
+ 	* reload.c (push_secondary_reload): Don't strip paradoxical SUBREG
+ 	if reload_class is CLASS_CANNOT_CHANGE_SIZE.
+ 
  Sat Dec 16 07:03:33 1995  Philippe De Muyter (phdm@info.ucl.ac.be)
  
*************** Sat Dec  9 18:05:03 1995  Jim Wilson  <w
*** 223,226 ****
--- 800,808 ----
  	* expr.c (expand_expr, case INDIRECT_REF): Correct typo in May 8
  	change.
+ 
+ Fri Dec  8 19:17:30 1995  Mike Meissner  <meissner@beauty.cygnus.com>
+ 
+ 	* rs6000/rs6000.c (input_operand): Allow any integer constant, not
+ 	just integers that fit in 1 instruction.
  
  Sun Nov 26 14:47:42 1995  Richard Kenner  <kenner@mole.gnu.ai.mit.edu>
diff -rcp2N gcc-2.7.2.3/Makefile.in gcc-2.7.2.3.f.2/Makefile.in
*** gcc-2.7.2.3/Makefile.in	Fri Aug  8 15:58:17 1997
--- gcc-2.7.2.3.f.2/Makefile.in	Tue Sep  9 07:01:12 1997
*************** all: all.indirect
*** 397,401 ****
  ####cross overrides
  ####build overrides
! 
  # Now figure out from those variables how to compile and link.
  
--- 397,401 ----
  ####cross overrides
  ####build overrides
! #
  # Now figure out from those variables how to compile and link.
  
*************** INCLUDES = -I. -I$(srcdir) -I$(srcdir)/c
*** 454,458 ****
  # defined in this file into the environment.
  .NOEXPORT:
! 
  # Support for additional languages (other than c and objc).
  # ??? objc can be supported this way too (leave for later).
--- 454,458 ----
  # defined in this file into the environment.
  .NOEXPORT:
! #
  # Support for additional languages (other than c and objc).
  # ??? objc can be supported this way too (leave for later).
*************** FLAGS_TO_PASS = \
*** 491,495 ****
  	"bindir=$(bindir)" \
  	"libsubdir=$(libsubdir)"
! 
  # Lists of files for various purposes.
  
--- 491,495 ----
  	"bindir=$(bindir)" \
  	"libsubdir=$(libsubdir)"
! #
  # Lists of files for various purposes.
  
*************** OBJS = toplev.o version.o tree.o print-t
*** 519,523 ****
   integrate.o jump.o cse.o loop.o unroll.o flow.o stupid.o combine.o \
   regclass.o local-alloc.o global.o reload.o reload1.o caller-save.o \
!  insn-peep.o reorg.o sched.o final.o recog.o reg-stack.o \
   insn-opinit.o insn-recog.o insn-extract.o insn-output.o insn-emit.o \
   insn-attrtab.o $(out_object_file) getpwd.o convert.o $(EXTRA_OBJS)
--- 519,523 ----
   integrate.o jump.o cse.o loop.o unroll.o flow.o stupid.o combine.o \
   regclass.o local-alloc.o global.o reload.o reload1.o caller-save.o \
!  insn-peep.o reorg.o alias.o sched.o final.o recog.o reg-stack.o \
   insn-opinit.o insn-recog.o insn-extract.o insn-output.o insn-emit.o \
   insn-attrtab.o $(out_object_file) getpwd.o convert.o $(EXTRA_OBJS)
*************** LIB2FUNCS = _muldi3 _divdi3 _moddi3 _udi
*** 570,574 ****
      _fixxfdi _fixunsxfdi _floatdixf _fixunsxfsi \
      _fixtfdi _fixunstfdi _floatditf \
!     __gcc_bcmp _varargs _eprintf _op_new _op_vnew _new_handler _op_delete \
      _op_vdel _bb _shtab _clear_cache _trampoline __main _exit _ctors _eh \
      _pure
--- 570,575 ----
      _fixxfdi _fixunsxfdi _floatdixf _fixunsxfsi \
      _fixtfdi _fixunstfdi _floatditf \
!     __gcc_bcmp _varargs __dummy _eprintf \
!     _op_new _op_vnew _new_handler _op_delete \
      _op_vdel _bb _shtab _clear_cache _trampoline __main _exit _ctors _eh \
      _pure
*************** RTL_H = rtl.h rtl.def machmode.h machmod
*** 585,589 ****
  TREE_H = tree.h real.h tree.def machmode.h machmode.def
  BYTECODE_H = bytecode.h bc-emit.h bc-optab.h
! 
  # Language makefile fragments.
  
--- 586,590 ----
  TREE_H = tree.h real.h tree.def machmode.h machmode.def
  BYTECODE_H = bytecode.h bc-emit.h bc-optab.h
! #
  # Language makefile fragments.
  
*************** BYTECODE_H = bytecode.h bc-emit.h bc-opt
*** 607,611 ****
  
  # End of language makefile fragments.
! 
  # Avoid a lot of time thinking about remaking Makefile.in and *.def.
  .SUFFIXES: .in .def
--- 608,612 ----
  
  # End of language makefile fragments.
! #
  # Avoid a lot of time thinking about remaking Makefile.in and *.def.
  .SUFFIXES: .in .def
*************** xlimits.h: glimits.h limitx.h limity.h
*** 730,734 ****
  	fi
  	mv tmp-xlimits.h xlimits.h
! 
  # Build libgcc.a.
  # This is done in two parts because some functions, in libgcc1.c,
--- 731,735 ----
  	fi
  	mv tmp-xlimits.h xlimits.h
! #
  # Build libgcc.a.
  # This is done in two parts because some functions, in libgcc1.c,
*************** stamp-crtS:	stamp-crt crtstuff.c $(GCC_P
*** 1042,1046 ****
  	mv crtstuff$(objext) crtendS$(objext)
  	touch stamp-crtS
! 
  # Compiling object files from source files.
  
--- 1043,1047 ----
  	mv crtstuff$(objext) crtendS$(objext)
  	touch stamp-crtS
! #
  # Compiling object files from source files.
  
*************** expr.o : expr.c $(CONFIG_H) $(RTL_H) $(T
*** 1179,1183 ****
     insn-flags.h insn-codes.h expr.h insn-config.h recog.h output.h \
     typeclass.h bytecode.h bc-opcode.h bc-typecd.h bc-typecd.def bc-optab.h \
!    bc-emit.h modemap.def
  calls.o : calls.c $(CONFIG_H) $(RTL_H) $(TREE_H) flags.h expr.h insn-codes.h \
     insn-flags.h
--- 1180,1184 ----
     insn-flags.h insn-codes.h expr.h insn-config.h recog.h output.h \
     typeclass.h bytecode.h bc-opcode.h bc-typecd.h bc-typecd.def bc-optab.h \
!    bc-emit.h modemap.def hard-reg-set.h
  calls.o : calls.c $(CONFIG_H) $(RTL_H) $(TREE_H) flags.h expr.h insn-codes.h \
     insn-flags.h
*************** reorg.o : reorg.c $(CONFIG_H) $(RTL_H) c
*** 1238,1241 ****
--- 1239,1243 ----
     basic-block.h regs.h insn-config.h insn-attr.h insn-flags.h recog.h \
     flags.h output.h
+ alias.o : $(CONFIG_H) $(RTL_H) flags.h hard-reg-set.h regs.h
  sched.o : sched.c $(CONFIG_H) $(RTL_H) basic-block.h regs.h hard-reg-set.h \
     flags.h insn-config.h insn-attr.h
*************** alloca.o:	alloca.c
*** 1275,1279 ****
  	  -c `echo $(srcdir)/alloca.c | sed 's,^\./,,'`
  	$(ALLOCA_FINISH)
! 
  # Generate header and source files from the machine description, 
  # and compile them.
--- 1277,1281 ----
  	  -c `echo $(srcdir)/alloca.c | sed 's,^\./,,'`
  	$(ALLOCA_FINISH)
! #
  # Generate header and source files from the machine description, 
  # and compile them.
*************** stamp-output : $(md_file) genoutput $(sr
*** 1400,1404 ****
  	$(srcdir)/move-if-change tmp-output.c insn-output.c
  	touch stamp-output
! 
  # Compile the programs that generate insn-* from the machine description.
  # They are compiled with $(HOST_CC), and associated libraries,
--- 1402,1406 ----
  	$(srcdir)/move-if-change tmp-output.c insn-output.c
  	touch stamp-output
! #
  # Compile the programs that generate insn-* from the machine description.
  # They are compiled with $(HOST_CC), and associated libraries,
*************** genoutput : genoutput.o $(HOST_RTL) $(HO
*** 1493,1497 ****
  genoutput.o : genoutput.c $(RTL_H) $(build_xm_file)
  	$(HOST_CC) -c $(HOST_CFLAGS) $(HOST_CPPFLAGS) $(INCLUDES) $(srcdir)/genoutput.c
! 
  # Compile the libraries to be used by gen*.
  # If we are not cross-building, gen* use the same .o's that cc1 will use,
--- 1495,1499 ----
  genoutput.o : genoutput.c $(RTL_H) $(build_xm_file)
  	$(HOST_CC) -c $(HOST_CFLAGS) $(HOST_CPPFLAGS) $(INCLUDES) $(srcdir)/genoutput.c
! #
  # Compile the libraries to be used by gen*.
  # If we are not cross-building, gen* use the same .o's that cc1 will use,
*************** $(HOST_PREFIX_1)malloc.o: malloc.c
*** 1532,1536 ****
  $(HOST_PREFIX_1): 
  	touch $(HOST_PREFIX_1)
! 
  # Remake bytecode files.
  BI_OBJ=bi-parser.o bi-lexer.o bi-reverse.o
--- 1534,1538 ----
  $(HOST_PREFIX_1): 
  	touch $(HOST_PREFIX_1)
! #
  # Remake bytecode files.
  BI_OBJ=bi-parser.o bi-lexer.o bi-reverse.o
*************** bytecode.maintainer-clean: bytecode.clea
*** 1601,1605 ****
  	-rm -f bi-parser.c bi-parser.h
  
! 
  # Remake cpp and protoize.
  
--- 1603,1607 ----
  	-rm -f bi-parser.c bi-parser.h
  
! #
  # Remake cpp and protoize.
  
*************** test-protoize-simple: ./protoize ./unpro
*** 1724,1728 ****
  	diff $(srcdir)/protoize.c tmp-proto.c | cat
  	-rm -f tmp-proto.[cs] tmp-proto$(objext)
! 
  # Build the include directory.  The stamp files are stmp-* rather than
  # stamp-* so that mostlyclean does not force the include directory to
--- 1726,1730 ----
  	diff $(srcdir)/protoize.c tmp-proto.c | cat
  	-rm -f tmp-proto.[cs] tmp-proto$(objext)
! #
  # Build the include directory.  The stamp files are stmp-* rather than
  # stamp-* so that mostlyclean does not force the include directory to
*************** stmp-fixproto: fixhdr.ready fixproto stm
*** 1862,1866 ****
  	fi
  	touch stmp-fixproto
! 
  # Remake the info files.
  
--- 1864,1868 ----
  	fi
  	touch stmp-fixproto
! #
  # Remake the info files.
  
*************** $(srcdir)/INSTALL: install1.texi install
*** 1889,1893 ****
  	cd $(srcdir); $(MAKEINFO) -D INSTALLONLY --no-header \
  		--no-split install1.texi -o INSTALL
! 
  # Deletion of files made during compilation.
  # There are four levels of this:
--- 1891,1895 ----
  	cd $(srcdir); $(MAKEINFO) -D INSTALLONLY --no-header \
  		--no-split install1.texi -o INSTALL
! #
  # Deletion of files made during compilation.
  # There are four levels of this:
*************** maintainer-clean: distclean bytecode.mai
*** 2010,2014 ****
  	-rm -f cpp.info* cpp.??s cpp.*aux
  	-rm -f gcc.info* gcc.??s gcc.*aux
! 
  # Entry points `install' and `uninstall'.
  # Also use `install-collect2' to install collect2 when the config files don't.
--- 2012,2016 ----
  	-rm -f cpp.info* cpp.??s cpp.*aux
  	-rm -f gcc.info* gcc.??s gcc.*aux
! #
  # Entry points `install' and `uninstall'.
  # Also use `install-collect2' to install collect2 when the config files don't.
*************** uninstall: lang.uninstall
*** 2256,2260 ****
  	-rm -rf $(mandir)/protoize$(manext)
  	-rm -rf $(mandir)/unprotoize$(manext)
! 
  # These exist for maintenance purposes.
  
--- 2258,2262 ----
  	-rm -rf $(mandir)/protoize$(manext)
  	-rm -rf $(mandir)/unprotoize$(manext)
! #
  # These exist for maintenance purposes.
  
diff -rcp2N gcc-2.7.2.3/alias.c gcc-2.7.2.3.f.2/alias.c
*** gcc-2.7.2.3/alias.c	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/alias.c	Thu Feb 26 21:15:44 1998
***************
*** 0 ****
--- 1,1022 ----
+ /* Alias analysis for GNU C, by John Carr (jfc@mit.edu).
+    Derived in part from sched.c  */
+ #include "config.h"
+ #include "rtl.h"
+ #include "expr.h"
+ #include "regs.h"
+ #include "hard-reg-set.h"
+ #include "flags.h"
+ 
+ static rtx canon_rtx			PROTO((rtx));
+ static int rtx_equal_for_memref_p	PROTO((rtx, rtx));
+ static rtx find_symbolic_term		PROTO((rtx));
+ static int memrefs_conflict_p		PROTO((int, rtx, int, rtx,
+ 					       HOST_WIDE_INT));
+ 
+ /* Set up all info needed to perform alias analysis on memory references.  */
+ 
+ #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
+ 
+ /* reg_base_value[N] gives an address to which register N is related.
+    If all sets after the first add or subtract to the current value
+    or otherwise modify it so it does not point to a different top level
+    object, reg_base_value[N] is equal to the address part of the source
+    of the first set.  The value will be a SYMBOL_REF, a LABEL_REF, or
+    (address (reg)) to indicate that the address is derived from an
+    argument or fixed register.  */
+ rtx *reg_base_value;
+ unsigned int reg_base_value_size;	/* size of reg_base_value array */
+ #define REG_BASE_VALUE(X) \
+ 	(REGNO (X) < reg_base_value_size ? reg_base_value[REGNO (X)] : 0)
+ 
+ /* Vector indexed by N giving the initial (unchanging) value known
+    for pseudo-register N.  */
+ rtx *reg_known_value;
+ 
+ /* Indicates number of valid entries in reg_known_value.  */
+ static int reg_known_value_size;
+ 
+ /* Vector recording for each reg_known_value whether it is due to a
+    REG_EQUIV note.  Future passes (viz., reload) may replace the
+    pseudo with the equivalent expression and so we account for the
+    dependences that would be introduced if that happens. */
+ /* ??? This is a problem only on the Convex.  The REG_EQUIV notes created in
+    assign_parms mention the arg pointer, and there are explicit insns in the
+    RTL that modify the arg pointer.  Thus we must ensure that such insns don't
+    get scheduled across each other because that would invalidate the REG_EQUIV
+    notes.  One could argue that the REG_EQUIV notes are wrong, but solving
+    the problem in the scheduler will likely give better code, so we do it
+    here.  */
+ char *reg_known_equiv_p;
+ 
+ /* Inside SRC, the source of a SET, find a base address.  */
+ 
+ /* When copying arguments into pseudo-registers, record the (ADDRESS)
+    expression for the argument directly so that even if the argument
+    register is changed later (e.g. for a function call) the original
+    value is noted.  */
+ static int copying_arguments;
+ 
+ static rtx
+ find_base_value (src)
+      register rtx src;
+ {
+   switch (GET_CODE (src))
+     {
+     case SYMBOL_REF:
+     case LABEL_REF:
+       return src;
+ 
+     case REG:
+       if (copying_arguments && REGNO (src) < FIRST_PSEUDO_REGISTER)
+ 	return reg_base_value[REGNO (src)];
+       return src;
+ 
+     case MEM:
+       /* Check for an argument passed in memory.  Only record in the
+ 	 copying-arguments block; it is too hard to track changes
+ 	 otherwise.  */
+       if (copying_arguments
+ 	  && (XEXP (src, 0) == arg_pointer_rtx
+ 	      || (GET_CODE (XEXP (src, 0)) == PLUS
+ 		  && XEXP (XEXP (src, 0), 0) == arg_pointer_rtx)))
+ 	return gen_rtx (ADDRESS, VOIDmode, src);
+       return 0;
+ 
+     case CONST:
+       src = XEXP (src, 0);
+       if (GET_CODE (src) != PLUS && GET_CODE (src) != MINUS)
+ 	break;
+       /* fall through */
+     case PLUS:
+     case MINUS:
+       /* Guess which operand to set the register equivalent to.  */
+       /* If the first operand is a symbol or the second operand is
+ 	 an integer, the first operand is the base address.  */
+       if (GET_CODE (XEXP (src, 0)) == SYMBOL_REF
+ 	  || GET_CODE (XEXP (src, 0)) == LABEL_REF
+ 	  || GET_CODE (XEXP (src, 1)) == CONST_INT)
+ 	return XEXP (src, 0);
+       /* If an operand is a register marked as a pointer, it is the base.  */
+       if (GET_CODE (XEXP (src, 0)) == REG
+ 	  && REGNO_POINTER_FLAG (REGNO (XEXP (src, 0))))
+ 	src = XEXP (src, 0);
+       else if (GET_CODE (XEXP (src, 1)) == REG
+ 	  && REGNO_POINTER_FLAG (REGNO (XEXP (src, 1))))
+ 	src = XEXP (src, 1);
+       else
+ 	return 0;
+       if (copying_arguments && REGNO (src) < FIRST_PSEUDO_REGISTER)
+ 	return reg_base_value[REGNO (src)];
+       return src;
+ 
+     case AND:
+       /* If the second operand is constant set the base
+ 	 address to the first operand. */
+       if (GET_CODE (XEXP (src, 1)) == CONST_INT
+ 	  && GET_CODE (XEXP (src, 0)) == REG)
+ 	{
+ 	  src = XEXP (src, 0);
+ 	  if (copying_arguments && REGNO (src) < FIRST_PSEUDO_REGISTER)
+ 	    return reg_base_value[REGNO (src)];
+ 	  return src;
+ 	}
+       return 0;
+ 
+     case HIGH:
+       return XEXP (src, 0);
+     }
+ 
+   return 0;
+ }
+ 
+ /* Called from init_alias_analysis indirectly through note_stores.  */
+ 
+ /* while scanning insns to find base values, reg_seen[N] is nonzero if
+    register N has been set in this function.  */
+ static char *reg_seen;
+ 
+ static
+ void record_set (dest, set)
+      rtx dest, set;
+ {
+   register int regno;
+   rtx src;
+ 
+   if (GET_CODE (dest) != REG)
+     return;
+ 
+   regno = REGNO (dest);
+ 
+   if (set)
+     {
+       /* A CLOBBER wipes out any old value but does not prevent a previously
+ 	 unset register from acquiring a base address (i.e. reg_seen is not
+ 	 set).  */
+       if (GET_CODE (set) == CLOBBER)
+ 	{
+ 	  reg_base_value[regno] = 0;
+ 	  return;
+ 	}
+       src = SET_SRC (set);
+     }
+   else
+     {
+       static int unique_id;
+       if (reg_seen[regno])
+ 	{
+ 	  reg_base_value[regno] = 0;
+ 	  return;
+ 	}
+       reg_seen[regno] = 1;
+       reg_base_value[regno] = gen_rtx (ADDRESS, Pmode,
+ 				       GEN_INT (unique_id++));
+       return;
+     }
+ 
+   /* This is not the first set.  If the new value is not related to the
+      old value, forget the base value. Note that the following code is
+      not detected:
+      extern int x, y;  int *p = &x; p += (&y-&x);
+      ANSI C does not allow computing the difference of addresses
+      of distinct top level objects.  */
+   if (reg_base_value[regno])
+     switch (GET_CODE (src))
+       {
+       case PLUS:
+       case MINUS:
+ 	if (XEXP (src, 0) != dest && XEXP (src, 1) != dest)
+ 	  reg_base_value[regno] = 0;
+ 	break;
+       case AND:
+ 	if (XEXP (src, 0) != dest || GET_CODE (XEXP (src, 1)) != CONST_INT)
+ 	  reg_base_value[regno] = 0;
+ 	break;
+       case LO_SUM:
+ 	if (XEXP (src, 0) != dest)
+ 	  reg_base_value[regno] = 0;
+ 	break;
+       default:
+ 	reg_base_value[regno] = 0;
+ 	break;
+       }
+   /* If this is the first set of a register, record the value.  */
+   else if ((regno >= FIRST_PSEUDO_REGISTER || ! fixed_regs[regno])
+ 	   && ! reg_seen[regno] && reg_base_value[regno] == 0)
+     reg_base_value[regno] = find_base_value (src);
+ 
+   reg_seen[regno] = 1;
+ }
+ 
+ /* Called from loop optimization when a new pseudo-register is created.  */
+ void
+ record_base_value (regno, val)
+      int regno;
+      rtx val;
+ {
+   if (!flag_alias_check || regno >= reg_base_value_size)
+     return;
+   if (GET_CODE (val) == REG)
+     {
+       if (REGNO (val) < reg_base_value_size)
+ 	reg_base_value[regno] = reg_base_value[REGNO (val)];
+       return;
+     }
+   reg_base_value[regno] = find_base_value (val);
+ }
+ 
+ static rtx
+ canon_rtx (x)
+      rtx x;
+ {
+   /* Recursively look for equivalences.  */
+   if (GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER
+       && REGNO (x) < reg_known_value_size)
+     return reg_known_value[REGNO (x)] == x
+       ? x : canon_rtx (reg_known_value[REGNO (x)]);
+   else if (GET_CODE (x) == PLUS)
+     {
+       rtx x0 = canon_rtx (XEXP (x, 0));
+       rtx x1 = canon_rtx (XEXP (x, 1));
+ 
+       if (x0 != XEXP (x, 0) || x1 != XEXP (x, 1))
+ 	{
+ 	  /* We can tolerate LO_SUMs being offset here; these
+ 	     rtl are used for nothing other than comparisons.  */
+ 	  if (GET_CODE (x0) == CONST_INT)
+ 	    return plus_constant_for_output (x1, INTVAL (x0));
+ 	  else if (GET_CODE (x1) == CONST_INT)
+ 	    return plus_constant_for_output (x0, INTVAL (x1));
+ 	  return gen_rtx (PLUS, GET_MODE (x), x0, x1);
+ 	}
+     }
+   /* This gives us much better alias analysis when called from
+      the loop optimizer.   Note we want to leave the original
+      MEM alone, but need to return the canonicalized MEM with
+      all the flags with their original values.  */
+   else if (GET_CODE (x) == MEM)
+     {
+       rtx addr = canon_rtx (XEXP (x, 0));
+       if (addr != XEXP (x, 0))
+ 	{
+ 	  rtx new = gen_rtx (MEM, GET_MODE (x), addr);
+ 	  MEM_VOLATILE_P (new) = MEM_VOLATILE_P (x);
+ 	  RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x);
+ 	  MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (x);
+ 	  x = new;
+ 	}
+     }
+   return x;
+ }
+ 
+ /* Return 1 if X and Y are identical-looking rtx's.
+ 
+    We use the data in reg_known_value above to see if two registers with
+    different numbers are, in fact, equivalent.  */
+ 
+ static int
+ rtx_equal_for_memref_p (x, y)
+      rtx x, y;
+ {
+   register int i;
+   register int j;
+   register enum rtx_code code;
+   register char *fmt;
+ 
+   if (x == 0 && y == 0)
+     return 1;
+   if (x == 0 || y == 0)
+     return 0;
+   x = canon_rtx (x);
+   y = canon_rtx (y);
+ 
+   if (x == y)
+     return 1;
+ 
+   code = GET_CODE (x);
+   /* Rtx's of different codes cannot be equal.  */
+   if (code != GET_CODE (y))
+     return 0;
+ 
+   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
+      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
+ 
+   if (GET_MODE (x) != GET_MODE (y))
+     return 0;
+ 
+   /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively.  */
+ 
+   if (code == REG)
+     return REGNO (x) == REGNO (y);
+   if (code == LABEL_REF)
+     return XEXP (x, 0) == XEXP (y, 0);
+   if (code == SYMBOL_REF)
+     return XSTR (x, 0) == XSTR (y, 0);
+ 
+   /* For commutative operations, the RTX match if the operand match in any
+      order.  Also handle the simple binary and unary cases without a loop.  */
+   if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
+     return ((rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
+ 	     && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)))
+ 	    || (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 1))
+ 		&& rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 0))));
+   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
+     return (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
+ 	    && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)));
+   else if (GET_RTX_CLASS (code) == '1')
+     return rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0));
+ 
+   /* Compare the elements.  If any pair of corresponding elements
+      fail to match, return 0 for the whole things.  */
+ 
+   fmt = GET_RTX_FORMAT (code);
+   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+     {
+       switch (fmt[i])
+ 	{
+ 	case 'w':
+ 	  if (XWINT (x, i) != XWINT (y, i))
+ 	    return 0;
+ 	  break;
+ 
+ 	case 'n':
+ 	case 'i':
+ 	  if (XINT (x, i) != XINT (y, i))
+ 	    return 0;
+ 	  break;
+ 
+ 	case 'V':
+ 	case 'E':
+ 	  /* Two vectors must have the same length.  */
+ 	  if (XVECLEN (x, i) != XVECLEN (y, i))
+ 	    return 0;
+ 
+ 	  /* And the corresponding elements must match.  */
+ 	  for (j = 0; j < XVECLEN (x, i); j++)
+ 	    if (rtx_equal_for_memref_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
+ 	      return 0;
+ 	  break;
+ 
+ 	case 'e':
+ 	  if (rtx_equal_for_memref_p (XEXP (x, i), XEXP (y, i)) == 0)
+ 	    return 0;
+ 	  break;
+ 
+ 	case 'S':
+ 	case 's':
+ 	  if (strcmp (XSTR (x, i), XSTR (y, i)))
+ 	    return 0;
+ 	  break;
+ 
+ 	case 'u':
+ 	  /* These are just backpointers, so they don't matter.  */
+ 	  break;
+ 
+ 	case '0':
+ 	  break;
+ 
+ 	  /* It is believed that rtx's at this level will never
+ 	     contain anything but integers and other rtx's,
+ 	     except for within LABEL_REFs and SYMBOL_REFs.  */
+ 	default:
+ 	  abort ();
+ 	}
+     }
+   return 1;
+ }
+ 
+ /* Given an rtx X, find a SYMBOL_REF or LABEL_REF within
+    X and return it, or return 0 if none found.  */
+ 
+ static rtx
+ find_symbolic_term (x)
+      rtx x;
+ {
+   register int i;
+   register enum rtx_code code;
+   register char *fmt;
+ 
+   code = GET_CODE (x);
+   if (code == SYMBOL_REF || code == LABEL_REF)
+     return x;
+   if (GET_RTX_CLASS (code) == 'o')
+     return 0;
+ 
+   fmt = GET_RTX_FORMAT (code);
+   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+     {
+       rtx t;
+ 
+       if (fmt[i] == 'e')
+ 	{
+ 	  t = find_symbolic_term (XEXP (x, i));
+ 	  if (t != 0)
+ 	    return t;
+ 	}
+       else if (fmt[i] == 'E')
+ 	break;
+     }
+   return 0;
+ }
+ 
+ static rtx
+ find_base_term (x)
+      register rtx x;
+ {
+   switch (GET_CODE (x))
+     {
+     case REG:
+       return REG_BASE_VALUE (x);
+ 
+     case HIGH:
+       return find_base_term (XEXP (x, 0));
+ 
+     case CONST:
+       x = XEXP (x, 0);
+       if (GET_CODE (x) != PLUS && GET_CODE (x) != MINUS)
+ 	return 0;
+       /* fall through */
+     case LO_SUM:
+     case PLUS:
+     case MINUS:
+       {
+ 	rtx tmp = find_base_term (XEXP (x, 0));
+ 	if (tmp)
+ 	  return tmp;
+ 	return find_base_term (XEXP (x, 1));
+       }
+ 
+     case AND:
+       if (GET_CODE (XEXP (x, 0)) == REG && GET_CODE (XEXP (x, 1)) == CONST_INT)
+ 	return REG_BASE_VALUE (XEXP (x, 0));
+       return 0;
+ 
+     case SYMBOL_REF:
+     case LABEL_REF:
+       return x;
+ 
+     default:
+       return 0;
+     }
+ }
+ 
+ /* Return 0 if the addresses X and Y are known to point to different
+    objects, 1 if they might be pointers to the same object.  */
+ 
+ static int
+ base_alias_check (x, y)
+      rtx x, y;
+ {
+   rtx x_base = find_base_term (x);
+   rtx y_base = find_base_term (y);
+ 
+   /* If either base address is unknown or the base addresses are equal,
+      nothing is known about aliasing.  */
+ 
+   if (x_base == 0 || y_base == 0 || rtx_equal_p (x_base, y_base))
+     return 1;
+ 
+   /* The base addresses of the read and write are different
+      expressions.  If they are both symbols and they are not accessed
+      via AND, there is no conflict.  */
+   /* XXX: We can bring knowledge of object alignment and offset into 
+      play here.  For example, on alpha, "char a, b;" can alias one
+      another, though "char a; long b;" cannot.  Similarly, offsets
+      into strutures may be brought into play.  Given "char a, b[40];",
+      a and b[1] may overlap, but a and b[20] do not.  */
+   if (GET_CODE (x_base) != ADDRESS && GET_CODE (y_base) != ADDRESS)
+     {
+       return GET_CODE (x) == AND || GET_CODE (y) == AND;
+     }
+ 
+   /* If one address is a stack reference there can be no alias:
+      stack references using different base registers do not alias,
+      a stack reference can not alias a parameter, and a stack reference
+      can not alias a global.  */
+   if ((GET_CODE (x_base) == ADDRESS && GET_MODE (x_base) == Pmode)
+       || (GET_CODE (y_base) == ADDRESS && GET_MODE (y_base) == Pmode))
+     return 0;
+ 
+   if (! flag_argument_noalias)
+     return 1;
+ 
+   if (flag_argument_noalias > 1)
+     return 0;
+ 
+   /* Weak noalias assertion (arguments are distinct, but may match globals). */
+   return ! (GET_MODE (x_base) == VOIDmode && GET_MODE (y_base) == VOIDmode);
+ }
+ 
+ /* Return nonzero if X and Y (memory addresses) could reference the
+    same location in memory.  C is an offset accumulator.  When
+    C is nonzero, we are testing aliases between X and Y + C.
+    XSIZE is the size in bytes of the X reference,
+    similarly YSIZE is the size in bytes for Y.
+ 
+    If XSIZE or YSIZE is zero, we do not know the amount of memory being
+    referenced (the reference was BLKmode), so make the most pessimistic
+    assumptions.
+ 
+    If XSIZE or YSIZE is negative, we may access memory outside the object
+    being referenced as a side effect.  This can happen when using AND to
+    align memory references, as is done on the Alpha.
+ 
+    We recognize the following cases of non-conflicting memory:
+ 
+ 	(1) addresses involving the frame pointer cannot conflict
+ 	    with addresses involving static variables.
+ 	(2) static variables with different addresses cannot conflict.
+ 
+    Nice to notice that varying addresses cannot conflict with fp if no
+    local variables had their addresses taken, but that's too hard now.  */
+ 
+ 
+ static int
+ memrefs_conflict_p (xsize, x, ysize, y, c)
+      register rtx x, y;
+      int xsize, ysize;
+      HOST_WIDE_INT c;
+ {
+   if (GET_CODE (x) == HIGH)
+     x = XEXP (x, 0);
+   else if (GET_CODE (x) == LO_SUM)
+     x = XEXP (x, 1);
+   else
+     x = canon_rtx (x);
+   if (GET_CODE (y) == HIGH)
+     y = XEXP (y, 0);
+   else if (GET_CODE (y) == LO_SUM)
+     y = XEXP (y, 1);
+   else
+     y = canon_rtx (y);
+ 
+   if (rtx_equal_for_memref_p (x, y))
+     {
+       if (xsize <= 0 || ysize <= 0)
+ 	return 1;
+       if (c >= 0 && xsize > c)
+ 	return 1;
+       if (c < 0 && ysize+c > 0)
+ 	return 1;
+       return 0;
+     }
+ 
+   if (y == frame_pointer_rtx || y == hard_frame_pointer_rtx
+       || y == stack_pointer_rtx)
+     {
+       rtx t = y;
+       int tsize = ysize;
+       y = x; ysize = xsize;
+       x = t; xsize = tsize;
+     }
+ 
+   if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
+       || x == stack_pointer_rtx)
+     {
+       rtx y1;
+ 
+       if (CONSTANT_P (y))
+ 	return 0;
+ 
+       if (GET_CODE (y) == PLUS
+ 	  && canon_rtx (XEXP (y, 0)) == x
+ 	  && (y1 = canon_rtx (XEXP (y, 1)))
+ 	  && GET_CODE (y1) == CONST_INT)
+ 	{
+ 	  c += INTVAL (y1);
+ 	  return (xsize <= 0 || ysize <= 0
+ 		  || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
+ 	}
+ 
+       if (GET_CODE (y) == PLUS
+ 	  && (y1 = canon_rtx (XEXP (y, 0)))
+ 	  && CONSTANT_P (y1))
+ 	return 0;
+ 
+       return 1;
+     }
+ 
+   if (GET_CODE (x) == PLUS)
+     {
+       /* The fact that X is canonicalized means that this
+ 	 PLUS rtx is canonicalized.  */
+       rtx x0 = XEXP (x, 0);
+       rtx x1 = XEXP (x, 1);
+ 
+       if (GET_CODE (y) == PLUS)
+ 	{
+ 	  /* The fact that Y is canonicalized means that this
+ 	     PLUS rtx is canonicalized.  */
+ 	  rtx y0 = XEXP (y, 0);
+ 	  rtx y1 = XEXP (y, 1);
+ 
+ 	  if (rtx_equal_for_memref_p (x1, y1))
+ 	    return memrefs_conflict_p (xsize, x0, ysize, y0, c);
+ 	  if (rtx_equal_for_memref_p (x0, y0))
+ 	    return memrefs_conflict_p (xsize, x1, ysize, y1, c);
+ 	  if (GET_CODE (x1) == CONST_INT)
+ 	    if (GET_CODE (y1) == CONST_INT)
+ 	      return memrefs_conflict_p (xsize, x0, ysize, y0,
+ 					 c - INTVAL (x1) + INTVAL (y1));
+ 	    else
+ 	      return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
+ 	  else if (GET_CODE (y1) == CONST_INT)
+ 	    return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
+ 
+ 	  /* Handle case where we cannot understand iteration operators,
+ 	     but we notice that the base addresses are distinct objects.  */
+ 	  /* ??? Is this still necessary? */
+ 	  x = find_symbolic_term (x);
+ 	  if (x == 0)
+ 	    return 1;
+ 	  y = find_symbolic_term (y);
+ 	  if (y == 0)
+ 	    return 1;
+ 	  return rtx_equal_for_memref_p (x, y);
+ 	}
+       else if (GET_CODE (x1) == CONST_INT)
+ 	return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
+     }
+   else if (GET_CODE (y) == PLUS)
+     {
+       /* The fact that Y is canonicalized means that this
+ 	 PLUS rtx is canonicalized.  */
+       rtx y0 = XEXP (y, 0);
+       rtx y1 = XEXP (y, 1);
+ 
+       if (GET_CODE (y1) == CONST_INT)
+ 	return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
+       else
+ 	return 1;
+     }
+ 
+   if (GET_CODE (x) == GET_CODE (y))
+     switch (GET_CODE (x))
+       {
+       case MULT:
+ 	{
+ 	  /* Handle cases where we expect the second operands to be the
+ 	     same, and check only whether the first operand would conflict
+ 	     or not.  */
+ 	  rtx x0, y0;
+ 	  rtx x1 = canon_rtx (XEXP (x, 1));
+ 	  rtx y1 = canon_rtx (XEXP (y, 1));
+ 	  if (! rtx_equal_for_memref_p (x1, y1))
+ 	    return 1;
+ 	  x0 = canon_rtx (XEXP (x, 0));
+ 	  y0 = canon_rtx (XEXP (y, 0));
+ 	  if (rtx_equal_for_memref_p (x0, y0))
+ 	    return (xsize == 0 || ysize == 0
+ 		    || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
+ 
+ 	  /* Can't properly adjust our sizes.  */
+ 	  if (GET_CODE (x1) != CONST_INT)
+ 	    return 1;
+ 	  xsize /= INTVAL (x1);
+ 	  ysize /= INTVAL (x1);
+ 	  c /= INTVAL (x1);
+ 	  return memrefs_conflict_p (xsize, x0, ysize, y0, c);
+ 	}
+       }
+ 
+   /* Treat an access through an AND (e.g. a subword access on an Alpha)
+      as an access with indeterminate size.  */
+   if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT)
+     return memrefs_conflict_p (-1, XEXP (x, 0), ysize, y, c);
+   if (GET_CODE (y) == AND && GET_CODE (XEXP (y, 1)) == CONST_INT)
+     {
+       /* XXX: If we are indexing far enough into the array/structure, we
+ 	 may yet be able to determine that we can not overlap.  But we 
+ 	 also need to that we are far enough from the end not to overlap
+ 	 a following reference, so we do nothing for now.  */
+       return memrefs_conflict_p (xsize, x, -1, XEXP (y, 0), c);
+     }
+ 
+   if (CONSTANT_P (x))
+     {
+       if (GET_CODE (x) == CONST_INT && GET_CODE (y) == CONST_INT)
+ 	{
+ 	  c += (INTVAL (y) - INTVAL (x));
+ 	  return (xsize <= 0 || ysize <= 0
+ 		  || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
+ 	}
+ 
+       if (GET_CODE (x) == CONST)
+ 	{
+ 	  if (GET_CODE (y) == CONST)
+ 	    return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
+ 				       ysize, canon_rtx (XEXP (y, 0)), c);
+ 	  else
+ 	    return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
+ 				       ysize, y, c);
+ 	}
+       if (GET_CODE (y) == CONST)
+ 	return memrefs_conflict_p (xsize, x, ysize,
+ 				   canon_rtx (XEXP (y, 0)), c);
+ 
+       if (CONSTANT_P (y))
+ 	return (xsize < 0 || ysize < 0
+ 		|| (rtx_equal_for_memref_p (x, y)
+ 		    && (xsize == 0 || ysize == 0
+ 		        || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0))));
+ 
+       return 1;
+     }
+   return 1;
+ }
+ 
+ /* Functions to compute memory dependencies.
+ 
+    Since we process the insns in execution order, we can build tables
+    to keep track of what registers are fixed (and not aliased), what registers
+    are varying in known ways, and what registers are varying in unknown
+    ways.
+ 
+    If both memory references are volatile, then there must always be a
+    dependence between the two references, since their order can not be
+    changed.  A volatile and non-volatile reference can be interchanged
+    though. 
+ 
+    A MEM_IN_STRUCT reference at a non-QImode non-AND varying address can never
+    conflict with a non-MEM_IN_STRUCT reference at a fixed address.   We must
+    allow QImode aliasing because the ANSI C standard allows character
+    pointers to alias anything.  We are assuming that characters are
+    always QImode here.  We also must allow AND addresses, because they may
+    generate accesses outside the object being referenced.  This is used to
+    generate aligned addresses from unaligned addresses, for instance, the
+    alpha storeqi_unaligned pattern.  */
+ 
+ /* Read dependence: X is read after read in MEM takes place.  There can
+    only be a dependence here if both reads are volatile.  */
+ 
+ int
+ read_dependence (mem, x)
+      rtx mem;
+      rtx x;
+ {
+   return MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem);
+ }
+ 
+ /* True dependence: X is read after store in MEM takes place.  */
+ 
+ int
+ true_dependence (mem, mem_mode, x, varies)
+      rtx mem;
+      enum machine_mode mem_mode;
+      rtx x;
+      int (*varies)();
+ {
+   rtx x_addr, mem_addr;
+ 
+   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
+     return 1;
+ 
+   x_addr = XEXP (x, 0);
+   mem_addr = XEXP (mem, 0);
+ 
+   if (flag_alias_check && ! base_alias_check (x_addr, mem_addr))
+     return 0;
+ 
+   /* If X is an unchanging read, then it can't possibly conflict with any
+      non-unchanging store.  It may conflict with an unchanging write though,
+      because there may be a single store to this address to initialize it.
+      Just fall through to the code below to resolve the case where we have
+      both an unchanging read and an unchanging write.  This won't handle all
+      cases optimally, but the possible performance loss should be
+      negligible.  */
+   if (RTX_UNCHANGING_P (x) && ! RTX_UNCHANGING_P (mem))
+     return 0;
+ 
+   x_addr = canon_rtx (x_addr);
+   mem_addr = canon_rtx (mem_addr);
+   if (mem_mode == VOIDmode)
+     mem_mode = GET_MODE (mem);
+ 
+   if (! memrefs_conflict_p (mem_mode, mem_addr, SIZE_FOR_MODE (x), x_addr, 0))
+     return 0;
+ 
+   /* If both references are struct references, or both are not, nothing
+      is known about aliasing.
+ 
+      If either reference is QImode or BLKmode, ANSI C permits aliasing.
+ 
+      If both addresses are constant, or both are not, nothing is known
+      about aliasing.  */
+   if (MEM_IN_STRUCT_P (x) == MEM_IN_STRUCT_P (mem)
+       || mem_mode == QImode || mem_mode == BLKmode
+       || GET_MODE (x) == QImode || GET_MODE (x) == BLKmode
+       || GET_CODE (x_addr) == AND || GET_CODE (mem_addr) == AND
+       || varies (x_addr) == varies (mem_addr))
+     return 1;
+ 
+   /* One memory reference is to a constant address, one is not.
+      One is to a structure, the other is not.
+ 
+      If either memory reference is a variable structure the other is a
+      fixed scalar and there is no aliasing.  */
+   if ((MEM_IN_STRUCT_P (mem) && varies (mem_addr))
+       || (MEM_IN_STRUCT_P (x) && varies (x_addr)))
+     return 0;
+ 
+   return 1;
+ }
+ 
+ /* Anti dependence: X is written after read in MEM takes place.  */
+ 
+ int
+ anti_dependence (mem, x)
+      rtx mem;
+      rtx x;
+ {
+   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
+     return 1;
+ 
+   if (flag_alias_check && ! base_alias_check (XEXP (x, 0), XEXP (mem, 0)))
+     return 0;
+ 
+   /* If MEM is an unchanging read, then it can't possibly conflict with
+      the store to X, because there is at most one store to MEM, and it must
+      have occurred somewhere before MEM.  */
+   x = canon_rtx (x);
+   mem = canon_rtx (mem);
+   if (RTX_UNCHANGING_P (mem))
+     return 0;
+ 
+   return (memrefs_conflict_p (SIZE_FOR_MODE (mem), XEXP (mem, 0),
+ 			      SIZE_FOR_MODE (x), XEXP (x, 0), 0)
+ 	  && ! (MEM_IN_STRUCT_P (mem) && rtx_addr_varies_p (mem)
+ 		&& GET_MODE (mem) != QImode
+ 		&& GET_CODE (XEXP (mem, 0)) != AND
+ 		&& ! MEM_IN_STRUCT_P (x) && ! rtx_addr_varies_p (x))
+ 	  && ! (MEM_IN_STRUCT_P (x) && rtx_addr_varies_p (x)
+ 		&& GET_MODE (x) != QImode
+ 		&& GET_CODE (XEXP (x, 0)) != AND
+ 		&& ! MEM_IN_STRUCT_P (mem) && ! rtx_addr_varies_p (mem)));
+ }
+ 
+ /* Output dependence: X is written after store in MEM takes place.  */
+ 
+ int
+ output_dependence (mem, x)
+      register rtx mem;
+      register rtx x;
+ {
+   if (MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
+     return 1;
+ 
+   if (flag_alias_check && !base_alias_check (XEXP (x, 0), XEXP (mem, 0)))
+     return 0;
+ 
+   x = canon_rtx (x);
+   mem = canon_rtx (mem);
+   return (memrefs_conflict_p (SIZE_FOR_MODE (mem), XEXP (mem, 0),
+ 			      SIZE_FOR_MODE (x), XEXP (x, 0), 0)
+ 	  && ! (MEM_IN_STRUCT_P (mem) && rtx_addr_varies_p (mem)
+ 		&& GET_MODE (mem) != QImode
+ 		&& GET_CODE (XEXP (mem, 0)) != AND
+ 		&& ! MEM_IN_STRUCT_P (x) && ! rtx_addr_varies_p (x))
+ 	  && ! (MEM_IN_STRUCT_P (x) && rtx_addr_varies_p (x)
+ 		&& GET_MODE (x) != QImode
+ 		&& GET_CODE (XEXP (x, 0)) != AND
+ 		&& ! MEM_IN_STRUCT_P (mem) && ! rtx_addr_varies_p (mem)));
+ }
+ 
+ void
+ init_alias_analysis ()
+ {
+   int maxreg = max_reg_num ();
+   int changed;
+   register int i;
+   register rtx insn;
+   rtx note;
+   rtx set;
+ 
+   reg_known_value_size = maxreg;
+ 
+   reg_known_value
+     = (rtx *) oballoc ((maxreg - FIRST_PSEUDO_REGISTER) * sizeof (rtx))
+     - FIRST_PSEUDO_REGISTER;
+   reg_known_equiv_p =
+     oballoc (maxreg - FIRST_PSEUDO_REGISTER) - FIRST_PSEUDO_REGISTER;
+   bzero ((char *) (reg_known_value + FIRST_PSEUDO_REGISTER),
+ 	 (maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx));
+   bzero (reg_known_equiv_p + FIRST_PSEUDO_REGISTER,
+ 	 (maxreg - FIRST_PSEUDO_REGISTER) * sizeof (char));
+ 
+   if (flag_alias_check)
+     {
+       /* Overallocate reg_base_value to allow some growth during loop
+ 	 optimization.  Loop unrolling can create a large number of
+ 	 registers.  */
+       reg_base_value_size = maxreg * 2;
+       reg_base_value = (rtx *)oballoc (reg_base_value_size * sizeof (rtx));
+       reg_seen = (char *)alloca (reg_base_value_size);
+       bzero (reg_base_value, reg_base_value_size * sizeof (rtx));
+       bzero (reg_seen, reg_base_value_size);
+ 
+       /* Mark all hard registers which may contain an address.
+ 	 The stack, frame and argument pointers may contain an address.
+ 	 An argument register which can hold a Pmode value may contain
+ 	 an address even if it is not in BASE_REGS.
+ 
+ 	 The address expression is VOIDmode for an argument and
+ 	 Pmode for other registers.  */
+ #ifndef OUTGOING_REGNO
+ #define OUTGOING_REGNO(N) N
+ #endif
+       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ 	/* Check whether this register can hold an incoming pointer
+ 	   argument.  FUNCTION_ARG_REGNO_P tests outgoing register
+ 	   numbers, so translate if necessary due to register windows. */
+ 	if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i)) && HARD_REGNO_MODE_OK (i, Pmode))
+ 	  reg_base_value[i] = gen_rtx (ADDRESS, VOIDmode,
+ 				       gen_rtx (REG, Pmode, i));
+ 
+       reg_base_value[STACK_POINTER_REGNUM]
+ 	= gen_rtx (ADDRESS, Pmode, stack_pointer_rtx);
+       reg_base_value[ARG_POINTER_REGNUM]
+ 	= gen_rtx (ADDRESS, Pmode, arg_pointer_rtx);
+       reg_base_value[FRAME_POINTER_REGNUM]
+ 	= gen_rtx (ADDRESS, Pmode, frame_pointer_rtx);
+       reg_base_value[HARD_FRAME_POINTER_REGNUM]
+ 	= gen_rtx (ADDRESS, Pmode, hard_frame_pointer_rtx);
+     }
+ 
+   copying_arguments = 1;
+   /* Fill in the entries with known constant values.  */
+   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+     {
+       if (flag_alias_check && GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ 	{
+ 	  /* If this insn has a noalias note, process it,  Otherwise,
+ 	     scan for sets.  A simple set will have no side effects
+ 	     which could change the base value of any other register. */
+ 	  rtx noalias_note;
+ 	  if (GET_CODE (PATTERN (insn)) == SET
+ 	      && (noalias_note = find_reg_note (insn, REG_NOALIAS, NULL_RTX)))
+ 	      record_set (SET_DEST (PATTERN (insn)), 0);
+ 	  else
+ 	    note_stores (PATTERN (insn), record_set);
+ 	}
+       else if (GET_CODE (insn) == NOTE
+ 	       && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
+ 	copying_arguments = 0;
+ 
+       if ((set = single_set (insn)) != 0
+ 	  && GET_CODE (SET_DEST (set)) == REG
+ 	  && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
+ 	  && (((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
+ 	       && reg_n_sets[REGNO (SET_DEST (set))] == 1)
+ 	      || (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
+ 	  && GET_CODE (XEXP (note, 0)) != EXPR_LIST)
+ 	{
+ 	  int regno = REGNO (SET_DEST (set));
+ 	  reg_known_value[regno] = XEXP (note, 0);
+ 	  reg_known_equiv_p[regno] = REG_NOTE_KIND (note) == REG_EQUIV;
+ 	}
+     }
+ 
+   /* Fill in the remaining entries.  */
+   for (i = FIRST_PSEUDO_REGISTER; i < maxreg; i++)
+     if (reg_known_value[i] == 0)
+       reg_known_value[i] = regno_reg_rtx[i];
+ 
+   if (! flag_alias_check)
+     return;
+ 
+   /* Simplify the reg_base_value array so that no register refers to
+      another register, except to special registers indirectly through
+      ADDRESS expressions.
+ 
+      In theory this loop can take as long as O(registers^2), but unless
+      there are very long dependency chains it will run in close to linear
+      time.  */
+   do
+     {
+       changed = 0;
+       for (i = FIRST_PSEUDO_REGISTER; i < reg_base_value_size; i++)
+ 	{
+ 	  rtx base = reg_base_value[i];
+ 	  if (base && GET_CODE (base) == REG)
+ 	    {
+ 	      int base_regno = REGNO (base);
+ 	      if (base_regno == i)		/* register set from itself */
+ 		reg_base_value[i] = 0;
+ 	      else
+ 		reg_base_value[i] = reg_base_value[base_regno];
+ 	      changed = 1;
+ 	    }
+ 	}
+     }
+   while (changed);
+ 
+   reg_seen = 0;
+ }
+ 
+ void
+ end_alias_analysis ()
+ {
+   reg_known_value = 0;
+   reg_base_value = 0;
+   reg_base_value_size = 0;
+ }
diff -rcp2N gcc-2.7.2.3/basic-block.h gcc-2.7.2.3.f.2/basic-block.h
*** gcc-2.7.2.3/basic-block.h	Thu Jun 15 11:03:29 1995
--- gcc-2.7.2.3.f.2/basic-block.h	Sun Mar  1 03:28:56 1998
*************** extern rtx *basic_block_head;
*** 53,56 ****
--- 53,61 ----
  extern rtx *basic_block_end;
  
+ /* Index by basic block number, determine whether the block can be reached
+    through a computed jump.  */
+ 
+ extern char *basic_block_computed_jump_target;
+ 
  /* Index by basic block number, get address of regset
     describing the registers live at the start of that block.  */
diff -rcp2N gcc-2.7.2.3/c-decl.c gcc-2.7.2.3.f.2/c-decl.c
*** gcc-2.7.2.3/c-decl.c	Fri Oct 27 09:44:43 1995
--- gcc-2.7.2.3.f.2/c-decl.c	Tue Sep  9 07:01:13 1997
*************** init_decl_processing ()
*** 3207,3210 ****
--- 3207,3223 ----
    builtin_function ("__builtin_cosl", ldouble_ftype_ldouble, 
  		    BUILT_IN_COS, "cosl");
+   builtin_function ("__builtin_setjmp",
+ 		    build_function_type (integer_type_node,
+ 					 tree_cons (NULL_TREE,
+ 						    ptr_type_node, endlink)),
+ 		    BUILT_IN_SETJMP, NULL_PTR);
+   builtin_function ("__builtin_longjmp",
+ 		    build_function_type
+ 		    (void_type_node,
+ 		     tree_cons (NULL, ptr_type_node,
+ 				tree_cons (NULL_TREE,
+ 					   integer_type_node,
+ 					   endlink))),
+ 		    BUILT_IN_LONGJMP, NULL_PTR);
  
    /* In an ANSI C program, it is okay to supply built-in meanings
*************** grokdeclarator (declarator, declspecs, d
*** 4049,4052 ****
--- 4062,4066 ----
    int volatilep;
    int inlinep;
+   int restrictp;
    int explicit_int = 0;
    int explicit_char = 0;
*************** grokdeclarator (declarator, declspecs, d
*** 4342,4349 ****
--- 4356,4366 ----
    volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
    inlinep = !! (specbits & (1 << (int) RID_INLINE));
+   restrictp = !! (specbits & (1 << (int) RID_RESTRICT));
    if (constp > 1)
      pedwarn ("duplicate `const'");
    if (volatilep > 1)
      pedwarn ("duplicate `volatile'");
+   if (restrictp)
+     error ("`restrict' used in non-parameter or non-pointer type declaration");
    if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
      type = TYPE_MAIN_VARIANT (type);
*************** grokdeclarator (declarator, declspecs, d
*** 4693,4696 ****
--- 4710,4715 ----
  		  else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
  		    volatilep++;
+ 		  else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_RESTRICT])
+ 		    restrictp++;
  		  else if (!erred)
  		    {
*************** grokdeclarator (declarator, declspecs, d
*** 4703,4706 ****
--- 4722,4727 ----
  	      if (volatilep > 1)
  		pedwarn ("duplicate `volatile'");
+ 	      if (restrictp > 1)
+ 		pedwarn ("duplicate `restrict'");
  	    }
  
*************** grokdeclarator (declarator, declspecs, d
*** 4844,4847 ****
--- 4865,4875 ----
  	  }
  
+ 	if (restrictp)
+ 	  {
+ 	    if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE)
+ 	      error ("`restrict' applied to non-pointer");
+ 	    DECL_RESTRICT (decl) = 1;
+ 	  }
+ 
  	DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
        }
*************** start_struct (code, name)
*** 5365,5368 ****
--- 5393,5397 ----
    pushtag (name, ref);
    C_TYPE_BEING_DEFINED (ref) = 1;
+   TYPE_PACKED (ref) = flag_pack_struct;
    return ref;
  }
*************** start_enum (name)
*** 5806,5809 ****
--- 5835,5841 ----
    enum_overflow = 0;
  
+   if (flag_short_enums)
+     TYPE_PACKED (enumtype) = 1;
+ 
    return enumtype;
  }
*************** finish_enum (enumtype, values, attribute
*** 5862,5867 ****
    precision = MAX (lowprec, highprec);
  
!   if (flag_short_enums || TYPE_PACKED (enumtype)
!       || precision > TYPE_PRECISION (integer_type_node))
      /* Use the width of the narrowest normal C type which is wide enough.  */
      TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
--- 5894,5898 ----
    precision = MAX (lowprec, highprec);
  
!   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
      /* Use the width of the narrowest normal C type which is wide enough.  */
      TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
diff -rcp2N gcc-2.7.2.3/c-lex.c gcc-2.7.2.3.f.2/c-lex.c
*** gcc-2.7.2.3/c-lex.c	Thu Jun 15 11:11:39 1995
--- gcc-2.7.2.3.f.2/c-lex.c	Mon Sep 29 19:55:33 1997
*************** init_lex ()
*** 173,176 ****
--- 173,177 ----
    ridpointers[(int) RID_CONST] = get_identifier ("const");
    ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
+   ridpointers[(int) RID_RESTRICT] = get_identifier ("restrict");
    ridpointers[(int) RID_AUTO] = get_identifier ("auto");
    ridpointers[(int) RID_STATIC] = get_identifier ("static");
*************** init_lex ()
*** 206,209 ****
--- 207,211 ----
        UNSET_RESERVED_WORD ("iterator");
        UNSET_RESERVED_WORD ("complex");
+       UNSET_RESERVED_WORD ("restrict");
      }
    if (flag_no_asm)
*************** init_lex ()
*** 214,217 ****
--- 216,220 ----
        UNSET_RESERVED_WORD ("iterator");
        UNSET_RESERVED_WORD ("complex");
+       UNSET_RESERVED_WORD ("restrict");
      }
  }
*************** yylex ()
*** 1433,1437 ****
  	    /* Create a node with determined type and value.  */
  	    if (imag)
! 	      yylval.ttype = build_complex (convert (type, integer_zero_node),
  					    build_real (type, value));
  	    else
--- 1436,1441 ----
  	    /* Create a node with determined type and value.  */
  	    if (imag)
! 	      yylval.ttype = build_complex (NULL_TREE,
! 					    convert (type, integer_zero_node),
  					    build_real (type, value));
  	    else
*************** yylex ()
*** 1624,1629 ****
  		    <= TYPE_PRECISION (integer_type_node))
  		  yylval.ttype
! 		    = build_complex (integer_zero_node,
! 				     convert (integer_type_node, yylval.ttype));
  		else
  		  error ("complex integer constant is too wide for `complex int'");
--- 1628,1634 ----
  		    <= TYPE_PRECISION (integer_type_node))
  		  yylval.ttype
! 		    = build_complex (NULL_TREE, integer_zero_node,
! 				     convert (integer_type_node,
! 					      yylval.ttype));
  		else
  		  error ("complex integer constant is too wide for `complex int'");
diff -rcp2N gcc-2.7.2.3/c-lex.h gcc-2.7.2.3.f.2/c-lex.h
*** gcc-2.7.2.3/c-lex.h	Thu Jun 15 11:12:22 1995
--- gcc-2.7.2.3.f.2/c-lex.h	Tue Sep  9 07:01:13 1997
*************** enum rid
*** 43,47 ****
    RID_VOLATILE,
    RID_INLINE,
!   RID_NOALIAS,
    RID_ITERATOR,
    RID_COMPLEX,
--- 43,47 ----
    RID_VOLATILE,
    RID_INLINE,
!   RID_RESTRICT,
    RID_ITERATOR,
    RID_COMPLEX,
diff -rcp2N gcc-2.7.2.3/c-parse.gperf gcc-2.7.2.3.f.2/c-parse.gperf
*** gcc-2.7.2.3/c-parse.gperf	Fri Apr  9 23:00:44 1993
--- gcc-2.7.2.3.f.2/c-parse.gperf	Mon Sep 29 19:49:21 1997
*************** __label__, LABEL, NORID
*** 36,39 ****
--- 36,41 ----
  __real, REALPART, NORID
  __real__, REALPART, NORID
+ __restrict, TYPE_QUAL, RID_RESTRICT
+ __restrict__, TYPE_QUAL, RID_RESTRICT
  __signed, TYPESPEC, RID_SIGNED
  __signed__, TYPESPEC, RID_SIGNED
diff -rcp2N gcc-2.7.2.3/c-typeck.c gcc-2.7.2.3.f.2/c-typeck.c
*** gcc-2.7.2.3/c-typeck.c	Sat Jun 29 16:27:15 1996
--- gcc-2.7.2.3.f.2/c-typeck.c	Tue Sep  9 07:01:14 1997
*************** pointer_int_sum (resultcode, ptrop, into
*** 2681,2686 ****
       so the multiply won't overflow spuriously.  */
  
!   if (TYPE_PRECISION (TREE_TYPE (intop)) != POINTER_SIZE)
!     intop = convert (type_for_size (POINTER_SIZE, 0), intop);
  
    /* Replace the integer argument with a suitable product by the object size.
--- 2681,2688 ----
       so the multiply won't overflow spuriously.  */
  
!   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
!       || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
!     intop = convert (type_for_size (TYPE_PRECISION (sizetype), 
! 				    TREE_UNSIGNED (sizetype)), intop);
  
    /* Replace the integer argument with a suitable product by the object size.
diff -rcp2N gcc-2.7.2.3/calls.c gcc-2.7.2.3.f.2/calls.c
*** gcc-2.7.2.3/calls.c	Fri Oct 27 01:53:43 1995
--- gcc-2.7.2.3.f.2/calls.c	Tue Sep  9 07:01:14 1997
*************** expand_call (exp, target, ignore)
*** 564,567 ****
--- 564,569 ----
    /* Nonzero if it is plausible that this is a call to alloca.  */
    int may_be_alloca;
+   /* Nonzero if this is a call to malloc or a related function. */
+   int is_malloc;
    /* Nonzero if this is a call to setjmp or a related function.  */
    int returns_twice;
*************** expand_call (exp, target, ignore)
*** 741,745 ****
  	  if (stack_arg_under_construction || i >= 0)
  	    {
! 	      rtx insn = NEXT_INSN (before_call), seq;
  
  	      /* Look for a call in the inline function code.
--- 743,749 ----
  	  if (stack_arg_under_construction || i >= 0)
  	    {
! 	      rtx first_insn
! 		= before_call ? NEXT_INSN (before_call) : get_insns ();
! 	      rtx insn, seq;
  
  	      /* Look for a call in the inline function code.
*************** expand_call (exp, target, ignore)
*** 749,753 ****
  
  	      if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
! 		for (; insn; insn = NEXT_INSN (insn))
  		  if (GET_CODE (insn) == CALL_INSN)
  		    break;
--- 753,757 ----
  
  	      if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
! 		for (insn = first_insn; insn; insn = NEXT_INSN (insn))
  		  if (GET_CODE (insn) == CALL_INSN)
  		    break;
*************** expand_call (exp, target, ignore)
*** 781,785 ****
  		  seq = get_insns ();
  		  end_sequence ();
! 		  emit_insns_before (seq, NEXT_INSN (before_call));
  		  emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
  		}
--- 785,789 ----
  		  seq = get_insns ();
  		  end_sequence ();
! 		  emit_insns_before (seq, first_insn);
  		  emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
  		}
*************** expand_call (exp, target, ignore)
*** 852,855 ****
--- 856,860 ----
    returns_twice = 0;
    is_longjmp = 0;
+   is_malloc = 0;
  
    if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15)
*************** expand_call (exp, target, ignore)
*** 891,894 ****
--- 896,903 ----
  	       && ! strcmp (tname, "longjmp"))
  	is_longjmp = 1;
+       /* Only recognize malloc when alias analysis is enabled.  */
+       else if (tname[0] == 'm' && flag_alias_check
+ 	       && ! strcmp(tname, "malloc"))
+ 	is_malloc = 1;
      }
  
*************** expand_call (exp, target, ignore)
*** 1060,1064 ****
  
  	      if (TYPE_SIZE (type) == 0
! 		  || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
  		{
  		  /* This is a variable-sized object.  Make space on the stack
--- 1069,1077 ----
  
  	      if (TYPE_SIZE (type) == 0
! 		  || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
! 		  || (flag_stack_check && ! STACK_CHECK_BUILTIN
! 		      && (TREE_INT_CST_HIGH (TYPE_SIZE (type)) != 0
! 			  || (TREE_INT_CST_LOW (TYPE_SIZE (type))
! 			      > STACK_CHECK_MAX_VAR_SIZE * BITS_PER_UNIT))))
  		{
  		  /* This is a variable-sized object.  Make space on the stack
*************** expand_call (exp, target, ignore)
*** 1087,1090 ****
--- 1100,1104 ----
  
  	      store_expr (args[i].tree_value, copy, 0);
+ 	      is_const = 0;
  
  	      args[i].tree_value = build1 (ADDR_EXPR,
*************** expand_call (exp, target, ignore)
*** 1363,1367 ****
    /* Now we are about to start emitting insns that can be deleted
       if a libcall is deleted.  */
!   if (is_const)
      start_sequence ();
  
--- 1377,1381 ----
    /* Now we are about to start emitting insns that can be deleted
       if a libcall is deleted.  */
!   if (is_const || is_malloc)
      start_sequence ();
  
*************** expand_call (exp, target, ignore)
*** 1951,1954 ****
--- 1965,1982 ----
        end_sequence ();
        emit_insns (insns);
+     }
+   else if (is_malloc)
+     {
+       rtx temp = gen_reg_rtx (GET_MODE (valreg));
+       rtx last, insns;
+ 
+       emit_move_insn (temp, valreg);
+       last = get_last_insn ();
+       REG_NOTES (last) = 
+ 	gen_rtx (EXPR_LIST, REG_NOALIAS, temp, REG_NOTES (last));
+       insns = get_insns ();
+       end_sequence ();
+       emit_insns (insns);
+       valreg = temp;
      }
  
diff -rcp2N gcc-2.7.2.3/cccp.c gcc-2.7.2.3.f.2/cccp.c
*** gcc-2.7.2.3/cccp.c	Thu Oct 26 22:07:26 1995
--- gcc-2.7.2.3.f.2/cccp.c	Tue Sep  9 07:01:15 1997
*************** initialize_builtins (inp, outp)
*** 9626,9629 ****
--- 9626,9630 ----
      so that it is present only when truly compiling with GNU C.  */
  /*  install ((U_CHAR *) "__GNUC__", -1, T_CONST, "2", -1);  */
+   install ((U_CHAR *) "__HAVE_BUILTIN_SETJMP__", -1, T_CONST, "1", -1);
  
    if (debug_output)
diff -rcp2N gcc-2.7.2.3/combine.c gcc-2.7.2.3.f.2/combine.c
*** gcc-2.7.2.3/combine.c	Sun Nov 26 19:32:07 1995
--- gcc-2.7.2.3.f.2/combine.c	Tue Sep  9 07:01:17 1997
*************** try_combine (i3, i2, i1)
*** 2011,2016 ****
  				  XVECEXP (newpat, 0, 1)))
      {
!       newi2pat = XVECEXP (newpat, 0, 1);
!       newpat = XVECEXP (newpat, 0, 0);
  
        i2_code_number
--- 2011,2029 ----
  				  XVECEXP (newpat, 0, 1)))
      {
!       /* Normally, it doesn't matter which of the two is done first,
! 	 but it does if one references cc0.  In that case, it has to
! 	 be first.  */
! #ifdef HAVE_cc0
!       if (reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0)))
! 	{
! 	  newi2pat = XVECEXP (newpat, 0, 0);
! 	  newpat = XVECEXP (newpat, 0, 1);
! 	}
!       else
! #endif
! 	{
! 	  newi2pat = XVECEXP (newpat, 0, 1);
! 	  newpat = XVECEXP (newpat, 0, 0);
! 	}
  
        i2_code_number
*************** simplify_rtx (x, op0_mode, last, in_dest
*** 3278,3282 ****
        if (CONSTANT_P (SUBREG_REG (x)) && op0_mode != VOIDmode
  	  && GET_MODE_SIZE (mode) == UNITS_PER_WORD
! 	  && GET_MODE_SIZE (op0_mode) < UNITS_PER_WORD
  	  && GET_MODE_CLASS (mode) == MODE_INT)
  	{
--- 3291,3295 ----
        if (CONSTANT_P (SUBREG_REG (x)) && op0_mode != VOIDmode
  	  && GET_MODE_SIZE (mode) == UNITS_PER_WORD
! 	  && GET_MODE_SIZE (op0_mode) > UNITS_PER_WORD
  	  && GET_MODE_CLASS (mode) == MODE_INT)
  	{
*************** simplify_rtx (x, op0_mode, last, in_dest
*** 3290,3295 ****
  	 take the low bits.  On a little-endian machine, that's
  	 always valid.  On a big-endian machine, it's valid
! 	 only if the constant's mode fits in one word.  */
!       if (CONSTANT_P (SUBREG_REG (x)) && subreg_lowpart_p (x)
  	  && GET_MODE_SIZE (mode) < GET_MODE_SIZE (op0_mode)
  	  && (! WORDS_BIG_ENDIAN
--- 3303,3316 ----
  	 take the low bits.  On a little-endian machine, that's
  	 always valid.  On a big-endian machine, it's valid
! 	 only if the constant's mode fits in one word.   Note that we
! 	 cannot use subreg_lowpart_p since we SUBREG_REG may be VOIDmode.  */
!       if (CONSTANT_P (SUBREG_REG (x))
! 	  && ((GET_MODE_SIZE (op0_mode) <= UNITS_PER_WORD
! 	      || ! WORDS_BIG_ENDIAN)
! 	      ? SUBREG_WORD (x) == 0
! 	      : (SUBREG_WORD (x)
! 		 == ((GET_MODE_SIZE (op0_mode)
! 		      - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
! 		     / UNITS_PER_WORD)))
  	  && GET_MODE_SIZE (mode) < GET_MODE_SIZE (op0_mode)
  	  && (! WORDS_BIG_ENDIAN
*************** num_sign_bit_copies (x, mode)
*** 7326,7329 ****
--- 7347,7356 ----
  
      case NEG:
+       while (GET_MODE (XEXP (x, 0)) == GET_MODE (x)
+ 	     && GET_CODE (XEXP (x, 0)) == NEG
+ 	     && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
+ 	     && GET_CODE (XEXP (XEXP (x, 0), 0)) == NEG)
+ 	x = XEXP (XEXP (x, 0), 0);	/* Speed up 961126-1.c */
+ 
        /* In general, this subtracts one sign bit copy.  But if the value
  	 is known to be positive, the number of sign bit copies is the
*************** move_deaths (x, from_cuid, to_insn, pnot
*** 10421,10425 ****
  	  if (note != 0 && regno < FIRST_PSEUDO_REGISTER
  	      && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
! 		  != GET_MODE_SIZE (GET_MODE (x))))
  	    {
  	      int deadregno = REGNO (XEXP (note, 0));
--- 10448,10452 ----
  	  if (note != 0 && regno < FIRST_PSEUDO_REGISTER
  	      && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
! 		  > GET_MODE_SIZE (GET_MODE (x))))
  	    {
  	      int deadregno = REGNO (XEXP (note, 0));
*************** move_deaths (x, from_cuid, to_insn, pnot
*** 10437,10452 ****
  			       REG_NOTES (where_dead));
  	    }
! 	  /* If we didn't find any note, and we have a multi-reg hard
  	     register, then to be safe we must check for REG_DEAD notes
  	     for each register other than the first.  They could have
  	     their own REG_DEAD notes lying around.  */
! 	  else if (note == 0 && regno < FIRST_PSEUDO_REGISTER
  		   && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
  	    {
  	      int ourend = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
! 	      int i;
  	      rtx oldnotes = 0;
  
! 	      for (i = regno + 1; i < ourend; i++)
  		move_deaths (gen_rtx (REG, reg_raw_mode[i], i),
  			     from_cuid, to_insn, &oldnotes);
--- 10464,10489 ----
  			       REG_NOTES (where_dead));
  	    }
! 	  /* If we didn't find any note, or if we found a REG_DEAD note that
! 	     covers only part of the given reg, and we have a multi-reg hard
  	     register, then to be safe we must check for REG_DEAD notes
  	     for each register other than the first.  They could have
  	     their own REG_DEAD notes lying around.  */
! 	  else if ((note == 0
! 		    || (note != 0
! 			&& (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
! 			    < GET_MODE_SIZE (GET_MODE (x)))))
! 		   && regno < FIRST_PSEUDO_REGISTER
  		   && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
  	    {
  	      int ourend = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
! 	      int i, offset;
  	      rtx oldnotes = 0;
  
! 	      if (note)
! 		offset = HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0)));
! 	      else
! 		offset = 1;
! 
! 	      for (i = regno + offset; i < ourend; i++)
  		move_deaths (gen_rtx (REG, reg_raw_mode[i], i),
  			     from_cuid, to_insn, &oldnotes);
*************** distribute_notes (notes, from_insn, i3, 
*** 10648,10651 ****
--- 10685,10689 ----
  	case REG_EQUIV:
  	case REG_NONNEG:
+ 	case REG_NOALIAS:
  	  /* These notes say something about results of an insn.  We can
  	     only support them if they used to be on I3 in which case they
diff -rcp2N gcc-2.7.2.3/config/alpha/alpha.c gcc-2.7.2.3.f.2/config/alpha/alpha.c
*** gcc-2.7.2.3/config/alpha/alpha.c	Sat Jun 29 16:26:53 1996
--- gcc-2.7.2.3.f.2/config/alpha/alpha.c	Tue Sep  9 07:01:17 1997
*************** extern int rtx_equal_function_value_matt
*** 64,67 ****
--- 64,69 ----
  /* Declarations of static functions.  */
  static void alpha_set_memflags_1  PROTO((rtx, int, int, int));
+ static rtx alpha_emit_set_const_1 PROTO((rtx, enum machine_mode,
+ 					 HOST_WIDE_INT, int));
  static void add_long_const	PROTO((FILE *, HOST_WIDE_INT, int, int, int));
  
*************** alpha_emit_set_const (target, mode, c, n
*** 670,673 ****
--- 672,695 ----
       int n;
  {
+   rtx pat;
+   int i;
+ 
+   /* Try 1 insn, then 2, then up to N. */
+   for (i = 1; i <= n; i++)
+     if ((pat = alpha_emit_set_const_1 (target, mode, c, i)) != 0)
+       return pat;
+ 
+   return 0;
+ }
+ 
+ /* Internal routine for the above to check for N or below insns.  */
+ 
+ static rtx
+ alpha_emit_set_const_1 (target, mode, c, n)
+      rtx target;
+      enum machine_mode mode;
+      HOST_WIDE_INT c;
+      int n;
+ {
    HOST_WIDE_INT new = c;
    int i, bits;
*************** alpha_emit_set_const (target, mode, c, n
*** 714,723 ****
        if (c == low || (low == 0 && extra == 0))
  	return copy_to_suggested_reg (GEN_INT (c), target, mode);
!       else if (n >= 2 + (extra != 0)
! 	       /* We can't do this when SImode if HIGH required adjustment.
! 		  This is because the code relies on an implicit overflow
! 		  which is invisible to the RTL.  We can thus get incorrect
! 		  code if the two ldah instructions are combined.  */
! 	       && ! (mode == SImode && extra != 0))
  	{
  	  temp = copy_to_suggested_reg (GEN_INT (low), subtarget, mode);
--- 736,740 ----
        if (c == low || (low == 0 && extra == 0))
  	return copy_to_suggested_reg (GEN_INT (c), target, mode);
!       else if (n >= 2 + (extra != 0))
  	{
  	  temp = copy_to_suggested_reg (GEN_INT (low), subtarget, mode);
*************** direct_return ()
*** 1239,1243 ****
     cross-compiler.  Otherwise, use the versions in /usr/include/stamp.h.  */
  
! #if !defined(CROSS_COMPILE) && !defined(_WIN32)
  #include <stamp.h>
  #endif
--- 1256,1260 ----
     cross-compiler.  Otherwise, use the versions in /usr/include/stamp.h.  */
  
! #if !defined(CROSS_COMPILE) && !defined(_WIN32) && !defined(__linux__)
  #include <stamp.h>
  #endif
*************** output_prolog (file, size)
*** 1370,1373 ****
--- 1387,1395 ----
  
    alpha_function_needs_gp = 0;
+ #ifdef __linux__
+   if(profile_flag) {
+       alpha_function_needs_gp = 1;
+   }
+ #endif
    for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
      if ((GET_CODE (insn) == CALL_INSN)
diff -rcp2N gcc-2.7.2.3/config/alpha/alpha.h gcc-2.7.2.3.f.2/config/alpha/alpha.h
*** gcc-2.7.2.3/config/alpha/alpha.h	Sat Jun 29 16:27:31 1996
--- gcc-2.7.2.3.f.2/config/alpha/alpha.h	Thu Feb 26 21:16:59 1998
*************** extern int target_flags;
*** 112,116 ****
--- 112,118 ----
      {"", TARGET_DEFAULT | TARGET_CPU_DEFAULT} }
  
+ #ifndef TARGET_DEFAULT
  #define TARGET_DEFAULT 3
+ #endif
  
  #ifndef TARGET_CPU_DEFAULT
*************** extern int target_flags;
*** 253,256 ****
--- 255,261 ----
  #define BIGGEST_ALIGNMENT 64
  
+ /* For atomic access to objects, must have at least 32-bit alignment.  */
+ #define MINIMUM_ATOMIC_ALIGNMENT 32
+ 
  /* Make strings word-aligned so strcpy from constants will be faster.  */
  #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
*************** enum reg_class { NO_REGS, GENERAL_REGS, 
*** 665,668 ****
--- 670,676 ----
  /*  #define PUSH_ROUNDING(BYTES) */
  
+ /* Define this to be nonzero if stack checking is built into the ABI.  */
+ #define STACK_CHECK_BUILTIN 1
+ 
  /* Define this if the maximum size of all the outgoing args is to be
     accumulated and pushed during the prologue.  The amount can be
*************** __enable_execute_stack (addr)						\
*** 1374,1378 ****
  /* Define the value returned by a floating-point comparison instruction.  */
  
! #define FLOAT_STORE_FLAG_VALUE 0.5
  
  /* Canonicalize a comparison from one we don't have to one we do have.  */
--- 1382,1386 ----
  /* Define the value returned by a floating-point comparison instruction.  */
  
! #define FLOAT_STORE_FLAG_VALUE 2.0
  
  /* Canonicalize a comparison from one we don't have to one we do have.  */
diff -rcp2N gcc-2.7.2.3/config/alpha/alpha.md gcc-2.7.2.3.f.2/config/alpha/alpha.md
*** gcc-2.7.2.3/config/alpha/alpha.md	Fri Oct 27 10:49:59 1995
--- gcc-2.7.2.3.f.2/config/alpha/alpha.md	Tue Sep  9 07:01:17 1997
***************
*** 1746,1752 ****
  	(if_then_else:DF 
  	 (match_operator 3 "signed_comparison_operator"
! 			 [(match_operand:DF 1 "reg_or_fp0_operand" "fG,fG")
  			  (match_operand:DF 2 "fp0_operand" "G,G")])
! 	 (float_extend:DF (match_operand:SF 4 "reg_or_fp0_operand" "fG,0"))
  	 (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
    "TARGET_FP"
--- 1746,1752 ----
  	(if_then_else:DF 
  	 (match_operator 3 "signed_comparison_operator"
! 			 [(match_operand:DF 4 "reg_or_fp0_operand" "fG,fG")
  			  (match_operand:DF 2 "fp0_operand" "G,G")])
! 	 (float_extend:DF (match_operand:SF 1 "reg_or_fp0_operand" "fG,0"))
  	 (match_operand:DF 5 "reg_or_fp0_operand" "0,fG")))]
    "TARGET_FP"
diff -rcp2N gcc-2.7.2.3/config/alpha/elf.h gcc-2.7.2.3.f.2/config/alpha/elf.h
*** gcc-2.7.2.3/config/alpha/elf.h	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/alpha/elf.h	Tue Sep  9 07:01:18 1997
***************
*** 0 ****
--- 1,522 ----
+ /* Definitions of target machine for GNU compiler, for DEC Alpha w/ELF.
+    Copyright (C) 1996 Free Software Foundation, Inc.
+    Contributed by Richard Henderson (rth@tamu.edu).
+ 
+ This file is part of GNU CC.
+ 
+ GNU CC 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, or (at your option)
+ any later version.
+ 
+ GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+ the Free Software Foundation, 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.    */
+ 
+ /* This is used on Alpha platforms that use the ELF format.
+ Currently only Linux uses this. */
+ 
+ #include "alpha/linux.h"
+ 
+ #undef TARGET_VERSION
+ #define TARGET_VERSION fprintf (stderr, " (Alpha Linux/ELF)");
+ 
+ #undef OBJECT_FORMAT_COFF
+ #undef EXTENDED_COFF
+ #define OBJECT_FORMAT_ELF
+ 
+ #define SDB_DEBUGGING_INFO
+ 
+ #undef ASM_FINAL_SPEC
+ 
+ #undef CPP_PREDEFINES
+ #define CPP_PREDEFINES "\
+ -D__alpha -D__alpha__ -D__linux__ -D__linux -D_LONGLONG -Dlinux -Dunix \
+ -Asystem(linux) -Acpu(alpha) -Amachine(alpha) -D__ELF__"
+ 
+ #undef LINK_SPEC
+ #define LINK_SPEC "-m elf64alpha -G 8 %{O*:-O3} %{!O*:-O1}	\
+   %{shared:-shared}						\
+   %{!shared:							\
+     %{!static:							\
+       %{rdynamic:-export-dynamic}				\
+       %{!dynamic-linker:-dynamic-linker /lib/ld.so.1}}		\
+     %{static:-static}}"
+ 
+ /* Output at beginning of assembler file.  */
+ 
+ #undef ASM_FILE_START
+ #define ASM_FILE_START(FILE)					\
+ {								\
+   alpha_write_verstamp (FILE);					\
+   output_file_directive (FILE, main_input_filename);		\
+   fprintf (FILE, "\t.version\t\"01.01\"\n");			\
+   fprintf (FILE, "\t.set noat\n");				\
+ }
+ 
+ #define ASM_OUTPUT_SOURCE_LINE(STREAM, LINE)			\
+   alpha_output_lineno (STREAM, LINE)
+ extern void alpha_output_lineno ();
+ 
+ extern void output_file_directive ();
+ 
+ /* Attach a special .ident directive to the end of the file to identify
+    the version of GCC which compiled this code.  The format of the
+    .ident string is patterned after the ones produced by native svr4
+    C compilers.  */
+ 
+ #define IDENT_ASM_OP ".ident"
+ 
+ #ifdef IDENTIFY_WITH_IDENT
+ #define ASM_IDENTIFY_GCC(FILE) /* nothing */
+ #define ASM_IDENTIFY_LANGUAGE(FILE)				\
+  fprintf(FILE, "\t%s \"GCC (%s) %s\"\n", IDENT_ASM_OP,		\
+ 	 lang_identify(), version_string)
+ #else
+ #define ASM_FILE_END(FILE)					\
+ do {				 				\
+      fprintf ((FILE), "\t%s\t\"GCC: (GNU) %s\"\n",		\
+ 	      IDENT_ASM_OP, version_string);			\
+    } while (0)
+ #endif
+ 
+ /* Allow #sccs in preprocessor.  */
+ 
+ #define SCCS_DIRECTIVE
+ 
+ /* Output #ident as a .ident.  */
+ 
+ #define ASM_OUTPUT_IDENT(FILE, NAME) \
+   fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME);
+ 
+ /* This is how to allocate empty space in some section.  The .zero
+    pseudo-op is used for this on most svr4 assemblers.  */
+ 
+ #define SKIP_ASM_OP	".zero"
+ 
+ #undef ASM_OUTPUT_SKIP
+ #define ASM_OUTPUT_SKIP(FILE,SIZE) \
+   fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE))
+ 
+ /* Output the label which precedes a jumptable.  Note that for all svr4
+    systems where we actually generate jumptables (which is to say every
+    svr4 target except i386, where we use casesi instead) we put the jump-
+    tables into the .rodata section and since other stuff could have been
+    put into the .rodata section prior to any given jumptable, we have to
+    make sure that the location counter for the .rodata section gets pro-
+    perly re-aligned prior to the actual beginning of the jump table.  */
+ 
+ #define ALIGN_ASM_OP ".align"
+ 
+ #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL
+ #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
+   ASM_OUTPUT_ALIGN ((FILE), 2);
+ #endif
+ 
+ #undef ASM_OUTPUT_CASE_LABEL
+ #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE)		\
+   do {									\
+     ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE)		\
+     ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM);			\
+   } while (0)
+ 
+ /* The standard SVR4 assembler seems to require that certain builtin
+    library routines (e.g. .udiv) be explicitly declared as .globl
+    in each assembly file where they are referenced.  */
+ 
+ #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)				\
+   ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
+ 
+ /* This says how to output assembler code to declare an
+    uninitialized external linkage data object.  Under SVR4,
+    the linker seems to want the alignment of data objects
+    to depend on their types.  We do exactly that here.  */
+ 
+ #define COMMON_ASM_OP	".comm"
+ 
+ #undef ASM_OUTPUT_ALIGNED_COMMON
+ #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)		\
+ do {									\
+   fprintf ((FILE), "\t%s\t", COMMON_ASM_OP);				\
+   assemble_name ((FILE), (NAME));					\
+   fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);	\
+ } while (0)
+ 
+ /* This says how to output assembler code to declare an
+    uninitialized internal linkage data object.  Under SVR4,
+    the linker seems to want the alignment of data objects
+    to depend on their types.  We do exactly that here.  */
+ 
+ #define LOCAL_ASM_OP	".local"
+ 
+ #undef ASM_OUTPUT_ALIGNED_LOCAL
+ #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)		\
+ do {									\
+   fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP);				\
+   assemble_name ((FILE), (NAME));					\
+   fprintf ((FILE), "\n");						\
+   ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);			\
+ } while (0)
+ 
+ /* This is the pseudo-op used to generate a 64-bit word of data with a
+    specific value in some section.    */
+ 
+ #define INT_ASM_OP		".quad"
+ 
+ /* This is the pseudo-op used to generate a contiguous sequence of byte
+    values from a double-quoted string WITHOUT HAVING A TERMINATING NUL
+    AUTOMATICALLY APPENDED.  This is the same for most svr4 assemblers.  */
+ 
+ #undef ASCII_DATA_ASM_OP
+ #define ASCII_DATA_ASM_OP	".ascii"
+ 
+ /* Support const sections and the ctors and dtors sections for g++.
+    Note that there appears to be two different ways to support const
+    sections at the moment.  You can either #define the symbol
+    READONLY_DATA_SECTION (giving it some code which switches to the
+    readonly data section) or else you can #define the symbols
+    EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and
+    SELECT_RTX_SECTION.  We do both here just to be on the safe side.  */
+ 
+ #define USE_CONST_SECTION	1
+ 
+ #define CONST_SECTION_ASM_OP	".section\t.rodata"
+ 
+ /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
+ 
+    Note that we want to give these sections the SHF_WRITE attribute
+    because these sections will actually contain data (i.e. tables of
+    addresses of functions in the current root executable or shared library
+    file) and, in the case of a shared library, the relocatable addresses
+    will have to be properly resolved/relocated (and then written into) by
+    the dynamic linker when it actually attaches the given shared library
+    to the executing process.  (Note that on SVR4, you may wish to use the
+    `-z text' option to the ELF linker, when building a shared library, as
+    an additional check that you are doing everything right.  But if you do
+    use the `-z text' option when building a shared library, you will get
+    errors unless the .ctors and .dtors sections are marked as writable
+    via the SHF_WRITE attribute.)  */
+ 
+ #define CTORS_SECTION_ASM_OP	".section\t.ctors,\"aw\""
+ #define DTORS_SECTION_ASM_OP	".section\t.dtors,\"aw\""
+ 
+ /* On svr4, we *do* have support for the .init and .fini sections, and we
+    can put stuff in there to be executed before and after `main'.  We let
+    crtstuff.c and other files know this by defining the following symbols.
+    The definitions say how to change sections to the .init and .fini
+    sections.  This is the same for all known svr4 assemblers.  */
+ 
+ #define INIT_SECTION_ASM_OP	".section\t.init"
+ #define FINI_SECTION_ASM_OP	".section\t.fini"
+ 
+ /* Support non-common, uninitialized data in the .bss section.  */
+ 
+ #define BSS_SECTION_ASM_OP	".section\t.bss"
+ 
+ /* A default list of other sections which we might be "in" at any given
+    time.  For targets that use additional sections (e.g. .tdesc) you
+    should override this definition in the target-specific file which
+    includes this file.  */
+ 
+ #undef EXTRA_SECTIONS
+ #define EXTRA_SECTIONS in_const, in_ctors, in_dtors, in_bss
+ 
+ /* A default list of extra section function definitions.  For targets
+    that use additional sections (e.g. .tdesc) you should override this
+    definition in the target-specific file which includes this file.  */
+ 
+ #undef EXTRA_SECTION_FUNCTIONS
+ #define EXTRA_SECTION_FUNCTIONS						\
+   CONST_SECTION_FUNCTION						\
+   CTORS_SECTION_FUNCTION						\
+   DTORS_SECTION_FUNCTION						\
+   BSS_SECTION_FUNCTION
+ 
+ #undef READONLY_DATA_SECTION
+ #define READONLY_DATA_SECTION() const_section ()
+ 
+ extern void text_section ();
+ 
+ #define CONST_SECTION_FUNCTION						\
+ void									\
+ const_section ()							\
+ {									\
+   if (!USE_CONST_SECTION)						\
+     text_section();							\
+   else if (in_section != in_const)					\
+     {									\
+       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);		\
+       in_section = in_const;						\
+     }									\
+ }
+ 
+ #define CTORS_SECTION_FUNCTION						\
+ void									\
+ ctors_section ()							\
+ {									\
+   if (in_section != in_ctors)						\
+     {									\
+       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);		\
+       in_section = in_ctors;						\
+     }									\
+ }
+ 
+ #define DTORS_SECTION_FUNCTION						\
+ void									\
+ dtors_section ()							\
+ {									\
+   if (in_section != in_dtors)						\
+     {									\
+       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);		\
+       in_section = in_dtors;						\
+     }									\
+ }
+ 
+ #define BSS_SECTION_FUNCTION						\
+ void									\
+ bss_section ()								\
+ {									\
+   if (in_section != in_bss)						\
+     {									\
+       fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);		\
+       in_section = in_bss;						\
+     }									\
+ }
+ 
+ 
+ /* Switch into a generic section.
+    This is currently only used to support section attributes.
+ 
+    We make the section read-only and executable for a function decl,
+    read-only for a const data decl, and writable for a non-const data decl.  */
+ #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \
+   fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, \
+ 	   (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" : \
+ 	   (DECL) && TREE_READONLY (DECL) ? "a" : "aw")
+ 
+ 
+ /* A C statement (sans semicolon) to output an element in the table of
+    global constructors.  */
+ #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME)				\
+   do {									\
+     ctors_section ();							\
+     fprintf (FILE, "\t%s\t ", INT_ASM_OP);				\
+     assemble_name (FILE, NAME);						\
+     fprintf (FILE, "\n");						\
+   } while (0)
+ 
+ /* A C statement (sans semicolon) to output an element in the table of
+    global destructors.  */
+ #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)       				\
+   do {									\
+     dtors_section ();                   				\
+     fprintf (FILE, "\t%s\t ", INT_ASM_OP);				\
+     assemble_name (FILE, NAME);              				\
+     fprintf (FILE, "\n");						\
+   } while (0)
+ 
+ /* A C statement or statements to switch to the appropriate
+    section for output of DECL.  DECL is either a `VAR_DECL' node
+    or a constant of some sort.  RELOC indicates whether forming
+    the initial value of DECL requires link-time relocations.  */
+ 
+ #define SELECT_SECTION(DECL,RELOC)					\
+ {									\
+   if (TREE_CODE (DECL) == STRING_CST)					\
+     {									\
+       if (! flag_writable_strings)					\
+ 	const_section ();						\
+       else								\
+ 	data_section ();						\
+     }									\
+   else if (TREE_CODE (DECL) == VAR_DECL)				\
+     {									\
+       if ((flag_pic && RELOC)						\
+ 	  || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)		\
+ 	  || !DECL_INITIAL (DECL)					\
+ 	  || (DECL_INITIAL (DECL) != error_mark_node			\
+ 	      && !TREE_CONSTANT (DECL_INITIAL (DECL))))			\
+         {								\
+           if (DECL_COMMON (DECL)					\
+ 	      && !DECL_INITIAL (DECL))					\
+ 	          /* || DECL_INITIAL (DECL) == error_mark_node)) */	\
+ 	    bss_section();						\
+ 	  else								\
+ 	    data_section ();						\
+ 	}								\
+       else								\
+ 	const_section ();						\
+     }									\
+   else									\
+     const_section ();							\
+ }
+ 
+ /* A C statement or statements to switch to the appropriate
+    section for output of RTX in mode MODE.  RTX is some kind
+    of constant in RTL.  The argument MODE is redundant except
+    in the case of a `const_int' rtx.  Currently, these always
+    go into the const section.  */
+ 
+ #undef SELECT_RTX_SECTION
+ #define SELECT_RTX_SECTION(MODE,RTX) const_section()
+ 
+ /* Define the strings used for the special svr4 .type and .size directives.
+    These strings generally do not vary from one system running svr4 to
+    another, but if a given system (e.g. m88k running svr) needs to use
+    different pseudo-op names for these, they may be overridden in the
+    file which includes this one.  */
+ 
+ #define TYPE_ASM_OP	".type"
+ #define SIZE_ASM_OP	".size"
+ 
+ /* This is how we tell the assembler that a symbol is weak.  */
+ 
+ #define ASM_WEAKEN_LABEL(FILE,NAME) \
+   do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME); \
+        fputc ('\n', FILE); } while (0)
+ 
+ /* This is how we tell the assembler that two symbols have the same value.  */
+ 
+ #define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \
+   do { assemble_name(FILE, NAME1); 	 \
+        fputs(" = ", FILE);		 \
+        assemble_name(FILE, NAME2);	 \
+        fputc('\n', FILE); } while (0)
+ 
+ /* The following macro defines the format used to output the second
+    operand of the .type assembler directive.  Different svr4 assemblers
+    expect various different forms for this operand.  The one given here
+    is just a default.  You may need to override it in your machine-
+    specific tm.h file (depending upon the particulars of your assembler).  */
+ 
+ #define TYPE_OPERAND_FMT	"@%s"
+ 
+ /* Write the extra assembler code needed to declare a function's result.
+    Most svr4 assemblers don't require any special declaration of the
+    result value, but there are exceptions.  */
+ 
+ #ifndef ASM_DECLARE_RESULT
+ #define ASM_DECLARE_RESULT(FILE, RESULT)
+ #endif
+ 
+ /* These macros generate the special .type and .size directives which
+    are used to set the corresponding fields of the linker symbol table
+    entries in an ELF object file under SVR4.  These macros also output
+    the starting labels for the relevant functions/objects.  */
+ 
+ /* Write the extra assembler code needed to declare an object properly.  */
+ 
+ #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)			\
+   do {									\
+     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);				\
+     assemble_name (FILE, NAME);						\
+     putc (',', FILE);							\
+     fprintf (FILE, TYPE_OPERAND_FMT, "object");				\
+     putc ('\n', FILE);							\
+     size_directive_output = 0;						\
+     if (!flag_inhibit_size_directive && DECL_SIZE (DECL))		\
+       {									\
+ 	size_directive_output = 1;					\
+ 	fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);				\
+ 	assemble_name (FILE, NAME);					\
+ 	fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL)));	\
+       }									\
+     ASM_OUTPUT_LABEL(FILE, NAME);					\
+   } while (0)
+ 
+ /* Output the size directive for a decl in rest_of_decl_compilation
+    in the case where we did not do so before the initializer.
+    Once we find the error_mark_node, we know that the value of
+    size_directive_output was set
+    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
+ 
+ #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)	 \
+ do {									 \
+      char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);			 \
+      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)		 \
+          && ! AT_END && TOP_LEVEL					 \
+ 	 && DECL_INITIAL (DECL) == error_mark_node			 \
+ 	 && !size_directive_output)					 \
+        {								 \
+ 	 size_directive_output = 1;					 \
+ 	 fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);			 \
+ 	 assemble_name (FILE, name);					 \
+ 	 fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
+        }								 \
+    } while (0)
+ 
+ /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
+    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
+    corresponds to a particular byte value [0..255].  For any
+    given byte value, if the value in the corresponding table
+    position is zero, the given character can be output directly.
+    If the table value is 1, the byte must be output as a \ooo
+    octal escape.  If the tables value is anything else, then the
+    byte value should be output as a \ followed by the value
+    in the table.  Note that we can use standard UN*X escape
+    sequences for many control characters, but we don't use
+    \a to represent BEL because some svr4 assemblers (e.g. on
+    the i386) don't know about that.  Also, we don't use \v
+    since some versions of gas, such as 2.2 did not accept it.  */
+ 
+ #define ESCAPES \
+ "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
+ \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
+ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\
+ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\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\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\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\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\1"
+ 
+ /* Some svr4 assemblers have a limit on the number of characters which
+    can appear in the operand of a .string directive.  If your assembler
+    has such a limitation, you should define STRING_LIMIT to reflect that
+    limit.  Note that at least some svr4 assemblers have a limit on the
+    actual number of bytes in the double-quoted string, and that they
+    count each character in an escape sequence as one byte.  Thus, an
+    escape sequence like \377 would count as four bytes.
+ 
+    If your target assembler doesn't support the .string directive, you
+    should define this to zero.
+ */
+ 
+ #define STRING_LIMIT	((unsigned) 256)
+ 
+ #define STRING_ASM_OP	".string"
+ 
+ /*
+  * We always use gas here, so we don't worry about ECOFF assembler problems.
+  */
+ #undef TARGET_GAS
+ #define TARGET_GAS	(1)
+ 
+ #undef PREFERRED_DEBUGGING_TYPE
+ #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
+ 
+ /* Provide a STARTFILE_SPEC appropriate for Linux.  Here we add
+    the Linux magical crtbegin.o file (see crtstuff.c) which
+    provides part of the support for getting C++ file-scope static
+    object constructed before entering `main'. */
+    
+ #undef	STARTFILE_SPEC
+ #define STARTFILE_SPEC \
+   "%{!shared: \
+      %{pg:gcrt1.o%s} %{!pg:%{p:gcrt1.o%s} %{!p:crt1.o%s}}}\
+    crti.o%s crtbegin.o%s"
+ 
+ /* Provide a ENDFILE_SPEC appropriate for Linux.  Here we tack on
+    the Linux magical crtend.o file (see crtstuff.c) which
+    provides part of the support for getting C++ file-scope static
+    object constructed before entering `main', followed by a normal
+    Linux "finalizer" file, `crtn.o'.  */
+ 
+ #undef	ENDFILE_SPEC
+ #define ENDFILE_SPEC \
+   "crtend.o%s crtn.o%s"
diff -rcp2N gcc-2.7.2.3/config/alpha/linux.h gcc-2.7.2.3.f.2/config/alpha/linux.h
*** gcc-2.7.2.3/config/alpha/linux.h	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/alpha/linux.h	Tue Sep  9 07:01:18 1997
***************
*** 0 ****
--- 1,72 ----
+ /* Definitions of target machine for GNU compiler, for Alpha Linux,
+    using ECOFF.
+    Copyright (C) 1995 Free Software Foundation, Inc.
+    Contributed by Bob Manson.
+    Derived from work contributed by Cygnus Support,
+    (c) 1993 Free Software Foundation.
+ 
+ This file is part of GNU CC.
+ 
+ GNU CC 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, or (at your option)
+ any later version.
+ 
+ GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+ 
+ #define TARGET_DEFAULT (3 | MASK_GAS)
+ 
+ #include "alpha/alpha.h"
+ 
+ #undef TARGET_VERSION
+ #define TARGET_VERSION fprintf (stderr, " (Linux/Alpha)");
+ 
+ #undef CPP_PREDEFINES
+ #define CPP_PREDEFINES "\
+ -D__alpha -D__alpha__ -D__linux__ -D__linux -D_LONGLONG -Dlinux -Dunix \
+ -Asystem(linux) -Acpu(alpha) -Amachine(alpha)"
+ 
+ /* We don't actually need any of these; the MD_ vars are ignored
+    anyway for cross-compilers, and the other specs won't get picked up
+    'coz the user is supposed to do ld -r (hmm, perhaps that should be
+    the default).  In any case, setting them thus will catch some
+    common user errors. */
+ 
+ #undef	MD_EXEC_PREFIX
+ #undef	MD_STARTFILE_PREFIX
+ 
+ #undef	LIB_SPEC
+ #define LIB_SPEC "%{pg:-lgmon} %{pg:-lc_p} %{!pg:-lc}"
+ 
+ #undef	LINK_SPEC
+ #define LINK_SPEC  \
+   "-G 8 %{O*:-O3} %{!O*:-O1}"
+ 
+ #undef ASM_SPEC
+ #define ASM_SPEC "-nocpp"
+ 
+ /* Can't do stabs */
+ #undef SDB_DEBUGGING_INFO
+ 
+ /* Prefer dbx.  */
+ #undef PREFERRED_DEBUGGING_TYPE
+ #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
+ 
+ #undef FUNCTION_PROFILER
+ 
+ #define FUNCTION_PROFILER(FILE, LABELNO)			\
+     do {							\
+ 	fputs ("\tlda $27,_mcount\n", (FILE));			\
+ 	fputs ("\tjsr $26,($27),_mcount\n", (FILE));		\
+ 	fputs ("\tldgp $29,0($26)\n", (FILE));			\
+     } while (0);
+ 
+ /* Generate calls to memcpy, etc., not bcopy, etc. */
+ #define TARGET_MEM_FUNCTIONS
diff -rcp2N gcc-2.7.2.3/config/alpha/t-linux gcc-2.7.2.3.f.2/config/alpha/t-linux
*** gcc-2.7.2.3/config/alpha/t-linux	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/alpha/t-linux	Tue Sep  9 07:01:18 1997
***************
*** 0 ****
--- 1,3 ----
+ # Our header files are supposed to be correct, nein?
+ FIXINCLUDES = 
+ STMP_FIXPROTO =
diff -rcp2N gcc-2.7.2.3/config/alpha/x-linux gcc-2.7.2.3.f.2/config/alpha/x-linux
*** gcc-2.7.2.3/config/alpha/x-linux	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/alpha/x-linux	Tue Sep  9 07:01:18 1997
***************
*** 0 ****
--- 1 ----
+ CLIB=-lbfd -liberty
diff -rcp2N gcc-2.7.2.3/config/alpha/xm-alpha.h gcc-2.7.2.3.f.2/config/alpha/xm-alpha.h
*** gcc-2.7.2.3/config/alpha/xm-alpha.h	Thu Aug 31 21:52:27 1995
--- gcc-2.7.2.3.f.2/config/alpha/xm-alpha.h	Tue Sep  9 07:01:18 1997
*************** Boston, MA 02111-1307, USA.  */
*** 46,51 ****
--- 46,53 ----
  #include <alloca.h>
  #else
+ #ifndef alloca
  extern void *alloca ();
  #endif
+ #endif
  
  /* The host compiler has problems with enum bitfields since it makes
*************** extern void *malloc (), *realloc (), *ca
*** 68,72 ****
--- 70,76 ----
  /* OSF/1 has vprintf.  */
  
+ #ifndef linux  /* 1996/02/22 mauro@craftwork.com -- unreliable with Linux */
  #define HAVE_VPRINTF
+ #endif
  
  /* OSF/1 has putenv.  */
diff -rcp2N gcc-2.7.2.3/config/alpha/xm-linux.h gcc-2.7.2.3.f.2/config/alpha/xm-linux.h
*** gcc-2.7.2.3/config/alpha/xm-linux.h	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/alpha/xm-linux.h	Tue Sep  9 07:01:18 1997
***************
*** 0 ****
--- 1,10 ----
+ #ifndef _XM_LINUX_H
+ #define _XM_LINUX_H
+ 
+ #include "xm-alpha.h"
+ 
+ #define HAVE_STRERROR
+ 
+ #define DONT_DECLARE_SYS_SIGLIST
+ #define USE_BFD
+ #endif
diff -rcp2N gcc-2.7.2.3/config/i386/i386.c gcc-2.7.2.3.f.2/config/i386/i386.c
*** gcc-2.7.2.3/config/i386/i386.c	Sun Oct 22 11:13:21 1995
--- gcc-2.7.2.3.f.2/config/i386/i386.c	Tue Sep  9 07:01:18 1997
*************** standard_80387_constant_p (x)
*** 1290,1294 ****
    set_float_handler (handler);
    REAL_VALUE_FROM_CONST_DOUBLE (d, x);
!   is0 = REAL_VALUES_EQUAL (d, dconst0);
    is1 = REAL_VALUES_EQUAL (d, dconst1);
    set_float_handler (NULL_PTR);
--- 1290,1294 ----
    set_float_handler (handler);
    REAL_VALUE_FROM_CONST_DOUBLE (d, x);
!   is0 = REAL_VALUES_EQUAL (d, dconst0) && !REAL_VALUE_MINUS_ZERO (d);
    is1 = REAL_VALUES_EQUAL (d, dconst1);
    set_float_handler (NULL_PTR);
diff -rcp2N gcc-2.7.2.3/config/i386/i386.h gcc-2.7.2.3.f.2/config/i386/i386.h
*** gcc-2.7.2.3/config/i386/i386.h	Fri Sep 22 22:42:57 1995
--- gcc-2.7.2.3.f.2/config/i386/i386.h	Tue Mar  3 18:04:35 1998
*************** extern int target_flags;
*** 245,249 ****
  
  /* Boundary (in *bits*) on which stack pointer should be aligned.  */
! #define STACK_BOUNDARY 32
  
  /* Allocation boundary (in *bits*) for the code of a function.
--- 245,249 ----
  
  /* Boundary (in *bits*) on which stack pointer should be aligned.  */
! #define STACK_BOUNDARY BIGGEST_ALIGNMENT
  
  /* Allocation boundary (in *bits*) for the code of a function.
*************** do { long l;						\
*** 1699,1703 ****
  
  #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
!   fprintf (FILE, "\tpushl e%s\n", reg_names[REGNO])
  
  /* This is how to output an insn to pop a register from the stack.
--- 1699,1703 ----
  
  #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
!   fprintf (FILE, "\tpushl %%e%s\n", reg_names[REGNO])
  
  /* This is how to output an insn to pop a register from the stack.
*************** do { long l;						\
*** 1705,1709 ****
  
  #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
!   fprintf (FILE, "\tpopl e%s\n", reg_names[REGNO])
  
  /* This is how to output an element of a case-vector that is absolute.
--- 1705,1709 ----
  
  #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
!   fprintf (FILE, "\tpopl %%e%s\n", reg_names[REGNO])
  
  /* This is how to output an element of a case-vector that is absolute.
diff -rcp2N gcc-2.7.2.3/config/m68k/m68k.md gcc-2.7.2.3.f.2/config/m68k/m68k.md
*** gcc-2.7.2.3/config/m68k/m68k.md	Wed Aug 13 17:23:23 1997
--- gcc-2.7.2.3.f.2/config/m68k/m68k.md	Tue Sep  9 07:01:20 1997
***************
*** 288,292 ****
  	  (match_operand:DI 0 "nonimmediate_operand" "d"))
       (clobber (match_dup 1))])]
!   ""
    "operands[1] = gen_reg_rtx (DImode);")
  
--- 288,292 ----
  	  (match_operand:DI 0 "nonimmediate_operand" "d"))
       (clobber (match_dup 1))])]
!   "0"
    "operands[1] = gen_reg_rtx (DImode);")
  
***************
*** 411,415 ****
  		   (match_operand:DI 1 "general_operand" "")))
       (clobber (match_dup 2))])]
!   ""
    "operands[2] = gen_reg_rtx (DImode);")
  
--- 411,415 ----
  		   (match_operand:DI 1 "general_operand" "")))
       (clobber (match_dup 2))])]
!   "0"
    "operands[2] = gen_reg_rtx (DImode);")
  
diff -rcp2N gcc-2.7.2.3/config/mips/mips.c gcc-2.7.2.3.f.2/config/mips/mips.c
*** gcc-2.7.2.3/config/mips/mips.c	Sat Jun 29 16:26:44 1996
--- gcc-2.7.2.3.f.2/config/mips/mips.c	Tue Sep  9 07:01:20 1997
*************** expand_block_move (operands)
*** 2360,2365 ****
  
    else if (constp && bytes <= 2*MAX_MOVE_BYTES)
!     emit_insn (gen_movstrsi_internal (gen_rtx (MEM, BLKmode, dest_reg),
! 				      gen_rtx (MEM, BLKmode, src_reg),
  				      bytes_rtx, align_rtx));
  
--- 2360,2367 ----
  
    else if (constp && bytes <= 2*MAX_MOVE_BYTES)
!     emit_insn (gen_movstrsi_internal (change_address (operands[0],
! 						      BLKmode, dest_reg),
! 				      change_address (orig_src, BLKmode,
! 						      src_reg),
  				      bytes_rtx, align_rtx));
  
diff -rcp2N gcc-2.7.2.3/config/mips/mips.h gcc-2.7.2.3.f.2/config/mips/mips.h
*** gcc-2.7.2.3/config/mips/mips.h	Thu Nov  9 16:23:09 1995
--- gcc-2.7.2.3.f.2/config/mips/mips.h	Tue Sep  9 07:01:21 1997
*************** typedef struct mips_args {
*** 2160,2170 ****
      }									    \
  									    \
!   /* Flush the instruction cache.  */					    \
!   /* ??? Are the modes right? Maybe they should depend on -mint64/-mlong64? */\
    /* ??? Should check the return value for errors.  */			    \
!   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "cacheflush"),		    \
  		     0, VOIDmode, 3, addr, Pmode,			    \
  		     GEN_INT (TRAMPOLINE_SIZE), SImode,  		    \
! 		     GEN_INT (1), SImode);				    \
  }
  
--- 2160,2170 ----
      }									    \
  									    \
!   /* Flush both caches.  We need to flush the data cache in case	    \
!      the system has a write-back cache.  */				    \
    /* ??? Should check the return value for errors.  */			    \
!   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "_flush_cache"),	    \
  		     0, VOIDmode, 3, addr, Pmode,			    \
  		     GEN_INT (TRAMPOLINE_SIZE), SImode,  		    \
! 		     GEN_INT (3), TYPE_MODE (integer_type_node));	    \
  }
  
*************** typedef struct mips_args {
*** 2388,2392 ****
    ((GET_CODE (X) != CONST_DOUBLE					\
      || mips_const_double_ok (X, GET_MODE (X)))				\
!    && ! (GET_CODE (X) == CONST && ABI_64BIT))
  
  /* A C compound statement that attempts to replace X with a valid
--- 2388,2393 ----
    ((GET_CODE (X) != CONST_DOUBLE					\
      || mips_const_double_ok (X, GET_MODE (X)))				\
!    && ! (GET_CODE (X) == CONST						\
! 	 && (ABI_64BIT || GET_CODE (XEXP (X, 0)) == MINUS)))
  
  /* A C compound statement that attempts to replace X with a valid
diff -rcp2N gcc-2.7.2.3/config/mips/sni-gas.h gcc-2.7.2.3.f.2/config/mips/sni-gas.h
*** gcc-2.7.2.3/config/mips/sni-gas.h	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/mips/sni-gas.h	Tue Sep  9 07:01:21 1997
***************
*** 0 ****
--- 1,43 ----
+ #include "mips/sni-svr4.h"
+ 
+ /* Enable debugging.  */
+ #define DBX_DEBUGGING_INFO
+ #define SDB_DEBUGGING_INFO
+ #define MIPS_DEBUGGING_INFO
+ 
+ #define DWARF_DEBUGGING_INFO
+ #undef PREFERRED_DEBUGGING_TYPE
+ #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
+ 
+ /* We need to use .esize and .etype instead of .size and .type to
+    avoid conflicting with ELF directives.  These are only recognized
+    by gas, anyhow, not the native assembler.  */
+ #undef PUT_SDB_SIZE
+ #define PUT_SDB_SIZE(a)                                       \
+ do {                                                  \
+   extern FILE *asm_out_text_file;                     \
+   fprintf (asm_out_text_file, "\t.esize\t%d;", (a));  \
+ } while (0)
+ 
+ #undef PUT_SDB_TYPE
+ #define PUT_SDB_TYPE(a)                                       \
+ do {                                                  \
+   extern FILE *asm_out_text_file;                     \
+   fprintf (asm_out_text_file, "\t.etype\t0x%x;", (a));        \
+ } while (0)
+ 
+ 
+ /* This is how to equate one symbol to another symbol.  The syntax used is
+    `SYM1=SYM2'.  Note that this is different from the way equates are done
+    with most svr4 assemblers, where the syntax is `.set SYM1,SYM2'.  */
+ 
+ #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)				\
+  do {	fprintf ((FILE), "\t");						\
+ 	assemble_name (FILE, LABEL1);					\
+ 	fprintf (FILE, " = ");						\
+ 	assemble_name (FILE, LABEL2);					\
+ 	fprintf (FILE, "\n");						\
+   } while (0)
+ 
+ 
+ 
diff -rcp2N gcc-2.7.2.3/config/mips/sni-svr4.h gcc-2.7.2.3.f.2/config/mips/sni-svr4.h
*** gcc-2.7.2.3/config/mips/sni-svr4.h	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/mips/sni-svr4.h	Tue Sep  9 07:01:21 1997
***************
*** 0 ****
--- 1,103 ----
+ /* Definitions of target machine for GNU compiler.  SNI SINIX version.
+    Copyright (C) 1996 Free Software Foundation, Inc.
+    Contributed by Marco Walther (Marco.Walther@mch.sni.de).
+ 
+ This file is part of GNU CC.
+ 
+ GNU CC 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, or (at your option)
+ any later version.
+ 
+ GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+ 
+ #define MIPS_SVR4
+ 
+ #define CPP_PREDEFINES "\
+ -Dmips -Dunix -Dhost_mips -DMIPSEB -DR3000 -DSYSTYPE_SVR4 \
+ -D_mips -D_unix -D_host_mips -D_MIPSEB -D_R3000 -D_SYSTYPE_SVR4 \
+ -Asystem(unix) -Asystem(svr4) -Acpu(mips) -Amachine(mips)"
+ 
+ #define CPP_SPEC "\
+ %{.cc:	-D__LANGUAGE_C_PLUS_PLUS -D_LANGUAGE_C_PLUS_PLUS} \
+ %{.cxx:	-D__LANGUAGE_C_PLUS_PLUS -D_LANGUAGE_C_PLUS_PLUS} \
+ %{.C:	-D__LANGUAGE_C_PLUS_PLUS -D_LANGUAGE_C_PLUS_PLUS} \
+ %{.m:	-D__LANGUAGE_OBJECTIVE_C -D_LANGUAGE_OBJECTIVE_C} \
+ %{.S:	-D__LANGUAGE_ASSEMBLY -D_LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \
+ %{.s:	-D__LANGUAGE_ASSEMBLY -D_LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \
+ %{!.S:%{!.s:	-D__LANGUAGE_C -D_LANGUAGE_C %{!ansi:-DLANGUAGE_C}}} \
+ -D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int"
+ 
+ #define LINK_SPEC "\
+ %{G*} \
+ %{!mgas: \
+ 	%{dy} %{dn}}"
+ 		    
+ #define LIB_SPEC "\
+ 	%{p:-lprof1} \
+ 	%{!p:%{pg:-lprof1} \
+ 	     %{!pg:-L/usr/ccs/lib/ -lc /usr/ccs/lib/crtn.o%s}}"
+ 
+ #define STARTFILE_SPEC "\
+ 	%{pg:gcrt0.o%s} \
+ 	%{!pg:%{p:mcrt0.o%s} \
+ 	       %{!p:/usr/ccs/lib/crt1.o /usr/ccs/lib/crti.o /usr/ccs/lib/values-Xt.o%s}}"
+ 
+ /* Mips System V.4 doesn't have a getpagesize() function needed by the
+    trampoline code, so use the POSIX sysconf function to get it.
+    This is only done when compiling the trampoline code.  */
+ 
+ #ifdef  L_trampoline
+ #include <unistd.h>
+ 
+ #define getpagesize()	sysconf(_SC_PAGE_SIZE)
+ #endif /*  L_trampoline */
+ 
+ /* Use atexit for static constructors/destructors, instead of defining
+    our own exit function.  */
+ #define HAVE_ATEXIT
+ 
+ /* Generate calls to memcpy, etc., not bcopy, etc.  */
+ #define TARGET_MEM_FUNCTIONS
+ 
+ #define OBJECT_FORMAT_ELF
+ 
+ #define	TARGET_DEFAULT	MASK_ABICALLS
+ #define ABICALLS_ASM_OP ".option pic2"
+ 
+ #define MACHINE_TYPE "SNI running SINIX 5.42"
+ 
+ #define MIPS_DEFAULT_GVALUE	0
+ 
+ #define NM_FLAGS	"-p"
+ 
+ /* wir haben ein Problem, wenn in einem Assembler-File keine .text-section
+    erzeugt wird. Dann landen diese Pseudo-Labels in irgendeiner anderen
+    section, z.B. .reginfo. Das macht den ld sehr ungluecklich. */
+ 
+ #define ASM_IDENTIFY_GCC(mw_stream) \
+ 	fprintf(mw_stream, "\t.ident \"gcc2_compiled.\"\n");
+ 
+ #define ASM_IDENTIFY_LANGUAGE(STREAM)
+ 
+ #define ASM_LONG	".word\t"
+ #define ASM_GLOBAL	".rdata\n\t\t.globl\t"
+ 
+ #include "mips/mips.h"
+ 
+ /* We do not want to run mips-tfile!  */
+ #undef ASM_FINAL_SPEC
+ 
+ #undef OBJECT_FORMAT_COFF
+ 
+ /* We don't support debugging info for now. */
+ #undef DBX_DEBUGGING_INFO
+ #undef SDB_DEBUGGING_INFO
+ #undef MIPS_DEBUGGING_INFO
diff -rcp2N gcc-2.7.2.3/config/mips/x-sni-svr4 gcc-2.7.2.3.f.2/config/mips/x-sni-svr4
*** gcc-2.7.2.3/config/mips/x-sni-svr4	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/mips/x-sni-svr4	Tue Sep  9 07:01:21 1997
***************
*** 0 ****
--- 1,18 ----
+ # Define CC and OLDCC as the same, so that the tests:
+ #	if [ x"$(OLDCC)" = x"$(CC)" ] ...
+ #
+ # will succeed (if OLDCC != CC, it is assumed that GCC is
+ # being used in secondary stage builds).
+ # -Olimit is so the user can use -O2.  Down with fixed
+ # size tables!
+ 
+ CC		= $(OLDCC)
+ OPT		=
+ OLDCC		= cc -Olimit 3000 $(OPT)
+ 
+ X_CFLAGS	= -DNO_SYS_SIGLIST
+ 
+ # Show we need to use the C version of ALLOCA
+ # The SVR3 configurations have it, but the SVR4 configurations don't.
+ # For now, just try using it for all SVR* configurations.
+ ALLOCA		= alloca.o
diff -rcp2N gcc-2.7.2.3/config/msdos/configur.bat gcc-2.7.2.3.f.2/config/msdos/configur.bat
*** gcc-2.7.2.3/config/msdos/configur.bat	Mon Aug 28 09:55:47 1995
--- gcc-2.7.2.3.f.2/config/msdos/configur.bat	Tue Sep  9 07:01:21 1997
*************** sed -f config/msdos/top.sed Makefile.in 
*** 18,21 ****
--- 18,27 ----
  set LANG=
  
+ if not exist ada\make-lang.in goto no_ada
+ sed -f config/msdos/top.sed ada\make-lang.in >> Makefile
+ sed -f config/msdos/top.sed ada\makefile.in > ada\Makefile
+ set LANG=%LANG% ada.&	
+ :no_ada
+ 
  if not exist cp\make-lang.in goto no_cp
  sed -f config/msdos/top.sed cp\make-lang.in >> Makefile
diff -rcp2N gcc-2.7.2.3/config/pa/pa.c gcc-2.7.2.3.f.2/config/pa/pa.c
*** gcc-2.7.2.3/config/pa/pa.c	Sun Oct 22 11:45:20 1995
--- gcc-2.7.2.3.f.2/config/pa/pa.c	Tue Sep  9 07:01:22 1997
*************** output_move_double (operands)
*** 1344,1369 ****
       do them in the other order.
  
!      RMS says "This happens only for registers;
!      such overlap can't happen in memory unless the user explicitly
!      sets it up, and that is an undefined circumstance."
! 
!      but it happens on the HP-PA when loading parameter registers,
!      so I am going to define that circumstance, and make it work
!      as expected.  */
  
!   if (optype0 == REGOP && (optype1 == MEMOP || optype1 == OFFSOP)
! 	   && reg_overlap_mentioned_p (operands[0], XEXP (operands[1], 0)))
      {
-       /* XXX THIS PROBABLY DOESN'T WORK.  */
        /* Do the late half first.  */
        if (addreg1)
  	output_asm_insn ("ldo 4(%0),%0", &addreg1);
        output_asm_insn (singlemove_string (latehalf), latehalf);
        if (addreg1)
  	output_asm_insn ("ldo -4(%0),%0", &addreg1);
-       /* Then clobber.  */
        return singlemove_string (operands);
      }
  
    if (optype0 == REGOP && optype1 == REGOP
        && REGNO (operands[0]) == REGNO (operands[1]) + 1)
--- 1344,1377 ----
       do them in the other order.
  
!      This can happen in two cases:
  
! 	mem -> register where the first half of the destination register
!  	is the same register used in the memory's address.  Reload
! 	can create such insns.
! 
! 	mem in this case will be either register indirect or register
! 	indirect plus a valid offset. 
! 
! 	register -> register move where REGNO(dst) == REGNO(src + 1)
! 	someone (Tim/Tege?) claimed this can happen for parameter loads. 
! 
!      Handle mem -> register case first.  */
!   if (optype0 == REGOP
!       && (optype1 == MEMOP || optype1 == OFFSOP)
!       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
! 			    operands[1], 0))
      {
        /* Do the late half first.  */
        if (addreg1)
  	output_asm_insn ("ldo 4(%0),%0", &addreg1);
        output_asm_insn (singlemove_string (latehalf), latehalf);
+ 
+       /* Then clobber.  */
        if (addreg1)
  	output_asm_insn ("ldo -4(%0),%0", &addreg1);
        return singlemove_string (operands);
      }
  
+   /* Now handle register -> register case.  */
    if (optype0 == REGOP && optype1 == REGOP
        && REGNO (operands[0]) == REGNO (operands[1]) + 1)
diff -rcp2N gcc-2.7.2.3/config/pa/pa.md gcc-2.7.2.3.f.2/config/pa/pa.md
*** gcc-2.7.2.3/config/pa/pa.md	Mon Aug 14 13:00:49 1995
--- gcc-2.7.2.3.f.2/config/pa/pa.md	Tue Sep  9 07:01:22 1997
***************
*** 1828,1832 ****
  (define_insn ""
    [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand"
! 			  "=f,*r,Q,?o,?Q,f,*&r,*&r")
  	(match_operand:DF 1 "reg_or_0_or_nonsymb_mem_operand"
  			  "fG,*rG,f,*r,*r,Q,o,Q"))]
--- 1828,1832 ----
  (define_insn ""
    [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand"
! 			  "=f,*r,Q,?o,?Q,f,*r,*r")
  	(match_operand:DF 1 "reg_or_0_or_nonsymb_mem_operand"
  			  "fG,*rG,f,*r,*r,Q,o,Q"))]
***************
*** 1846,1850 ****
  (define_insn ""
    [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,?o,?Q,&r,&r")
  	(match_operand:DF 1 "reg_or_0_or_nonsymb_mem_operand"
  			  "rG,r,r,o,Q"))]
--- 1846,1850 ----
  (define_insn ""
    [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,?o,?Q,r,r")
  	(match_operand:DF 1 "reg_or_0_or_nonsymb_mem_operand"
  			  "rG,r,r,o,Q"))]
***************
*** 2019,2023 ****
  (define_insn ""
    [(set (match_operand:DI 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,o,Q,&r,&r,&r,f,f,*T")
  	(match_operand:DI 1 "general_operand"
  			  "rM,r,r,o,Q,i,fM,*T,f"))]
--- 2019,2023 ----
  (define_insn ""
    [(set (match_operand:DI 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,o,Q,r,r,r,f,f,*T")
  	(match_operand:DI 1 "general_operand"
  			  "rM,r,r,o,Q,i,fM,*T,f"))]
***************
*** 2037,2041 ****
  (define_insn ""
    [(set (match_operand:DI 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,o,Q,&r,&r,&r")
  	(match_operand:DI 1 "general_operand"
  			  "rM,r,r,o,Q,i"))]
--- 2037,2041 ----
  (define_insn ""
    [(set (match_operand:DI 0 "reg_or_nonsymb_mem_operand"
! 			  "=r,o,Q,r,r,r")
  	(match_operand:DI 1 "general_operand"
  			  "rM,r,r,o,Q,i"))]
diff -rcp2N gcc-2.7.2.3/config/rs6000/rs6000.c gcc-2.7.2.3.f.2/config/rs6000/rs6000.c
*** gcc-2.7.2.3/config/rs6000/rs6000.c	Sat Jun 29 16:26:26 1996
--- gcc-2.7.2.3.f.2/config/rs6000/rs6000.c	Tue Sep  9 07:01:23 1997
*************** input_operand (op, mode)
*** 724,730 ****
      return 1;
  
!   /* For HImode and QImode, any constant is valid. */
!   if ((mode == HImode || mode == QImode)
!       && GET_CODE (op) == CONST_INT)
      return 1;
  
--- 724,729 ----
      return 1;
  
!   /* For integer modes, any constant is ok.  */
!   if (GET_CODE (op) == CONST_INT)
      return 1;
  
*************** svr4_traceback (file, name, decl)
*** 2611,2614 ****
--- 2610,2682 ----
  #endif /* USING_SVR4_H */
  
+ /* Write out an instruction to load the TOC_TABLE address into register 30.
+    This is only needed when TARGET_TOC, TARGET_MINIMAL_TOC, and there is
+    a constant pool.  */
+ 
+ void
+ rs6000_output_load_toc_table (file)
+      FILE *file;
+ {
+   char buf[256];
+ 
+ #ifdef USING_SVR4_H
+   if (TARGET_RELOCATABLE)
+     {
+       ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
+       fprintf (file, "\tbl ");
+       assemble_name (file, buf);
+       fprintf (file, "\n");
+ 
+       ASM_OUTPUT_INTERNAL_LABEL (file, "LCF", rs6000_pic_labelno);
+       fprintf (file, "\tmflr %s\n", reg_names[30]);
+ 
+       if (TARGET_POWERPC64)
+ 	fprintf (file, "\tld");
+       else if (TARGET_NEW_MNEMONICS)
+ 	fprintf (file, "\tlwz");
+       else
+ 	fprintf (file, "\tl");
+ 
+       fprintf (file, " %s,(", reg_names[0]);
+       ASM_GENERATE_INTERNAL_LABEL (buf, "LCL", rs6000_pic_labelno);
+       assemble_name (file, buf);
+       fprintf (file, "-");
+       ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
+       assemble_name (file, buf);
+       fprintf (file, ")(%s)\n", reg_names[30]);
+       asm_fprintf (file, "\t{cax|add} %s,%s,%s\n",
+ 		   reg_names[30], reg_names[0], reg_names[30]);
+       rs6000_pic_labelno++;
+     }
+   else if (!TARGET_64BIT)
+     {
+       ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 1);
+       asm_fprintf (file, "\t{cau|addis} %s,%s,", reg_names[30], reg_names[0]);
+       assemble_name (file, buf);
+       asm_fprintf (file, "@ha\n");
+       if (TARGET_NEW_MNEMONICS)
+ 	{
+ 	  asm_fprintf (file, "\taddi %s,%s,", reg_names[30], reg_names[30]);
+ 	  assemble_name (file, buf);
+ 	  asm_fprintf (file, "@l\n");
+ 	}
+       else
+ 	{
+ 	  asm_fprintf (file, "\tcal %s,", reg_names[30]);
+ 	  assemble_name (file, buf);
+ 	  asm_fprintf (file, "@l(%s)\n", reg_names[30]);
+ 	}
+     }
+   else
+     abort ();
+ 
+ #else	/* !USING_SVR4_H */
+   ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 0);
+   asm_fprintf (file, "\t{l|lwz} %s,", reg_names[30]);
+   assemble_name (file, buf);
+   asm_fprintf (file, "(%s)\n", reg_names[2]);
+ #endif /* USING_SVR4_H */
+ }
+ 
  /* Write function prologue.  */
  void
*************** output_prolog (file, size)
*** 2770,2834 ****
       TOC_TABLE address into register 30.  */
    if (TARGET_TOC && TARGET_MINIMAL_TOC && get_pool_size () != 0)
!     {
!       char buf[256];
! 
! #ifdef USING_SVR4_H
!       if (TARGET_RELOCATABLE)
! 	{
! 	  ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
! 	  fprintf (file, "\tbl ");
! 	  assemble_name (file, buf);
! 	  fprintf (file, "\n");
! 
! 	  ASM_OUTPUT_INTERNAL_LABEL (file, "LCF", rs6000_pic_labelno);
! 	  fprintf (file, "\tmflr %s\n", reg_names[30]);
! 
! 	  if (TARGET_POWERPC64)
! 	    fprintf (file, "\tld");
! 	  else if (TARGET_NEW_MNEMONICS)
! 	    fprintf (file, "\tlwz");
! 	  else
! 	    fprintf (file, "\tl");
! 
! 	  fprintf (file, " %s,(", reg_names[0]);
! 	  ASM_GENERATE_INTERNAL_LABEL (buf, "LCL", rs6000_pic_labelno);
! 	  assemble_name (file, buf);
! 	  fprintf (file, "-");
! 	  ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
! 	  assemble_name (file, buf);
! 	  fprintf (file, ")(%s)\n", reg_names[30]);
! 	  asm_fprintf (file, "\t{cax|add} %s,%s,%s\n",
! 		       reg_names[30], reg_names[0], reg_names[30]);
! 	  rs6000_pic_labelno++;
! 	}
!       else if (!TARGET_64BIT)
! 	{
! 	  ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 1);
! 	  asm_fprintf (file, "\t{cau|addis} %s,%s,", reg_names[30], reg_names[0]);
! 	  assemble_name (file, buf);
! 	  asm_fprintf (file, "@ha\n");
! 	  if (TARGET_NEW_MNEMONICS)
! 	    {
! 	      asm_fprintf (file, "\taddi %s,%s,", reg_names[30], reg_names[30]);
! 	      assemble_name (file, buf);
! 	      asm_fprintf (file, "@l\n");
! 	    }
! 	  else
! 	    {
! 	      asm_fprintf (file, "\tcal %s,", reg_names[30]);
! 	      assemble_name (file, buf);
! 	      asm_fprintf (file, "@l(%s)\n", reg_names[30]);
! 	    }
! 	}
!       else
! 	abort ();
! 
! #else	/* !USING_SVR4_H */
!       ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 0);
!       asm_fprintf (file, "\t{l|lwz} %s,", reg_names[30]);
!       assemble_name (file, buf);
!       asm_fprintf (file, "(%s)\n", reg_names[2]);
! #endif /* USING_SVR4_H */
!     }
  }
  
--- 2838,2842 ----
       TOC_TABLE address into register 30.  */
    if (TARGET_TOC && TARGET_MINIMAL_TOC && get_pool_size () != 0)
!     rs6000_output_load_toc_table (file);
  }
  
diff -rcp2N gcc-2.7.2.3/config/rs6000/rs6000.md gcc-2.7.2.3.f.2/config/rs6000/rs6000.md
*** gcc-2.7.2.3/config/rs6000/rs6000.md	Sat Jun 29 16:27:24 1996
--- gcc-2.7.2.3.f.2/config/rs6000/rs6000.md	Tue Sep  9 07:01:23 1997
***************
*** 4420,4423 ****
--- 4420,4424 ----
  	}
  
+       emit_insn (gen_rtx (CLOBBER, VOIDmode, operands[0]));
        emit_move_insn (gen_rtx (SUBREG, SImode, operands[0], WORDS_BIG_ENDIAN),
  		      GEN_INT (low));
***************
*** 5409,5412 ****
--- 5410,5425 ----
    DONE;
  }")
+ 
+ ;; If we have -mmiminal-toc, we need to reload r30 after a nonlocal goto.
+ 
+ (define_insn "nonlocal_goto_receiver"
+   [(unspec_volatile [(const_int 0)] 1)]
+   "TARGET_TOC && TARGET_MINIMAL_TOC && get_pool_size () != 0"
+   "*
+ {
+   rs6000_output_load_toc_table (asm_out_file);
+   return \"\";
+ }"
+   [(set_attr "type" "load")])
  
  ;; A function pointer is a pointer to a data area whose first word contains
diff -rcp2N gcc-2.7.2.3/config/sparc/sol2.h gcc-2.7.2.3.f.2/config/sparc/sol2.h
*** gcc-2.7.2.3/config/sparc/sol2.h	Sat Aug 19 21:36:45 1995
--- gcc-2.7.2.3.f.2/config/sparc/sol2.h	Tue Sep  9 07:01:23 1997
*************** do {									\
*** 166,168 ****
  /* Define for support of TFmode long double and REAL_ARITHMETIC.
     Sparc ABI says that long double is 4 words.  */
! #define LONG_DOUBLE_TYPE_SIZE 128
--- 166,168 ----
  /* Define for support of TFmode long double and REAL_ARITHMETIC.
     Sparc ABI says that long double is 4 words.  */
! #define LONG_DOUBLE_TYPE_SIZE 64
diff -rcp2N gcc-2.7.2.3/config/sparc/sparc.c gcc-2.7.2.3.f.2/config/sparc/sparc.c
*** gcc-2.7.2.3/config/sparc/sparc.c	Tue Sep 12 22:32:24 1995
--- gcc-2.7.2.3.f.2/config/sparc/sparc.c	Tue Sep  9 07:01:24 1997
*************** Boston, MA 02111-1307, USA.  */
*** 40,46 ****
  /* 1 if the caller has placed an "unimp" insn immediately after the call.
     This is used in v8 code when calling a function that returns a structure.
!    v9 doesn't have this.  */
  
! #define SKIP_CALLERS_UNIMP_P (!TARGET_V9 && current_function_returns_struct)
  
  /* Global variables for machine-dependent things.  */
--- 40,51 ----
  /* 1 if the caller has placed an "unimp" insn immediately after the call.
     This is used in v8 code when calling a function that returns a structure.
!    v9 doesn't have this.  Be careful to have this test be the same as that
!    used on the call.  */
  
! #define SKIP_CALLERS_UNIMP_P  \
! (!TARGET_V9 && current_function_returns_struct			\
!  && ! integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl)))	\
!  && (TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))	\
!      == INTEGER_CST))
  
  /* Global variables for machine-dependent things.  */
diff -rcp2N gcc-2.7.2.3/config/sparc/sparc.h gcc-2.7.2.3.f.2/config/sparc/sparc.h
*** gcc-2.7.2.3/config/sparc/sparc.h	Sat Jun 29 16:25:54 1996
--- gcc-2.7.2.3.f.2/config/sparc/sparc.h	Tue Sep  9 07:01:25 1997
*************** extern int leaf_function;
*** 1526,1533 ****
  
  /* Output assembler code to FILE to increment profiler label # LABELNO
!    for profiling a function entry.  */
  
  #define FUNCTION_PROFILER(FILE, LABELNO)  			\
    do {								\
      fputs ("\tsethi %hi(", (FILE));				\
      ASM_OUTPUT_INTERNAL_LABELREF (FILE, "LP", LABELNO);		\
--- 1526,1540 ----
  
  /* Output assembler code to FILE to increment profiler label # LABELNO
!    for profiling a function entry.
! 
!    32 bit sparc uses %g2 as the STATIC_CHAIN_REGNUM which gets clobbered
!    during profiling so we need to save/restore it around the call to mcount.
!    We're guaranteed that a save has just been done, and we use the space
!    allocated for intreg/fpreg value passing.  */
  
  #define FUNCTION_PROFILER(FILE, LABELNO)  			\
    do {								\
+     if (! TARGET_V9)					\
+       fputs ("\tst %g2,[%fp-4]\n", FILE);			\
      fputs ("\tsethi %hi(", (FILE));				\
      ASM_OUTPUT_INTERNAL_LABELREF (FILE, "LP", LABELNO);		\
*************** extern int leaf_function;
*** 1539,1542 ****
--- 1546,1551 ----
      ASM_OUTPUT_INTERNAL_LABELREF (FILE, "LP", LABELNO);		\
      fputs ("),%o0,%o0\n", (FILE));				\
+     if (! TARGET_V9)					\
+       fputs ("\tld [%fp-4],%g2\n", FILE);			\
    } while (0)
  
diff -rcp2N gcc-2.7.2.3/config/sparc/sparc.md gcc-2.7.2.3.f.2/config/sparc/sparc.md
*** gcc-2.7.2.3/config/sparc/sparc.md	Tue Sep 12 22:57:35 1995
--- gcc-2.7.2.3.f.2/config/sparc/sparc.md	Tue Sep  9 07:01:26 1997
***************
*** 4799,4803 ****
      abort ();
  
!  if (GET_CODE (XEXP (operands[0], 0)) == LABEL_REF)
      {
        /* This is really a PIC sequence.  We want to represent
--- 4799,4803 ----
      abort ();
  
!   if (GET_CODE (XEXP (operands[0], 0)) == LABEL_REF)
      {
        /* This is really a PIC sequence.  We want to represent
***************
*** 4809,4824 ****
  
        if (! TARGET_V9 && INTVAL (operands[3]) != 0)
! 	emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3,
! 				 gen_rtx (SET, VOIDmode, pc_rtx,
! 					  XEXP (operands[0], 0)),
! 				 operands[3],
! 				 gen_rtx (CLOBBER, VOIDmode,
! 					  gen_rtx (REG, Pmode, 15)))));
        else
! 	emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
! 				 gen_rtx (SET, VOIDmode, pc_rtx,
! 					  XEXP (operands[0], 0)),
! 				 gen_rtx (CLOBBER, VOIDmode,
! 					  gen_rtx (REG, Pmode, 15)))));
        goto finish_call;
      }
--- 4809,4828 ----
  
        if (! TARGET_V9 && INTVAL (operands[3]) != 0)
! 	emit_jump_insn
! 	  (gen_rtx (PARALLEL, VOIDmode,
! 		    gen_rtvec (3,
! 			       gen_rtx (SET, VOIDmode, pc_rtx,
! 					XEXP (operands[0], 0)),
! 			       GEN_INT (INTVAL (operands[3]) & 0xfff),
! 			       gen_rtx (CLOBBER, VOIDmode,
! 					gen_rtx (REG, Pmode, 15)))));
        else
! 	emit_jump_insn
! 	  (gen_rtx (PARALLEL, VOIDmode,
! 		    gen_rtvec (2,
! 			       gen_rtx (SET, VOIDmode, pc_rtx,
! 					XEXP (operands[0], 0)),
! 			       gen_rtx (CLOBBER, VOIDmode,
! 					gen_rtx (REG, Pmode, 15)))));
        goto finish_call;
      }
***************
*** 4839,4852 ****
  
    if (! TARGET_V9 && INTVAL (operands[3]) != 0)
!     emit_call_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3,
! 			     gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx),
! 			     operands[3],
! 			     gen_rtx (CLOBBER, VOIDmode,
! 					       gen_rtx (REG, Pmode, 15)))));
    else
!     emit_call_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (2,
! 			     gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx),
! 			     gen_rtx (CLOBBER, VOIDmode,
! 					       gen_rtx (REG, Pmode, 15)))));
  
   finish_call:
--- 4843,4858 ----
  
    if (! TARGET_V9 && INTVAL (operands[3]) != 0)
!     emit_call_insn
!       (gen_rtx (PARALLEL, VOIDmode,
! 		gen_rtvec (3, gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx),
! 			   GEN_INT (INTVAL (operands[3]) & 0xfff),
! 			   gen_rtx (CLOBBER, VOIDmode,
! 				    gen_rtx (REG, Pmode, 15)))));
    else
!     emit_call_insn
!       (gen_rtx (PARALLEL, VOIDmode,
! 		gen_rtvec (2, gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx),
! 			   gen_rtx (CLOBBER, VOIDmode,
! 				    gen_rtx (REG, Pmode, 15)))));
  
   finish_call:
***************
*** 4911,4915 ****
     (clobber (reg:SI 15))]
    ;;- Do not use operand 1 for most machines.
!   "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) > 0"
    "call %a0,%1\;nop\;unimp %2"
    [(set_attr "type" "call_no_delay_slot")])
--- 4917,4921 ----
     (clobber (reg:SI 15))]
    ;;- Do not use operand 1 for most machines.
!   "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 0"
    "call %a0,%1\;nop\;unimp %2"
    [(set_attr "type" "call_no_delay_slot")])
***************
*** 4923,4927 ****
     (clobber (reg:SI 15))]
    ;;- Do not use operand 1 for most machines.
!   "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) > 0"
    "call %a0,%1\;nop\;unimp %2"
    [(set_attr "type" "call_no_delay_slot")])
--- 4929,4933 ----
     (clobber (reg:SI 15))]
    ;;- Do not use operand 1 for most machines.
!   "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) >= 0"
    "call %a0,%1\;nop\;unimp %2"
    [(set_attr "type" "call_no_delay_slot")])
***************
*** 5178,5184 ****
    emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
    emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
-   emit_insn (gen_rtx (USE, VOIDmode, gen_rtx (REG, Pmode, 8)));
    /* Return, restoring reg window and jumping to goto handler.  */
    emit_insn (gen_goto_handler_and_restore ());
    DONE;
  }")
--- 5184,5190 ----
    emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
    emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
    /* Return, restoring reg window and jumping to goto handler.  */
    emit_insn (gen_goto_handler_and_restore ());
+   emit_barrier ();
    DONE;
  }")
***************
*** 5192,5200 ****
  
  (define_insn "goto_handler_and_restore"
!   [(unspec_volatile [(const_int 0)] 2)]
    ""
    "jmp %%o0+0\;restore"
    [(set_attr "type" "misc")
     (set_attr "length" "2")])
  
  ;; Special pattern for the FLUSH instruction.
--- 5198,5237 ----
  
  (define_insn "goto_handler_and_restore"
!   [(unspec_volatile [(const_int 0)] 2)
!    (use (reg:SI 8))]
    ""
    "jmp %%o0+0\;restore"
    [(set_attr "type" "misc")
     (set_attr "length" "2")])
+ 
+ ;; Pattern for use after a setjmp to store FP and the return register
+ ;; into the stack area.
+ 
+ (define_expand "setjmp"
+   [(const_int 0)]
+   ""
+   "
+ {
+   if (TARGET_V9)
+     emit_insn (gen_setjmp_64 ());
+   else
+     emit_insn (gen_setjmp_32 ());
+ 
+   DONE;
+ }")
+ 
+ (define_expand "setjmp_32"
+   [(set (mem:SI (plus:SI (reg:SI 14) (const_int 56))) (match_dup 0))
+    (set (mem:SI (plus:SI (reg:SI 14) (const_int 60))) (reg:SI 31))]
+   ""
+   "
+ { operands[0] = frame_pointer_rtx; }")
+ 
+ (define_expand "setjmp_64"
+   [(set (mem:DI (plus:DI (reg:DI 14) (const_int 112))) (match_dup 0))
+    (set (mem:DI (plus:DI (reg:DI 14) (const_int 120))) (reg:DI 31))]
+   ""
+   "
+ { operands[0] = frame_pointer_rtx; }")
  
  ;; Special pattern for the FLUSH instruction.
diff -rcp2N gcc-2.7.2.3/config/x-linux gcc-2.7.2.3.f.2/config/x-linux
*** gcc-2.7.2.3/config/x-linux	Tue Mar 28 12:43:37 1995
--- gcc-2.7.2.3.f.2/config/x-linux	Tue Sep  9 07:01:26 1997
*************** BOOT_CFLAGS = -O $(CFLAGS) -Iinclude
*** 13,14 ****
--- 13,17 ----
  # Don't run fixproto
  STMP_FIXPROTO =
+ 
+ # Don't install "assert.h" in gcc. We use the one in glibc.
+ INSTALL_ASSERT_H =
diff -rcp2N gcc-2.7.2.3/config/x-linux-aout gcc-2.7.2.3.f.2/config/x-linux-aout
*** gcc-2.7.2.3/config/x-linux-aout	Thu Jan  1 00:00:00 1970
--- gcc-2.7.2.3.f.2/config/x-linux-aout	Tue Sep  9 07:01:26 1997
***************
*** 0 ****
--- 1,14 ----
+ # It is defined in config/xm-linux.h.
+ # X_CFLAGS = -DPOSIX
+ 
+ # The following is needed when compiling stages 2 and 3 because gcc's
+ # limits.h must be picked up before /usr/include/limits.h.  This is because
+ # each does an #include_next of the other if the other hasn't been included.
+ # /usr/include/limits.h loses if it gets found first because /usr/include is
+ # at the end of the search order.  When a new version of gcc is released,
+ # gcc's limits.h hasn't been installed yet and hence isn't found.
+ 
+ BOOT_CFLAGS = -O $(CFLAGS) -Iinclude
+ 
+ # Don't run fixproto
+ STMP_FIXPROTO =
diff -rcp2N gcc-2.7.2.3/config.guess gcc-2.7.2.3.f.2/config.guess
*** gcc-2.7.2.3/config.guess	Tue Jun 24 18:42:50 1997
--- gcc-2.7.2.3.f.2/config.guess	Tue Sep  9 07:01:26 1997
*************** trap 'rm -f dummy.c dummy.o dummy; exit 
*** 52,63 ****
  
  case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
-     alpha:OSF1:V*:*)
- 	# After 1.2, OSF1 uses "V1.3" for uname -r.
- 	echo alpha-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^V//'`
- 	exit 0 ;;
      alpha:OSF1:*:*)
  	# 1.2 uses "1.2" for uname -r.
! 	echo alpha-dec-osf${UNAME_RELEASE}
!         exit 0 ;;
      21064:Windows_NT:50:3)
  	echo alpha-dec-winnt3.5
--- 52,62 ----
  
  case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
      alpha:OSF1:*:*)
+ 	# A Vn.n version is a released version.
+ 	# A Tn.n version is a released field test version.
+ 	# A Xn.n version is an unreleased experimental baselevel.
  	# 1.2 uses "1.2" for uname -r.
! 	echo alpha-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//'`
! 	exit 0 ;;
      21064:Windows_NT:50:3)
  	echo alpha-dec-winnt3.5
*************** case "${UNAME_MACHINE}:${UNAME_SYSTEM}:$
*** 154,161 ****
  	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
  	exit 0 ;;
!    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
  	echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
  	exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
!     i[34]86:AIX:*:*)
  	echo i386-ibm-aix
  	exit 0 ;;
--- 153,160 ----
  	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
  	exit 0 ;;
!     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
  	echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
  	exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
!     i?86:AIX:*:*)
  	echo i386-ibm-aix
  	exit 0 ;;
*************** EOF
*** 220,224 ****
  	    9000/31? )            HP_ARCH=m68000 ;;
  	    9000/[34]?? )         HP_ARCH=m68k ;;
! 	    9000/7?? | 9000/8?[79] ) HP_ARCH=hppa1.1 ;;
  	    9000/8?? )            HP_ARCH=hppa1.0 ;;
  	esac
--- 219,223 ----
  	    9000/31? )            HP_ARCH=m68000 ;;
  	    9000/[34]?? )         HP_ARCH=m68k ;;
! 	    9000/7?? | 9000/8?[1679] ) HP_ARCH=hppa1.1 ;;
  	    9000/8?? )            HP_ARCH=hppa1.0 ;;
  	esac
*************** EOF
*** 304,308 ****
  	echo m68k-hp-netbsd${UNAME_RELEASE}
  	exit 0 ;;
!     i[34]86:BSD/386:*:* | *:BSD/OS:*:*)
  	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
  	exit 0 ;;
--- 303,307 ----
  	echo m68k-hp-netbsd${UNAME_RELEASE}
  	exit 0 ;;
!     i?86:BSD/386:*:* | *:BSD/OS:*:*)
  	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
  	exit 0 ;;
*************** EOF
*** 314,318 ****
  	exit 0 ;;
      *:GNU:*:*)
! 	echo `echo ${UNAME_MACHINE}|sed -e 's,/.*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
  	exit 0 ;;
      *:Linux:*:*)
--- 313,317 ----
  	exit 0 ;;
      *:GNU:*:*)
! 	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
  	exit 0 ;;
      *:Linux:*:*)
*************** EOF
*** 320,330 ****
  	# first see if it will tell us.
  	ld_help_string=`ld --help 2>&1`
! #	if echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: elf_i[345]86"; then
  #	  echo "${UNAME_MACHINE}-unknown-linux" ; exit 0
! 	if echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: i[345]86linux"; then
  	  echo "${UNAME_MACHINE}-unknown-linuxaout" ; exit 0
! 	elif echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: i[345]86coff"; then
  	  echo "${UNAME_MACHINE}-unknown-linuxcoff" ; exit 0
  	elif test "${UNAME_MACHINE}" = "alpha" ; then
  	  echo alpha-unknown-linux ; exit 0
  	else
--- 319,333 ----
  	# first see if it will tell us.
  	ld_help_string=`ld --help 2>&1`
! #	if echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: elf_i?86"; then
  #	  echo "${UNAME_MACHINE}-unknown-linux" ; exit 0
! 	if echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: i?86linux"; then
  	  echo "${UNAME_MACHINE}-unknown-linuxaout" ; exit 0
! 	elif echo $ld_help_string | grep >/dev/null 2>&1 "supported emulations: i?86coff"; then
  	  echo "${UNAME_MACHINE}-unknown-linuxcoff" ; exit 0
  	elif test "${UNAME_MACHINE}" = "alpha" ; then
+ 	  as_version_string=`as --version 2>&1`
+ 	  if echo $as_version_string | grep >/dev/null 2>&1 " version 2.6 "; then
+ 	    echo alpha-unknown-linuxoldas ; exit 0
+ 	  fi
  	  echo alpha-unknown-linux ; exit 0
  	else
*************** EOF
*** 362,369 ****
  # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
  # are messed up and put the nodename in both sysname and nodename.
!     i[34]86:DYNIX/ptx:4*:*)
  	echo i386-sequent-sysv4
  	exit 0 ;;
!     i[34]86:*:4.*:* | i[34]86:SYSTEM_V:4.*:*)
  	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
  		echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE}
--- 365,372 ----
  # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
  # are messed up and put the nodename in both sysname and nodename.
!     i?86:DYNIX/ptx:4*:*)
  	echo i386-sequent-sysv4
  	exit 0 ;;
!     i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
  	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
  		echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE}
*************** EOF
*** 372,376 ****
  	fi
  	exit 0 ;;
!     i[34]86:*:3.2:*)
  	if test -f /usr/options/cb.name; then
  		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
--- 375,379 ----
  	fi
  	exit 0 ;;
!     i?86:*:3.2:*)
  	if test -f /usr/options/cb.name; then
  		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
*************** EOF
*** 379,382 ****
--- 382,387 ----
  		UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
  		(/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
+ 		(/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) \
+ 			&& UNAME_MACHINE=i586
  		echo ${UNAME_MACHINE}-unknown-sco$UNAME_REL
  	else
*************** EOF
*** 401,405 ****
  	echo m68010-convergent-sysv
  	exit 0 ;;
!     M680[234]0:*:R3V[567]*:*)
  	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
      3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0)
--- 406,410 ----
  	echo m68010-convergent-sysv
  	exit 0 ;;
!     M68*:*:R3V[567]*:*)
  	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
      3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0)
*************** EOF
*** 409,413 ****
          uname -p 2>/dev/null | grep 86 >/dev/null \
            && echo i486-ncr-sysv4 && exit 0 ;;
!     m680[234]0:LynxOS:2.[23]*:*)
  	echo m68k-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
--- 414,418 ----
          uname -p 2>/dev/null | grep 86 >/dev/null \
            && echo i486-ncr-sysv4 && exit 0 ;;
!     m68*:LynxOS:2.*:*)
  	echo m68k-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
*************** EOF
*** 415,425 ****
  	echo m68k-atari-sysv4
  	exit 0 ;;
!     i[34]86:LynxOS:2.[23]*:*)
  	echo i386-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
!     TSUNAMI:LynxOS:2.[23]*:*)
  	echo sparc-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
!     rs6000:LynxOS:2.[23]*:*)
  	echo rs6000-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
--- 420,430 ----
  	echo m68k-atari-sysv4
  	exit 0 ;;
!     i?86:LynxOS:2.*:*)
  	echo i386-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
!     TSUNAMI:LynxOS:2.*:*)
  	echo sparc-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
!     rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
  	echo rs6000-lynx-lynxos${UNAME_RELEASE}
  	exit 0 ;;
*************** main ()
*** 478,482 ****
    int version;
    version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
!   printf ("%s-next-nextstep%s\n", __ARCHITECTURE__,  version==2 ? "2" : "3");
    exit (0);
  #endif
--- 483,487 ----
    int version;
    version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
!   printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
    exit (0);
  #endif
diff -rcp2N gcc-2.7.2.3/configure gcc-2.7.2.3.f.2/configure
*** gcc-2.7.2.3/configure	Wed Aug 13 17:23:24 1997
--- gcc-2.7.2.3.f.2/configure	Tue Sep  9 07:01:26 1997
*************** exec_prefix='$(prefix)'
*** 82,85 ****
--- 82,86 ----
  # The default g++ include directory is $(libdir)/g++-include.
  gxx_include_dir='$(libdir)/g++-include'
+ #gxx_include_dir='$(exec_prefix)/include/g++'
  
  # Default --program-transform-name to nothing.
*************** for machine in $canon_build $canon_host 
*** 548,551 ****
--- 549,578 ----
  		use_collect2=yes
  		;;
+ 	alpha-*-linux*oldas*)
+ 		tm_file=alpha/linux.h
+ 		tmake_file=alpha/t-linux
+ 		xmake_file=alpha/x-linux
+ 		fixincludes=Makefile.in
+ 		xm_file=alpha/xm-linux.h
+ 		gas=yes gnu_ld=yes
+ 		;;
+ 	alpha-*-linux*ecoff*)
+ 		tm_file=alpha/linux.h
+ 		tmake_file=alpha/t-linux
+ 		xmake_file=alpha/x-linux
+ 		fixincludes=Makefile.in
+ 		xm_file=alpha/xm-linux.h
+ 		extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
+ 		gas=yes gnu_ld=yes
+ 		;;
+ 	alpha-*-linux*)
+                 tm_file=alpha/elf.h
+                 tmake_file=alpha/t-linux
+                 xmake_file=alpha/x-linux
+                 fixincludes=Makefile.in
+                 xm_file=alpha/xm-linux.h
+                 extra_parts="crtbegin.o crtbeginS.o crtend.o crtendS.o"
+                 gas=yes gnu_ld=yes
+                 ;;
  	alpha-dec-osf[23456789]*)
  		tm_file=alpha/osf2.h
*************** for machine in $canon_build $canon_host 
*** 982,986 ****
  		cpu_type=i386		# with a.out format using pre BFD linkers
  		xm_file=i386/xm-linux.h
! 		xmake_file=x-linux
  		tm_file=i386/linux-oldld.h
  		fixincludes=Makefile.in # The headers are ok already.
--- 1009,1013 ----
  		cpu_type=i386		# with a.out format using pre BFD linkers
  		xm_file=i386/xm-linux.h
! 		xmake_file=x-linux-aout
  		tm_file=i386/linux-oldld.h
  		fixincludes=Makefile.in # The headers are ok already.
*************** for machine in $canon_build $canon_host 
*** 991,995 ****
  		cpu_type=i386		# with a.out format
  		xm_file=i386/xm-linux.h
! 		xmake_file=x-linux
  		tm_file=i386/linux-aout.h
  		fixincludes=Makefile.in # The headers are ok already.
--- 1018,1022 ----
  		cpu_type=i386		# with a.out format
  		xm_file=i386/xm-linux.h
! 		xmake_file=x-linux-aout
  		tm_file=i386/linux-aout.h
  		fixincludes=Makefile.in # The headers are ok already.
*************** for machine in $canon_build $canon_host 
*** 1663,1666 ****
--- 1690,1714 ----
  		use_collect2=yes
  		;;
+         mips-sni-sysv4)
+ 		if [ x$gas = xyes ]
+ 		then
+ 			if [ x$stabs = xyes ]
+ 			then
+ 				tm_file=mips/iris5gdb.h
+ 			else
+ 				tm_file=mips/sni-gas.h
+ 			fi
+ 		else
+ 			tm_file=mips/sni-svr4.h
+ 		fi
+                 xm_file=mips/xm-sysv.h
+                 xmake_file=mips/x-sni-svr4
+                 tmake_file=mips/t-mips-gas
+                 if [ x$gnu_ld != xyes ]
+                 then
+                         use_collect2=yes
+                 fi
+                 broken_install=yes
+                 ;;
  	mips-sgi-irix5*)		# SGI System V.4., IRIX 5
  		if [ x$gas = xyes ]
*************** MAYBE_TARGET_DEFAULT = -DTARGET_CPU_DEFA
*** 2995,2999 ****
  	rm Makefile.sed
  	echo 's|||' > Makefile.sed
! 	echo "s|^target=.*$|target=${target}|" >> Makefile.sed
  	echo "s|^xmake_file=.*$|xmake_file=${dep_host_xmake_file}|" >> Makefile.sed
  	echo "s|^tmake_file=.*$|tmake_file=${dep_tmake_file}|" >> Makefile.sed
--- 3043,3047 ----
  	rm Makefile.sed
  	echo 's|||' > Makefile.sed
! 	echo "s|^target=.*$|target=${canon_target}|" >> Makefile.sed
  	echo "s|^xmake_file=.*$|xmake_file=${dep_host_xmake_file}|" >> Makefile.sed
  	echo "s|^tmake_file=.*$|tmake_file=${dep_tmake_file}|" >> Makefile.sed
diff -rcp2N gcc-2.7.2.3/cp/ChangeLog gcc-2.7.2.3.f.2/cp/ChangeLog
*** gcc-2.7.2.3/cp/ChangeLog	Tue Aug 19 21:26:09 1997
--- gcc-2.7.2.3.f.2/cp/ChangeLog	Mon Oct 27 08:01:25 1997
***************
*** 1,2 ****
--- 1,12 ----
+ Mon Oct 27 03:00:07 1997  Craig Burley  <burley@gnu.ai.mit.edu>
+ 
+ 	* tree.def (TEMPLATE_CONST_PARM): Word size now 3, not
+ 	2, due to Jul 23 1996 change to gcc/tree.h by Richard
+ 	Kenner to add an `rtl' field to `struct tree_int_cst'.
+ 	Silently depending on the length or layout of an
+ 	internal gcc back-end structure is, of course, a
+ 	kludge, but presumably the g++ people have long since
+ 	abandoned such kludges.
+ 
  Thu Aug 22 23:47:38 1997  H.J. Lu  (hjl@gnu.ai.mit.edu)
  
diff -rcp2N gcc-2.7.2.3/cp/tree.def gcc-2.7.2.3.f.2/cp/tree.def
*** gcc-2.7.2.3/cp/tree.def	Thu Oct 12 02:31:34 1995
--- gcc-2.7.2.3.f.2/cp/tree.def	Mon Oct 27 07:42:11 1997
*************** DEFTREECODE (TEMPLATE_TYPE_PARM, "templa
*** 93,97 ****
  /* Index into a template parameter list.  This parameter must not be a
     type.  */
! DEFTREECODE (TEMPLATE_CONST_PARM, "template_const_parm", "c", 2)
  
  /* For uninstantiated parameterized types.
--- 93,97 ----
  /* Index into a template parameter list.  This parameter must not be a
     type.  */
! DEFTREECODE (TEMPLATE_CONST_PARM, "template_const_parm", "c", 3)
  
  /* For uninstantiated parameterized types.
diff -rcp2N gcc-2.7.2.3/cse.c gcc-2.7.2.3.f.2/cse.c
*** gcc-2.7.2.3/cse.c	Fri Aug  8 15:30:25 1997
--- gcc-2.7.2.3.f.2/cse.c	Tue Sep  9 07:01:27 1997
*************** static struct table_elt *last_jump_equiv
*** 520,544 ****
  static int constant_pool_entries_cost;
  
- /* Bits describing what kind of values in memory must be invalidated
-    for a particular instruction.  If all three bits are zero,
-    no memory refs need to be invalidated.  Each bit is more powerful
-    than the preceding ones, and if a bit is set then the preceding
-    bits are also set.
- 
-    Here is how the bits are set:
-    Pushing onto the stack invalidates only the stack pointer,
-    writing at a fixed address invalidates only variable addresses,
-    writing in a structure element at variable address
-      invalidates all but scalar variables,
-    and writing in anything else at variable address invalidates everything.  */
- 
- struct write_data
- {
-   int sp : 1;			/* Invalidate stack pointer. */
-   int var : 1;			/* Invalidate variable addresses.  */
-   int nonscalar : 1;		/* Invalidate all but scalar variables.  */
-   int all : 1;			/* Invalidate all memory refs.  */
- };
- 
  /* Define maximum length of a branch path.  */
  
--- 520,523 ----
*************** static void merge_equiv_classes PROTO((s
*** 626,632 ****
  				       struct table_elt *));
  static void invalidate		PROTO((rtx, enum machine_mode));
  static void remove_invalid_refs	PROTO((int));
  static void rehash_using_reg	PROTO((rtx));
! static void invalidate_memory	PROTO((struct write_data *));
  static void invalidate_for_call	PROTO((void));
  static rtx use_related_value	PROTO((rtx, struct table_elt *));
--- 605,612 ----
  				       struct table_elt *));
  static void invalidate		PROTO((rtx, enum machine_mode));
+ static int cse_rtx_varies_p	PROTO((rtx));
  static void remove_invalid_refs	PROTO((int));
  static void rehash_using_reg	PROTO((rtx));
! static void invalidate_memory	PROTO((void));
  static void invalidate_for_call	PROTO((void));
  static rtx use_related_value	PROTO((rtx, struct table_elt *));
*************** static void set_nonvarying_address_compo
*** 638,644 ****
  						     HOST_WIDE_INT *));
  static int refers_to_p		PROTO((rtx, rtx));
- static int refers_to_mem_p	PROTO((rtx, rtx, HOST_WIDE_INT,
- 				       HOST_WIDE_INT));
- static int cse_rtx_addr_varies_p PROTO((rtx));
  static rtx canon_reg		PROTO((rtx, rtx));
  static void find_best_addr	PROTO((rtx, rtx *));
--- 618,621 ----
*************** static void record_jump_cond	PROTO((enum
*** 656,661 ****
  				       rtx, rtx, int));
  static void cse_insn		PROTO((rtx, int));
! static void note_mem_written	PROTO((rtx, struct write_data *));
! static void invalidate_from_clobbers PROTO((struct write_data *, rtx));
  static rtx cse_process_notes	PROTO((rtx, rtx));
  static void cse_around_loop	PROTO((rtx));
--- 633,638 ----
  				       rtx, rtx, int));
  static void cse_insn		PROTO((rtx, int));
! static int note_mem_written	PROTO((rtx));
! static void invalidate_from_clobbers PROTO((rtx));
  static rtx cse_process_notes	PROTO((rtx, rtx));
  static void cse_around_loop	PROTO((rtx));
*************** invalidate (x, full_mode)
*** 1512,1517 ****
    register int i;
    register struct table_elt *p;
-   rtx base;
-   HOST_WIDE_INT start, end;
  
    /* If X is a register, dependencies on its contents
--- 1489,1492 ----
*************** invalidate (x, full_mode)
*** 1605,1611 ****
      full_mode = GET_MODE (x);
  
-   set_nonvarying_address_components (XEXP (x, 0), GET_MODE_SIZE (full_mode),
- 				     &base, &start, &end);
- 
    for (i = 0; i < NBUCKETS; i++)
      {
--- 1580,1583 ----
*************** invalidate (x, full_mode)
*** 1614,1618 ****
  	{
  	  next = p->next_same_hash;
! 	  if (refers_to_mem_p (p->exp, base, start, end))
  	    remove_from_table (p, i);
  	}
--- 1586,1594 ----
  	{
  	  next = p->next_same_hash;
! 	  /* Invalidate ASM_OPERANDS which reference memory (this is easier
! 	     than checking all the aliases).  */
! 	  if (p->in_memory
! 	      && (GET_CODE (p->exp) != MEM
! 		  || true_dependence (x, full_mode, p->exp, cse_rtx_varies_p)))
  	    remove_from_table (p, i);
  	}
*************** rehash_using_reg (x)
*** 1695,1722 ****
  }
  
- /* Remove from the hash table all expressions that reference memory,
-    or some of them as specified by *WRITES.  */
- 
- static void
- invalidate_memory (writes)
-      struct write_data *writes;
- {
-   register int i;
-   register struct table_elt *p, *next;
-   int all = writes->all;
-   int nonscalar = writes->nonscalar;
- 
-   for (i = 0; i < NBUCKETS; i++)
-     for (p = table[i]; p; p = next)
-       {
- 	next = p->next_same_hash;
- 	if (p->in_memory
- 	    && (all
- 		|| (nonscalar && p->in_struct)
- 		|| cse_rtx_addr_varies_p (p->exp)))
- 	  remove_from_table (p, i);
-       }
- }
- 
  /* Remove from the hash table any expression that is a call-clobbered
     register.  Also update their TICK values.  */
--- 1671,1674 ----
*************** invalidate_for_call ()
*** 1756,1759 ****
--- 1708,1717 ----
  	  next = p->next_same_hash;
  
+ 	  if (p->in_memory)
+ 	    {
+ 	      remove_from_table (p, hash);
+ 	      continue;
+ 	    }
+ 
  	  if (GET_CODE (p->exp) != REG
  	      || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
*************** canon_hash (x, mode)
*** 1946,1950 ****
  	  return 0;
  	}
!       if (! RTX_UNCHANGING_P (x))
  	{
  	  hash_arg_in_memory = 1;
--- 1904,1908 ----
  	  return 0;
  	}
!       if (! RTX_UNCHANGING_P (x) || FIXED_BASE_PLUS_P (XEXP (x, 0)))
  	{
  	  hash_arg_in_memory = 1;
*************** set_nonvarying_address_components (addr,
*** 2395,2477 ****
  }
  
! /* Return 1 iff any subexpression of X refers to memory
!    at an address of BASE plus some offset
!    such that any of the bytes' offsets fall between START (inclusive)
!    and END (exclusive).
! 
!    The value is undefined if X is a varying address (as determined by
!    cse_rtx_addr_varies_p).  This function is not used in such cases.
! 
!    When used in the cse pass, `qty_const' is nonzero, and it is used
!    to treat an address that is a register with a known constant value
!    as if it were that constant value.
!    In the loop pass, `qty_const' is zero, so this is not done.  */
! 
! static int
! refers_to_mem_p (x, base, start, end)
!      rtx x, base;
!      HOST_WIDE_INT start, end;
! {
!   register HOST_WIDE_INT i;
!   register enum rtx_code code;
!   register char *fmt;
! 
!  repeat:
!   if (x == 0)
!     return 0;
! 
!   code = GET_CODE (x);
!   if (code == MEM)
!     {
!       register rtx addr = XEXP (x, 0);	/* Get the address.  */
!       rtx mybase;
!       HOST_WIDE_INT mystart, myend;
! 
!       set_nonvarying_address_components (addr, GET_MODE_SIZE (GET_MODE (x)),
! 					 &mybase, &mystart, &myend);
! 
! 
!       /* refers_to_mem_p is never called with varying addresses. 
! 	 If the base addresses are not equal, there is no chance
! 	 of the memory addresses conflicting.  */
!       if (! rtx_equal_p (mybase, base))
! 	return 0;
! 
!       return myend > start && mystart < end;
!     }
! 
!   /* X does not match, so try its subexpressions.  */
! 
!   fmt = GET_RTX_FORMAT (code);
!   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
!     if (fmt[i] == 'e')
!       {
! 	if (i == 0)
! 	  {
! 	    x = XEXP (x, 0);
! 	    goto repeat;
! 	  }
! 	else
! 	  if (refers_to_mem_p (XEXP (x, i), base, start, end))
! 	    return 1;
!       }
!     else if (fmt[i] == 'E')
!       {
! 	int j;
! 	for (j = 0; j < XVECLEN (x, i); j++)
! 	  if (refers_to_mem_p (XVECEXP (x, i, j), base, start, end))
! 	    return 1;
!       }
! 
!   return 0;
! }
! 
! /* Nonzero if X refers to memory at a varying address;
     except that a register which has at the moment a known constant value
     isn't considered variable.  */
  
  static int
! cse_rtx_addr_varies_p (x)
!      rtx x;
  {
    /* We need not check for X and the equivalence class being of the same
--- 2353,2363 ----
  }
  
! /* Nonzero if X, a memory address, refers to a varying address;
     except that a register which has at the moment a known constant value
     isn't considered variable.  */
  
  static int
! cse_rtx_varies_p (x)
!      register rtx x;
  {
    /* We need not check for X and the equivalence class being of the same
*************** cse_rtx_addr_varies_p (x)
*** 2479,2497 ****
       doesn't vary in any mode.  */
  
!   if (GET_CODE (x) == MEM
!       && GET_CODE (XEXP (x, 0)) == REG
!       && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
!       && GET_MODE (XEXP (x, 0)) == qty_mode[reg_qty[REGNO (XEXP (x, 0))]]
!       && qty_const[reg_qty[REGNO (XEXP (x, 0))]] != 0)
      return 0;
  
!   if (GET_CODE (x) == MEM
!       && GET_CODE (XEXP (x, 0)) == PLUS
!       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
!       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
!       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0)))
!       && (GET_MODE (XEXP (XEXP (x, 0), 0))
! 	  == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
!       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
      return 0;
  
--- 2365,2381 ----
       doesn't vary in any mode.  */
  
!   if (GET_CODE (x) == REG
!       && REGNO_QTY_VALID_P (REGNO (x))
!       && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]]
!       && qty_const[reg_qty[REGNO (x)]] != 0)
      return 0;
  
!   if (GET_CODE (x) == PLUS
!       && GET_CODE (XEXP (x, 1)) == CONST_INT
!       && GET_CODE (XEXP (x, 0)) == REG
!       && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
!       && (GET_MODE (XEXP (x, 0))
! 	  == qty_mode[reg_qty[REGNO (XEXP (x, 0))]])
!       && qty_const[reg_qty[REGNO (XEXP (x, 0))]])
      return 0;
  
*************** cse_rtx_addr_varies_p (x)
*** 2501,2519 ****
       load fp minus a constant into a register, then a MEM which is the
       sum of the two `constant' registers.  */
!   if (GET_CODE (x) == MEM
!       && GET_CODE (XEXP (x, 0)) == PLUS
!       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
!       && GET_CODE (XEXP (XEXP (x, 0), 1)) == REG
!       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0)))
!       && (GET_MODE (XEXP (XEXP (x, 0), 0))
! 	  == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]])
!       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]]
!       && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 1)))
!       && (GET_MODE (XEXP (XEXP (x, 0), 1))
! 	  == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 1))]])
!       && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 1))]])
      return 0;
  
!   return rtx_addr_varies_p (x);
  }
  
--- 2385,2402 ----
       load fp minus a constant into a register, then a MEM which is the
       sum of the two `constant' registers.  */
!   if (GET_CODE (x) == PLUS
!       && GET_CODE (XEXP (x, 0)) == REG
!       && GET_CODE (XEXP (x, 1)) == REG
!       && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))
!       && (GET_MODE (XEXP (x, 0))
! 	  == qty_mode[reg_qty[REGNO (XEXP (x, 0))]])
!       && qty_const[reg_qty[REGNO (XEXP (x, 0))]]
!       && REGNO_QTY_VALID_P (REGNO (XEXP (x, 1)))
!       && (GET_MODE (XEXP (x, 1))
! 	  == qty_mode[reg_qty[REGNO (XEXP (x, 1))]])
!       && qty_const[reg_qty[REGNO (XEXP (x, 1))]])
      return 0;
  
!   return rtx_varies_p (x);
  }
  
*************** fold_rtx (x, insn)
*** 5542,5550 ****
  	     CONST_INT, see if we can find a register equivalent to the
  	     positive constant.  Make a MINUS if so.  Don't do this for
! 	     a negative constant since we might then alternate between
  	     chosing positive and negative constants.  Having the positive
! 	     constant previously-used is the more common case.  */
! 	  if (const_arg1 && GET_CODE (const_arg1) == CONST_INT
! 	      && INTVAL (const_arg1) < 0 && GET_CODE (folded_arg1) == REG)
  	    {
  	      rtx new_const = GEN_INT (- INTVAL (const_arg1));
--- 5425,5439 ----
  	     CONST_INT, see if we can find a register equivalent to the
  	     positive constant.  Make a MINUS if so.  Don't do this for
! 	     a non-negative constant since we might then alternate between
  	     chosing positive and negative constants.  Having the positive
! 	     constant previously-used is the more common case.  Be sure
! 	     the resulting constant is non-negative; if const_arg1 were
! 	     the smallest negative number this would overflow: depending
! 	     on the mode, this would either just be the same value (and
! 	     hence not save anything) or be incorrect.  */
! 	  if (const_arg1 != 0 && GET_CODE (const_arg1) == CONST_INT
! 	      && INTVAL (const_arg1) < 0
! 	      && - INTVAL (const_arg1) >= 0
! 	      && GET_CODE (folded_arg1) == REG)
  	    {
  	      rtx new_const = GEN_INT (- INTVAL (const_arg1));
*************** cse_insn (insn, in_libcall_block)
*** 6105,6110 ****
    rtx this_insn_cc0 = 0;
    enum machine_mode this_insn_cc0_mode;
-   struct write_data writes_memory;
-   static struct write_data init = {0, 0, 0, 0};
  
    rtx src_eqv = 0;
--- 5994,5997 ----
*************** cse_insn (insn, in_libcall_block)
*** 6118,6122 ****
  
    this_insn = insn;
-   writes_memory = init;
  
    /* Find all the SETs and CLOBBERs in this instruction.
--- 6005,6008 ----
*************** cse_insn (insn, in_libcall_block)
*** 6220,6232 ****
  	  else if (GET_CODE (y) == CLOBBER)
  	    {
! 	      /* If we clobber memory, take note of that,
! 		 and canon the address.
  		 This does nothing when a register is clobbered
  		 because we have already invalidated the reg.  */
  	      if (GET_CODE (XEXP (y, 0)) == MEM)
! 		{
! 		  canon_reg (XEXP (y, 0), NULL_RTX);
! 		  note_mem_written (XEXP (y, 0), &writes_memory);
! 		}
  	    }
  	  else if (GET_CODE (y) == USE
--- 6106,6114 ----
  	  else if (GET_CODE (y) == CLOBBER)
  	    {
! 	      /* If we clobber memory, canon the address.
  		 This does nothing when a register is clobbered
  		 because we have already invalidated the reg.  */
  	      if (GET_CODE (XEXP (y, 0)) == MEM)
! 		canon_reg (XEXP (y, 0), NULL_RTX);
  	    }
  	  else if (GET_CODE (y) == USE
*************** cse_insn (insn, in_libcall_block)
*** 6247,6254 ****
      {
        if (GET_CODE (XEXP (x, 0)) == MEM)
! 	{
! 	  canon_reg (XEXP (x, 0), NULL_RTX);
! 	  note_mem_written (XEXP (x, 0), &writes_memory);
! 	}
      }
  
--- 6129,6133 ----
      {
        if (GET_CODE (XEXP (x, 0)) == MEM)
! 	canon_reg (XEXP (x, 0), NULL_RTX);
      }
  
*************** cse_insn (insn, in_libcall_block)
*** 6430,6433 ****
--- 6309,6327 ----
        sets[i].src_in_struct = hash_arg_in_struct;
  
+       /* If SRC is a MEM, there is a REG_EQUIV note for SRC, and DEST is
+ 	 a pseudo that is set more than once, do not record SRC.  Using
+ 	 SRC as a replacement for anything else will be incorrect in that
+ 	 situation.  Note that this usually occurs only for stack slots,
+ 	 in which case all the RTL would be refering to SRC, so we don't
+ 	 lose any optimization opportunities by not having SRC in the
+ 	 hash table.  */
+ 
+       if (GET_CODE (src) == MEM
+ 	  && find_reg_note (insn, REG_EQUIV, src) != 0
+ 	  && GET_CODE (dest) == REG
+ 	  && REGNO (dest) >= FIRST_PSEUDO_REGISTER
+ 	  && reg_n_sets[REGNO (dest)] != 1)
+ 	sets[i].src_volatile = 1;
+ 
  #if 0
        /* It is no longer clear why we used to do this, but it doesn't
*************** cse_insn (insn, in_libcall_block)
*** 6674,6678 ****
  	}
  #endif /* LOAD_EXTEND_OP */
!  
        if (src == src_folded)
          src_folded = 0;
--- 6568,6572 ----
  	}
  #endif /* LOAD_EXTEND_OP */
! 
        if (src == src_folded)
          src_folded = 0;
*************** cse_insn (insn, in_libcall_block)
*** 6860,6864 ****
  		       || (GET_CODE (src_folded) != MEM
  			   && ! src_folded_force_flag))
! 		   && GET_MODE_CLASS (mode) != MODE_CC)
  	    {
  	      src_folded_force_flag = 1;
--- 6754,6759 ----
  		       || (GET_CODE (src_folded) != MEM
  			   && ! src_folded_force_flag))
! 		   && GET_MODE_CLASS (mode) != MODE_CC
! 		   && mode != VOIDmode)
  	    {
  	      src_folded_force_flag = 1;
*************** cse_insn (insn, in_libcall_block)
*** 6983,6993 ****
        if (GET_CODE (dest) == MEM)
  	{
  	  dest = fold_rtx (dest, insn);
- 
- 	  /* Decide whether we invalidate everything in memory,
- 	     or just things at non-fixed places.
- 	     Writing a large aggregate must invalidate everything
- 	     because we don't know how long it is.  */
- 	  note_mem_written (dest, &writes_memory);
  	}
  
--- 6878,6890 ----
        if (GET_CODE (dest) == MEM)
  	{
+ #ifdef PUSH_ROUNDING
+ 	  /* Stack pushes invalidate the stack pointer.  */
+ 	  rtx addr = XEXP (dest, 0);
+ 	  if ((GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
+ 	       || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
+ 	      && XEXP (addr, 0) == stack_pointer_rtx)
+ 	    invalidate (stack_pointer_rtx, Pmode);
+ #endif
  	  dest = fold_rtx (dest, insn);
  	}
  
*************** cse_insn (insn, in_libcall_block)
*** 7234,7238 ****
        sets[i].src_elt = src_eqv_elt;
  
!   invalidate_from_clobbers (&writes_memory, x);
  
    /* Some registers are invalidated by subroutine calls.  Memory is 
--- 7131,7135 ----
        sets[i].src_elt = src_eqv_elt;
  
!   invalidate_from_clobbers (x);
  
    /* Some registers are invalidated by subroutine calls.  Memory is 
*************** cse_insn (insn, in_libcall_block)
*** 7241,7248 ****
    if (GET_CODE (insn) == CALL_INSN)
      {
-       static struct write_data everything = {0, 1, 1, 1};
- 
        if (! CONST_CALL_P (insn))
! 	invalidate_memory (&everything);
        invalidate_for_call ();
      }
--- 7138,7143 ----
    if (GET_CODE (insn) == CALL_INSN)
      {
        if (! CONST_CALL_P (insn))
! 	invalidate_memory ();
        invalidate_for_call ();
      }
*************** cse_insn (insn, in_libcall_block)
*** 7265,7270 ****
  	   we have just done an invalidate_memory that covers even those.  */
  	if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
! 	    || (GET_CODE (dest) == MEM && ! writes_memory.all
! 		&& ! cse_rtx_addr_varies_p (dest)))
  	  invalidate (dest, VOIDmode);
  	else if (GET_CODE (dest) == STRICT_LOW_PART
--- 7160,7164 ----
  	   we have just done an invalidate_memory that covers even those.  */
  	if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
! 	    || GET_CODE (dest) == MEM)
  	  invalidate (dest, VOIDmode);
  	else if (GET_CODE (dest) == STRICT_LOW_PART
*************** cse_insn (insn, in_libcall_block)
*** 7359,7363 ****
  		      sets[i].dest_hash, GET_MODE (dest));
  	elt->in_memory = (GET_CODE (sets[i].inner_dest) == MEM
! 			  && ! RTX_UNCHANGING_P (sets[i].inner_dest));
  
  	if (elt->in_memory)
--- 7253,7259 ----
  		      sets[i].dest_hash, GET_MODE (dest));
  	elt->in_memory = (GET_CODE (sets[i].inner_dest) == MEM
! 			  && (! RTX_UNCHANGING_P (sets[i].inner_dest)
! 			      || FIXED_BASE_PLUS_P (XEXP (sets[i].inner_dest,
! 							  0))));
  
  	if (elt->in_memory)
*************** cse_insn (insn, in_libcall_block)
*** 7532,7580 ****
  }
  
- /* Store 1 in *WRITES_PTR for those categories of memory ref
-    that must be invalidated when the expression WRITTEN is stored in.
-    If WRITTEN is null, say everything must be invalidated.  */
- 
  static void
! note_mem_written (written, writes_ptr)
!      rtx written;
!      struct write_data *writes_ptr;
! {
!   static struct write_data everything = {0, 1, 1, 1};
! 
!   if (written == 0)
!     *writes_ptr = everything;
!   else if (GET_CODE (written) == MEM)
!     {
!       /* Pushing or popping the stack invalidates just the stack pointer. */
!       rtx addr = XEXP (written, 0);
!       if ((GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
! 	   || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
! 	  && GET_CODE (XEXP (addr, 0)) == REG
! 	  && REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM)
! 	{
! 	  writes_ptr->sp = 1;
! 	  return;
! 	}
!       else if (GET_MODE (written) == BLKmode)
! 	*writes_ptr = everything;
!       /* (mem (scratch)) means clobber everything.  */
!       else if (GET_CODE (addr) == SCRATCH)
! 	*writes_ptr = everything;
!       else if (cse_rtx_addr_varies_p (written))
! 	{
! 	  /* A varying address that is a sum indicates an array element,
! 	     and that's just as good as a structure element
! 	     in implying that we need not invalidate scalar variables.
! 	     However, we must allow QImode aliasing of scalars, because the
! 	     ANSI C standard allows character pointers to alias anything.  */
! 	  if (! ((MEM_IN_STRUCT_P (written)
! 		  || GET_CODE (XEXP (written, 0)) == PLUS)
! 		 && GET_MODE (written) != QImode))
! 	    writes_ptr->all = 1;
! 	  writes_ptr->nonscalar = 1;
! 	}
!       writes_ptr->var = 1;
      }
  }
  
--- 7428,7471 ----
  }
  
  static void
! invalidate_memory ()
! {
!   register int i;
!   register struct table_elt *p, *next;
! 
!   for (i = 0; i < NBUCKETS; i++)
!     for (p = table[i]; p; p = next)
!       {
! 	next = p->next_same_hash;
! 	if (p->in_memory)
! 	  remove_from_table (p, i);
!       }
! }
! 
! static int
! note_mem_written (mem)
!      register rtx mem;
! {
!   if (mem == 0 || GET_CODE(mem) != MEM )
!      return 0;
!   else
!    {
!       register rtx addr = XEXP (mem, 0);
!   /* Pushing or popping the stack invalidates just the stack pointer.  */
!     if ((GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
!        || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
!       && GET_CODE (XEXP (addr, 0)) == REG
!       && REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM)
!     {
!       if (reg_tick[STACK_POINTER_REGNUM] >= 0)
! 	reg_tick[STACK_POINTER_REGNUM]++;
! 
!       /* This should be *very* rare.  */
!       if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM))
! 	invalidate (stack_pointer_rtx, VOIDmode);
!       return 1;
      }
+   return 0;
+   }
  }
  
*************** note_mem_written (written, writes_ptr)
*** 7584,7612 ****
     alias with something that is SET or CLOBBERed.
  
-    W points to the writes_memory for this insn, a struct write_data
-    saying which kinds of memory references must be invalidated.
     X is the pattern of the insn.  */
  
  static void
! invalidate_from_clobbers (w, x)
!      struct write_data *w;
       rtx x;
  {
-   /* If W->var is not set, W specifies no action.
-      If W->all is set, this step gets all memory refs
-      so they can be ignored in the rest of this function.  */
-   if (w->var)
-     invalidate_memory (w);
- 
-   if (w->sp)
-     {
-       if (reg_tick[STACK_POINTER_REGNUM] >= 0)
- 	reg_tick[STACK_POINTER_REGNUM]++;
- 
-       /* This should be *very* rare.  */
-       if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM))
- 	invalidate (stack_pointer_rtx, VOIDmode);
-     }
- 
    if (GET_CODE (x) == CLOBBER)
      {
--- 7475,7484 ----
     alias with something that is SET or CLOBBERed.
  
     X is the pattern of the insn.  */
  
  static void
! invalidate_from_clobbers (x)
       rtx x;
  {
    if (GET_CODE (x) == CLOBBER)
      {
*************** invalidate_from_clobbers (w, x)
*** 7615,7619 ****
  	{
  	  if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
! 	      || (GET_CODE (ref) == MEM && ! w->all))
  	    invalidate (ref, VOIDmode);
  	  else if (GET_CODE (ref) == STRICT_LOW_PART
--- 7487,7491 ----
  	{
  	  if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
! 	      || GET_CODE (ref) == MEM)
  	    invalidate (ref, VOIDmode);
  	  else if (GET_CODE (ref) == STRICT_LOW_PART
*************** invalidate_from_clobbers (w, x)
*** 7631,7643 ****
  	    {
  	      rtx ref = XEXP (y, 0);
! 	      if (ref)
! 		{
! 		  if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
! 		      || (GET_CODE (ref) == MEM && !w->all))
! 		    invalidate (ref, VOIDmode);
! 		  else if (GET_CODE (ref) == STRICT_LOW_PART
! 			   || GET_CODE (ref) == ZERO_EXTRACT)
! 		    invalidate (XEXP (ref, 0), GET_MODE (ref));
! 		}
  	    }
  	}
--- 7503,7512 ----
  	    {
  	      rtx ref = XEXP (y, 0);
! 	      if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG
! 		  || GET_CODE (ref) == MEM)
! 		invalidate (ref, VOIDmode);
! 	      else if (GET_CODE (ref) == STRICT_LOW_PART
! 		       || GET_CODE (ref) == ZERO_EXTRACT)
! 		invalidate (XEXP (ref, 0), GET_MODE (ref));
  	    }
  	}
*************** cse_around_loop (loop_start)
*** 7800,7807 ****
  }
  
- /* Variable used for communications between the next two routines.  */
- 
- static struct write_data skipped_writes_memory;
- 
  /* Process one SET of an insn that was skipped.  We ignore CLOBBERs
     since they are done elsewhere.  This function is called via note_stores.  */
--- 7669,7672 ----
*************** invalidate_skipped_set (dest, set)
*** 7812,7823 ****
       rtx dest;
  {
!   if (GET_CODE (dest) == MEM)
!     note_mem_written (dest, &skipped_writes_memory);
! 
!   /* There are times when an address can appear varying and be a PLUS
!      during this scan when it would be a fixed address were we to know
!      the proper equivalences.  So promote "nonscalar" to be "all".  */
!   if (skipped_writes_memory.nonscalar)
!     skipped_writes_memory.all = 1;
  
    if (GET_CODE (set) == CLOBBER
--- 7677,7695 ----
       rtx dest;
  {
!   enum rtx_code code = GET_CODE (dest);
!   
!   if (code == MEM
!       && ! note_mem_written (dest)	/* If this is not a stack push ... */
!       /* There are times when an address can appear varying and be a PLUS
! 	 during this scan when it would be a fixed address were we to know
! 	 the proper equivalences.  So invalidate all memory if there is
! 	 a BLKmode or nonscalar memory reference or a reference to a
! 	 variable address.  */
!       && (MEM_IN_STRUCT_P (dest) || GET_MODE (dest) == BLKmode
! 	  || cse_rtx_varies_p (XEXP (dest, 0))))
!     {
!       invalidate_memory ();
!       return;
!     }
  
    if (GET_CODE (set) == CLOBBER
*************** invalidate_skipped_set (dest, set)
*** 7828,7837 ****
      return;
  
!   if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG
!       || (! skipped_writes_memory.all && ! cse_rtx_addr_varies_p (dest)))
!     invalidate (dest, VOIDmode);
!   else if (GET_CODE (dest) == STRICT_LOW_PART
! 	   || GET_CODE (dest) == ZERO_EXTRACT)
      invalidate (XEXP (dest, 0), GET_MODE (dest));
  }
  
--- 7700,7707 ----
      return;
  
!   if (code == STRICT_LOW_PART || code == ZERO_EXTRACT)
      invalidate (XEXP (dest, 0), GET_MODE (dest));
+   else if (code == REG || code == SUBREG || code == MEM)
+     invalidate (dest, VOIDmode);
  }
  
*************** invalidate_skipped_block (start)
*** 7845,7850 ****
  {
    rtx insn;
-   static struct write_data init = {0, 0, 0, 0};
-   static struct write_data everything = {0, 1, 1, 1};
  
    for (insn = start; insn && GET_CODE (insn) != CODE_LABEL;
--- 7715,7718 ----
*************** invalidate_skipped_block (start)
*** 7854,7867 ****
  	continue;
  
-       skipped_writes_memory = init;
- 
        if (GET_CODE (insn) == CALL_INSN)
  	{
  	  invalidate_for_call ();
- 	  skipped_writes_memory = everything;
  	}
  
        note_stores (PATTERN (insn), invalidate_skipped_set);
-       invalidate_from_clobbers (&skipped_writes_memory, PATTERN (insn));
      }
  }
--- 7722,7733 ----
  	continue;
  
        if (GET_CODE (insn) == CALL_INSN)
  	{
+ 	  if (! CONST_CALL_P (insn))
+ 	    invalidate_memory ();
  	  invalidate_for_call ();
  	}
  
        note_stores (PATTERN (insn), invalidate_skipped_set);
      }
  }
*************** cse_set_around_loop (x, insn, loop_start
*** 7913,7920 ****
  {
    struct table_elt *src_elt;
-   static struct write_data init = {0, 0, 0, 0};
-   struct write_data writes_memory;
- 
-   writes_memory = init;
  
    /* If this is a SET, see if we can replace SET_SRC, but ignore SETs that
--- 7779,7782 ----
*************** cse_set_around_loop (x, insn, loop_start
*** 7976,7991 ****
  
    /* Now invalidate anything modified by X.  */
!   note_mem_written (SET_DEST (x), &writes_memory);
! 
!   if (writes_memory.var)
!     invalidate_memory (&writes_memory);
! 
!   /* See comment on similar code in cse_insn for explanation of these tests. */
    if (GET_CODE (SET_DEST (x)) == REG || GET_CODE (SET_DEST (x)) == SUBREG
!       || (GET_CODE (SET_DEST (x)) == MEM && ! writes_memory.all
! 	  && ! cse_rtx_addr_varies_p (SET_DEST (x))))
      invalidate (SET_DEST (x), VOIDmode);
    else if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
! 	   || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
      invalidate (XEXP (SET_DEST (x), 0), GET_MODE (SET_DEST (x)));
  }
--- 7838,7849 ----
  
    /* Now invalidate anything modified by X.  */
!   note_mem_written (SET_DEST (x));
!   
!   /* See comment on similar code in cse_insn for explanation of these tests.  */
    if (GET_CODE (SET_DEST (x)) == REG || GET_CODE (SET_DEST (x)) == SUBREG
!       || GET_CODE (SET_DEST (x)) == MEM)
      invalidate (SET_DEST (x), VOIDmode);
    else if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
!   	   || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
      invalidate (XEXP (SET_DEST (x), 0), GET_MODE (SET_DEST (x)));
  }
*************** cse_main (f, nregs, after_loop, file)
*** 8234,8237 ****
--- 8092,8096 ----
  
    init_recog ();
+   init_alias_analysis ();
  
    max_reg = nregs;
*************** cse_basic_block (from, to, next_branch, 
*** 8405,8408 ****
--- 8264,8268 ----
    int to_usage = 0;
    int in_libcall_block = 0;
+   int num_insns = 0;
  
    /* Each of these arrays is undefined before max_reg, so only allocate
*************** cse_basic_block (from, to, next_branch, 
*** 8437,8440 ****
--- 8297,8320 ----
      {
        register enum rtx_code code;
+       int i;
+       struct table_elt *p, *next;
+ 
+       /* If we have processed 1,000 insns, flush the hash table to avoid
+ 	 extreme quadratic behavior.  */
+       if (num_insns++ > 1000)
+ 	{
+ 	  for (i = 0; i < NBUCKETS; i++)
+ 	    for (p = table[i]; p; p = next)
+ 	      {
+ 		next = p->next_same_hash;
+ 
+ 		if (GET_CODE (p->exp) == REG)
+ 		  invalidate (p->exp, p->mode);
+ 		else
+ 		  remove_from_table (p, i);
+ 	      }
+ 
+ 	  num_insns = 0;
+ 	}
  
        /* See if this is a branch that is part of the path.  If so, and it is
diff -rcp2N gcc-2.7.2.3/dwarfout.c gcc-2.7.2.3.f.2/dwarfout.c
*** gcc-2.7.2.3/dwarfout.c	Fri Oct 27 01:40:07 1995
--- gcc-2.7.2.3.f.2/dwarfout.c	Tue Sep  9 07:01:28 1997
*************** output_bound_representation (bound, dim_
*** 1629,1705 ****
      {
  
!       case ERROR_MARK:
! 	return;
  
        /* All fixed-bounds are represented by INTEGER_CST nodes.	 */
  
!       case INTEGER_CST:
! 	ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
! 				(unsigned) TREE_INT_CST_LOW (bound));
! 	break;
! 
!       /* Dynamic bounds may be represented by NOP_EXPR nodes containing
! 	 SAVE_EXPR nodes.  */
! 
!       case NOP_EXPR:
! 	bound = TREE_OPERAND (bound, 0);
! 	/* ... fall thru... */
! 
!       case SAVE_EXPR:
! 	{
! 	  char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
! 	  char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
! 
! 	  sprintf (begin_label, BOUND_BEGIN_LABEL_FMT,
! 				current_dienum, dim_num, u_or_l);
  
! 	  sprintf (end_label,	BOUND_END_LABEL_FMT,
! 				current_dienum, dim_num, u_or_l);
  
! 	  ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
! 	  ASM_OUTPUT_LABEL (asm_out_file, begin_label);
  
! 	  /* If we are working on a bound for a dynamic dimension in C,
! 	     the dynamic dimension in question had better have a static
! 	     (zero) lower bound and a dynamic *upper* bound.  */
  
! 	  if (u_or_l != 'u')
! 	    abort ();
  
! 	  /* If optimization is turned on, the SAVE_EXPRs that describe
! 	     how to access the upper bound values are essentially bogus.
! 	     They only describe (at best) how to get at these values at
! 	     the points in the generated code right after they have just
! 	     been computed.  Worse yet, in the typical case, the upper
! 	     bound values will not even *be* computed in the optimized
! 	     code, so these SAVE_EXPRs are entirely bogus.
! 
! 	     In order to compensate for this fact, we check here to see
! 	     if optimization is enabled, and if so, we effectively create
! 	     an empty location description for the (unknown and unknowable)
! 	     upper bound.
! 
! 	     This should not cause too much trouble for existing (stupid?)
! 	     debuggers because they have to deal with empty upper bounds
! 	     location descriptions anyway in order to be able to deal with
! 	     incomplete array types.
! 
! 	     Of course an intelligent debugger (GDB?) should be able to
! 	     comprehend that a missing upper bound specification in a
! 	     array type used for a storage class `auto' local array variable
! 	     indicates that the upper bound is both unknown (at compile-
! 	     time) and unknowable (at run-time) due to optimization.
! 	  */
! 
! 	  if (! optimize)
! 	    output_loc_descriptor
! 	      (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
  
! 	  ASM_OUTPUT_LABEL (asm_out_file, end_label);
! 	}
! 	break;
  
-       default:
- 	abort ();
      }
  }
--- 1629,1699 ----
      {
  
!     case ERROR_MARK:
!       return;
  
        /* All fixed-bounds are represented by INTEGER_CST nodes.	 */
  
!     case INTEGER_CST:
!       ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
! 			      (unsigned) TREE_INT_CST_LOW (bound));
!       break;
  
!     default:
  
!       /* Dynamic bounds may be represented by NOP_EXPR nodes containing
! 	 SAVE_EXPR nodes, in which case we can do something, or as
! 	 an expression, which we cannot represent.  */
!       {
! 	char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
! 	char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
  
! 	sprintf (begin_label, BOUND_BEGIN_LABEL_FMT,
! 		 current_dienum, dim_num, u_or_l);
  
! 	sprintf (end_label, BOUND_END_LABEL_FMT,
! 		 current_dienum, dim_num, u_or_l);
  
! 	ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
! 	ASM_OUTPUT_LABEL (asm_out_file, begin_label);
! 
! 	/* If optimization is turned on, the SAVE_EXPRs that describe
! 	   how to access the upper bound values are essentially bogus.
! 	   They only describe (at best) how to get at these values at
! 	   the points in the generated code right after they have just
! 	   been computed.  Worse yet, in the typical case, the upper
! 	   bound values will not even *be* computed in the optimized
! 	   code, so these SAVE_EXPRs are entirely bogus.
! 
! 	   In order to compensate for this fact, we check here to see
! 	   if optimization is enabled, and if so, we effectively create
! 	   an empty location description for the (unknown and unknowable)
! 	   upper bound.
! 
! 	   This should not cause too much trouble for existing (stupid?)
! 	   debuggers because they have to deal with empty upper bounds
! 	   location descriptions anyway in order to be able to deal with
! 	   incomplete array types.
! 
! 	   Of course an intelligent debugger (GDB?) should be able to
! 	   comprehend that a missing upper bound specification in a
! 	   array type used for a storage class `auto' local array variable
! 	   indicates that the upper bound is both unknown (at compile-
! 	   time) and unknowable (at run-time) due to optimization. */
! 
! 	if (! optimize)
! 	  {
! 	    while (TREE_CODE (bound) == NOP_EXPR
! 		   || TREE_CODE (bound) == CONVERT_EXPR)
! 	      bound = TREE_OPERAND (bound, 0);
! 
! 	    if (TREE_CODE (bound) == SAVE_EXPR)
! 	      output_loc_descriptor
! 		(eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
! 	  }
  
! 	ASM_OUTPUT_LABEL (asm_out_file, end_label);
!       }
!       break;
  
      }
  }
*************** type_attribute (type, decl_const, decl_v
*** 2857,2861 ****
    register int root_type_modified;
  
!   if (TREE_CODE (type) == ERROR_MARK)
      return;
  
--- 2851,2855 ----
    register int root_type_modified;
  
!   if (code == ERROR_MARK)
      return;
  
*************** type_attribute (type, decl_const, decl_v
*** 2864,2869 ****
       type `void', so this only applies to function return types.  */
  
!   if (TREE_CODE (type) == VOID_TYPE)
      return;
  
    root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE
--- 2858,2869 ----
       type `void', so this only applies to function return types.  */
  
!   if (code == VOID_TYPE)
      return;
+ 
+   /* If this is a subtype, find the underlying type.  Eventually,
+      this should write out the appropriate subtype info.  */
+   while ((code == INTEGER_TYPE || code == REAL_TYPE)
+ 	 && TREE_TYPE (type) != 0)
+     type = TREE_TYPE (type), code = TREE_CODE (type);
  
    root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE
diff -rcp2N gcc-2.7.2.3/emit-rtl.c gcc-2.7.2.3.f.2/emit-rtl.c
*** gcc-2.7.2.3/emit-rtl.c	Thu Sep 14 20:09:30 1995
--- gcc-2.7.2.3.f.2/emit-rtl.c	Thu Feb 26 21:12:55 1998
*************** max_label_num ()
*** 545,548 ****
--- 545,565 ----
  }
  
+ /* Identify REG (which may be a CONCAT) as a user register.  */
+ 
+ void
+ mark_user_reg (reg)
+      rtx reg;
+ {
+   if (GET_CODE (reg) == CONCAT)
+     {
+       REG_USERVAR_P (XEXP (reg, 0)) = 1;
+       REG_USERVAR_P (XEXP (reg, 1)) = 1;
+     }
+   else if (GET_CODE (reg) == REG)
+     REG_USERVAR_P (reg) = 1;
+   else
+     abort ();
+ }
+ 
  /* Return first label number used in this function (if any were used).  */
  
*************** gen_lowpart_common (mode, x)
*** 610,614 ****
      return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
  	    ? SUBREG_REG (x)
! 	    : gen_rtx (SUBREG, mode, SUBREG_REG (x), SUBREG_WORD (x)));
    else if (GET_CODE (x) == REG)
      {
--- 627,631 ----
      return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
  	    ? SUBREG_REG (x)
! 	    : gen_rtx (SUBREG, mode, SUBREG_REG (x), SUBREG_WORD (x) + word));
    else if (GET_CODE (x) == REG)
      {
*************** subreg_lowpart_p (x)
*** 975,978 ****
--- 992,997 ----
    if (GET_CODE (x) != SUBREG)
      return 1;
+   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
+     return 0;
  
    if (WORDS_BIG_ENDIAN
*************** change_address (memref, mode, addr)
*** 1315,1318 ****
--- 1334,1340 ----
      addr = memory_address (mode, addr);
  	
+   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
+     return memref;
+ 
    new = gen_rtx (MEM, mode, addr);
    MEM_VOLATILE_P (new) = MEM_VOLATILE_P (memref);
diff -rcp2N gcc-2.7.2.3/explow.c gcc-2.7.2.3.f.2/explow.c
*** gcc-2.7.2.3/explow.c	Thu Jun 15 11:30:10 1995
--- gcc-2.7.2.3.f.2/explow.c	Tue Sep  9 07:01:28 1997
*************** Boston, MA 02111-1307, USA.  */
*** 32,36 ****
  
  static rtx break_out_memory_refs	PROTO((rtx));
! 
  /* Return an rtx for the sum of X and the integer C.
  
--- 32,36 ----
  
  static rtx break_out_memory_refs	PROTO((rtx));
! static void emit_stack_probe		PROTO((rtx));
  /* Return an rtx for the sum of X and the integer C.
  
*************** convert_memory_address (to_mode, x)
*** 305,310 ****
--- 305,313 ----
       rtx x;
  {
+   enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
    rtx temp;
  
+   /* Here we handle some special cases.  If none of them apply, fall through
+      to the default case.  */
    switch (GET_CODE (x))
      {
*************** convert_memory_address (to_mode, x)
*** 321,339 ****
        return temp;
  
-     case PLUS:
-     case MULT:
-       return gen_rtx (GET_CODE (x), to_mode, 
- 		      convert_memory_address (to_mode, XEXP (x, 0)),
- 		      convert_memory_address (to_mode, XEXP (x, 1)));
- 
      case CONST:
        return gen_rtx (CONST, to_mode, 
  		      convert_memory_address (to_mode, XEXP (x, 0)));
  
!     default:
!       return convert_modes (to_mode,
! 			    to_mode == ptr_mode ? Pmode : ptr_mode,
! 			    x, POINTERS_EXTEND_UNSIGNED);
      }
  }
  #endif
--- 324,348 ----
        return temp;
  
      case CONST:
        return gen_rtx (CONST, to_mode, 
  		      convert_memory_address (to_mode, XEXP (x, 0)));
  
!     case PLUS:
!     case MULT:
!       /* For addition the second operand is a small constant, we can safely
! 	 permute the converstion and addition operation.  We can always safely
! 	 permute them if we are making the address narrower.  In addition,
! 	 always permute the operations if this is a constant.  */
!       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
! 	  || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
! 	      && (INTVAL (XEXP (x, 1)) + 20000 < 40000
! 		  || CONSTANT_P (XEXP (x, 0)))))
! 	return gen_rtx (GET_CODE (x), to_mode, 
! 			convert_memory_address (to_mode, XEXP (x, 0)),
! 			convert_memory_address (to_mode, XEXP (x, 1)));
      }
+ 
+   return convert_modes (to_mode, from_mode,
+ 			x, POINTERS_EXTEND_UNSIGNED);
  }
  #endif
*************** allocate_dynamic_stack_space (size, targ
*** 1066,1069 ****
--- 1075,1083 ----
    do_pending_stack_adjust ();
  
+   /* If needed, check that we have the required amount of stack.  Take into
+      account what has already been checked.  */
+   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
+     probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
+ 
    /* Don't use a TARGET that isn't a pseudo.  */
    if (target == 0 || GET_CODE (target) != REG
*************** allocate_dynamic_stack_space (size, targ
*** 1133,1136 ****
--- 1147,1281 ----
  
    return target;
+ }
+ 
+ /* Emit one stack probe at ADDRESS, an address within the stack.  */
+ 
+ static void
+ emit_stack_probe (address)
+      rtx address;
+ {
+   rtx memref = gen_rtx (MEM, word_mode, address);
+ 
+   MEM_VOLATILE_P (memref) = 1;
+ 
+   if (STACK_CHECK_PROBE_LOAD)
+     emit_move_insn (gen_reg_rtx (word_mode), memref);
+   else
+     emit_move_insn (memref, const0_rtx);
+ }
+ 
+ /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 
+    FIRST is a constant and size is a Pmode RTX.  These are offsets from the
+    current stack pointer.  STACK_GROWS_DOWNWARD says whether to add or
+    subtract from the stack.  If SIZE is constant, this is done
+    with a fixed number of probes.  Otherwise, we must make a loop.  */
+ 
+ #ifdef STACK_GROWS_DOWNWARD
+ #define STACK_GROW_OP MINUS
+ #else
+ #define STACK_GROW_OP PLUS
+ #endif
+ 
+ void
+ probe_stack_range (first, size)
+      HOST_WIDE_INT first;
+      rtx size;
+ {
+   /* First see if we have an insn to check the stack.  Use it if so.  */
+ #ifdef HAVE_check_stack
+   if (HAVE_check_stack)
+     {
+       rtx last_addr = force_operand (gen_rtx (STACK_GROW_OP, Pmode,
+ 					      stack_pointer_rtx,
+ 					      plus_constant (size, first)),
+ 				     NULL_RTX);
+ 
+       if (insn_operand_predicate[(int) CODE_FOR_check_stack][0]
+ 	  && ! ((*insn_operand_predicate[(int) CODE_FOR_check_stack][0])
+ 		(last_address, Pmode)))
+ 	last_address = copy_to_mode_reg (Pmode, last_address);
+ 
+       emit_insn (gen_check_stack (last_address));
+       return;
+     }
+ #endif
+ 
+   /* If we have to generate explicit probes, see if we have a constant
+      small number of them to generate.  If so, that's the easy case.  */
+   if (GET_CODE (size) == CONST_INT && INTVAL (size) < 10)
+     {
+       HOST_WIDE_INT offset;
+ 
+       /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL
+ 	 for values of N from 1 until it exceeds LAST.  If only one
+ 	 probe is needed, this will not generate any code.  Then probe
+ 	 at LAST.  */
+       for (offset = first + STACK_CHECK_PROBE_INTERVAL;
+ 	   offset < INTVAL (size);
+ 	   offset = offset + STACK_CHECK_PROBE_INTERVAL)
+ 	emit_stack_probe (gen_rtx (STACK_GROW_OP, Pmode,
+ 				   stack_pointer_rtx, GEN_INT (offset)));
+ 
+       emit_stack_probe (gen_rtx (STACK_GROW_OP, Pmode, stack_pointer_rtx,
+ 				 plus_constant (size, first)));
+     }
+ 
+   /* In the variable case, do the same as above, but in a loop.  We emit loop
+      notes so that loop optimization can be done.  */
+   else
+     {
+       rtx test_addr
+ 	= force_operand (gen_rtx (STACK_GROW_OP, Pmode, stack_pointer_rtx,
+ 				  GEN_INT (first
+ 					   + STACK_CHECK_PROBE_INTERVAL)),
+ 			 NULL_RTX);
+       rtx last_addr
+ 	= force_operand (gen_rtx (STACK_GROW_OP, Pmode, stack_pointer_rtx,
+ 				  plus_constant (size, first)),
+ 			 NULL_RTX);
+       rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
+       rtx loop_lab = gen_label_rtx ();
+       rtx test_lab = gen_label_rtx ();
+       rtx end_lab = gen_label_rtx ();
+       rtx temp;
+ 
+       if (GET_CODE (test_addr) != REG
+ 	  || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
+ 	test_addr = force_reg (Pmode, test_addr);
+ 
+       emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
+       emit_jump (test_lab);
+ 
+       emit_label (loop_lab);
+       emit_stack_probe (test_addr);
+ 
+       emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
+ 
+ #ifdef STACK_GROWS_DOWNWARD
+ #define CMP_OPCODE GTU
+       temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
+ 			   1, OPTAB_WIDEN);
+ #else
+ #define CMP_OPCODE LTU
+       temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
+ 			   1, OPTAB_WIDEN);
+ #endif
+ 
+       if (temp != test_addr)
+ 	abort ();
+ 
+       emit_label (test_lab);
+       emit_cmp_insn (test_addr, last_addr, CMP_OPCODE, NULL_RTX, Pmode, 1, 0);
+       emit_jump_insn ((*bcc_gen_fctn[(int) CMP_OPCODE]) (loop_lab));
+       emit_jump (end_lab);
+       emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
+       emit_label (end_lab);
+ 
+       /* If will be doing stupid optimization, show test_addr is still live. */
+       if (obey_regdecls)
+ 	emit_insn (gen_rtx (USE, VOIDmode, test_addr));
+ 
+       emit_stack_probe (last_addr);
+     }
  }
  
diff -rcp2N gcc-2.7.2.3/expmed.c gcc-2.7.2.3.f.2/expmed.c
*** gcc-2.7.2.3/expmed.c	Thu Jul 13 23:25:37 1995
--- gcc-2.7.2.3.f.2/expmed.c	Tue Sep  9 07:01:29 1997
*************** store_bit_field (str_rtx, bitsize, bitnu
*** 399,402 ****
--- 399,403 ----
  #ifdef HAVE_insv
    if (HAVE_insv
+       && GET_MODE (value) != BLKmode
        && !(bitsize == 1 && GET_CODE (value) == CONST_INT)
        /* Ensure insv's size is wide enough for this field.  */
*************** store_split_bit_field (op0, bitsize, bit
*** 777,781 ****
  	     done in extract_bit_field, so that the two calls to
  	     extract_fixed_bit_field will have comparable arguments.  */
! 	  if (GET_CODE (value) != MEM)
  	    total_bits = BITS_PER_WORD;
  	  else
--- 778,782 ----
  	     done in extract_bit_field, so that the two calls to
  	     extract_fixed_bit_field will have comparable arguments.  */
! 	  if (GET_CODE (value) != MEM || GET_MODE (value) == BLKmode)
  	    total_bits = BITS_PER_WORD;
  	  else
*************** store_split_bit_field (op0, bitsize, bit
*** 790,797 ****
  	    /* The args are chosen so that the last part includes the
  	       lsb.  Give extract_bit_field the value it needs (with
! 	       endianness compensation) to fetch the piece we want.  */
! 	    part = extract_fixed_bit_field (word_mode, value, 0, thissize,
! 					    total_bits - bitsize + bitsdone,
! 					    NULL_RTX, 1, align);
  	}
        else
--- 791,807 ----
  	    /* The args are chosen so that the last part includes the
  	       lsb.  Give extract_bit_field the value it needs (with
! 	       endianness compensation) to fetch the piece we want.
! 
! 	       ??? We have no idea what the alignment of VALUE is, so
! 	       we have to use a guess.  */
! 	    part
! 	      = extract_fixed_bit_field
! 		(word_mode, value, 0, thissize,
! 		 total_bits - bitsize + bitsdone, NULL_RTX, 1,
! 		 GET_MODE (value) == VOIDmode
! 		 ? UNITS_PER_WORD
! 		 : (GET_MODE (value) == BLKmode
! 		    ? 1
! 		    : GET_MODE_ALIGNMENT (GET_MODE (value)) / BITS_PER_UNIT));
  	}
        else
*************** store_split_bit_field (op0, bitsize, bit
*** 803,808 ****
  			    & (((HOST_WIDE_INT) 1 << thissize) - 1));
  	  else
! 	    part = extract_fixed_bit_field (word_mode, value, 0, thissize,
! 					    bitsdone, NULL_RTX, 1, align);
  	}
  
--- 813,824 ----
  			    & (((HOST_WIDE_INT) 1 << thissize) - 1));
  	  else
! 	    part
! 	      = extract_fixed_bit_field
! 		(word_mode, value, 0, thissize, bitsdone, NULL_RTX, 1,
! 		 GET_MODE (value) == VOIDmode
! 		 ? UNITS_PER_WORD
! 		 : (GET_MODE (value) == BLKmode
! 		    ? 1
! 		    : GET_MODE_ALIGNMENT (GET_MODE (value)) / BITS_PER_UNIT));
  	}
  
*************** extract_bit_field (str_rtx, bitsize, bit
*** 876,882 ****
    rtx spec_target_subreg = 0;
  
-   if (GET_CODE (str_rtx) == MEM && ! MEM_IN_STRUCT_P (str_rtx))
-     abort ();
- 
    /* Discount the part of the structure before the desired byte.
       We need to know how many bytes are safe to reference after it.  */
--- 892,895 ----
*************** expand_divmod (rem_flag, code, mode, op0
*** 3189,3193 ****
  	   Notice that we compute also the final remainder value here,
  	   and return the result right away.  */
! 	if (target == 0)
  	  target = gen_reg_rtx (compute_mode);
  
--- 3202,3206 ----
  	   Notice that we compute also the final remainder value here,
  	   and return the result right away.  */
! 	if (target == 0 || GET_MODE (target) != compute_mode)
  	  target = gen_reg_rtx (compute_mode);
  
*************** expand_divmod (rem_flag, code, mode, op0
*** 3316,3320 ****
  	       remainder.  Notice that we compute also the final remainder
  	       value here, and return the result right away.  */
! 	    if (target == 0)
  	      target = gen_reg_rtx (compute_mode);
  
--- 3329,3333 ----
  	       remainder.  Notice that we compute also the final remainder
  	       value here, and return the result right away.  */
! 	    if (target == 0 || GET_MODE (target) != compute_mode)
  	      target = gen_reg_rtx (compute_mode);
  
*************** expand_divmod (rem_flag, code, mode, op0
*** 3418,3422 ****
  	       remainder.  Notice that we compute also the final remainder
  	       value here, and return the result right away.  */
! 	    if (target == 0)
  	      target = gen_reg_rtx (compute_mode);
  	    if (rem_flag)
--- 3431,3435 ----
  	       remainder.  Notice that we compute also the final remainder
  	       value here, and return the result right away.  */
! 	    if (target == 0 || GET_MODE (target) != compute_mode)
  	      target = gen_reg_rtx (compute_mode);
  	    if (rem_flag)
*************** expand_divmod (rem_flag, code, mode, op0
*** 3602,3605 ****
--- 3615,3621 ----
    if (quotient == 0)
      {
+       if (target && GET_MODE (target) != compute_mode)
+ 	target = 0;
+ 
        if (rem_flag)
  	{
*************** expand_divmod (rem_flag, code, mode, op0
*** 3653,3656 ****
--- 3669,3675 ----
    if (rem_flag)
      {
+       if (target && GET_MODE (target) != compute_mode)
+ 	target = 0;
+ 
        if (quotient == 0)
  	/* No divide instruction either.  Use library for remainder.  */
diff -rcp2N gcc-2.7.2.3/expr.c gcc-2.7.2.3.f.2/expr.c
*** gcc-2.7.2.3/expr.c	Sat Jun 29 16:26:15 1996
--- gcc-2.7.2.3.f.2/expr.c	Mon Sep 15 21:47:09 1997
*************** Boston, MA 02111-1307, USA.  */
*** 27,30 ****
--- 27,31 ----
  #include "flags.h"
  #include "regs.h"
+ #include "hard-reg-set.h"
  #include "function.h"
  #include "insn-flags.h"
*************** extern int stack_depth;
*** 139,143 ****
  extern int max_stack_depth;
  extern struct obstack permanent_obstack;
! 
  
  static rtx enqueue_insn		PROTO((rtx, rtx));
--- 140,144 ----
  extern int max_stack_depth;
  extern struct obstack permanent_obstack;
! extern rtx arg_pointer_save_area;
  
  static rtx enqueue_insn		PROTO((rtx, rtx));
*************** static void store_constructor	PROTO((tre
*** 151,155 ****
  static rtx store_field		PROTO((rtx, int, int, enum machine_mode, tree,
  				       enum machine_mode, int, int, int));
- static int get_inner_unaligned_p PROTO((tree));
  static tree save_noncopied_parts PROTO((tree, tree));
  static tree init_noncopied_parts PROTO((tree, tree));
--- 152,155 ----
*************** move_by_pieces (to, from, len, align)
*** 1494,1498 ****
  
    /* The code above should have handled everything.  */
!   if (data.len != 0)
      abort ();
  }
--- 1494,1498 ----
  
    /* The code above should have handled everything.  */
!   if (data.len > 0)
      abort ();
  }
*************** emit_move_insn_1 (x, y)
*** 1989,1993 ****
  			     
        /* Show the output dies here.  */
!       emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
  
        for (i = 0;
--- 1989,1994 ----
  			     
        /* Show the output dies here.  */
!       if (x != y)
!         emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
  
        for (i = 0;
*************** expand_assignment (to, from, want_value,
*** 2481,2490 ****
       problem.  */
  
!   if (TREE_CODE (to) == COMPONENT_REF
!       || TREE_CODE (to) == BIT_FIELD_REF
!       || (TREE_CODE (to) == ARRAY_REF
! 	  && ((TREE_CODE (TREE_OPERAND (to, 1)) == INTEGER_CST
! 	       && TREE_CODE (TYPE_SIZE (TREE_TYPE (to))) == INTEGER_CST)
! 	      || (SLOW_UNALIGNED_ACCESS && get_inner_unaligned_p (to)))))
      {
        enum machine_mode mode1;
--- 2482,2487 ----
       problem.  */
  
!   if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
!       || TREE_CODE (to) == ARRAY_REF)
      {
        enum machine_mode mode1;
*************** expand_assignment (to, from, want_value,
*** 2498,2503 ****
  
        push_temp_slots ();
!       tem = get_inner_reference (to, &bitsize, &bitpos, &offset,
! 				      &mode1, &unsignedp, &volatilep);
  
        /* If we are going to use store_bit_field and extract_bit_field,
--- 2495,2500 ----
  
        push_temp_slots ();
!       tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
! 				 &unsignedp, &volatilep, &alignment);
  
        /* If we are going to use store_bit_field and extract_bit_field,
*************** expand_assignment (to, from, want_value,
*** 2507,2511 ****
  	tem = stabilize_reference (tem);
  
-       alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
        to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
        if (offset != 0)
--- 2504,2507 ----
*************** expand_assignment (to, from, want_value,
*** 2518,2529 ****
  				   gen_rtx (PLUS, ptr_mode, XEXP (to_rtx, 0),
  					    force_reg (ptr_mode, offset_rtx)));
- 	  /* If we have a variable offset, the known alignment
- 	     is only that of the innermost structure containing the field.
- 	     (Actually, we could sometimes do better by using the
- 	     align of an element of the innermost array, but no need.)  */
- 	  if (TREE_CODE (to) == COMPONENT_REF
- 	      || TREE_CODE (to) == BIT_FIELD_REF)
- 	    alignment
- 	      = TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (to, 0))) / BITS_PER_UNIT;
  	}
        if (volatilep)
--- 2514,2517 ----
*************** expand_assignment (to, from, want_value,
*** 2535,2539 ****
  		 We must make a new MEM before setting the volatile bit.  */
  	      if (offset == 0)
! 		to_rtx = change_address (to_rtx, VOIDmode, XEXP (to_rtx, 0));
  	      MEM_VOLATILE_P (to_rtx) = 1;
  	    }
--- 2523,2527 ----
  		 We must make a new MEM before setting the volatile bit.  */
  	      if (offset == 0)
! 		to_rtx = copy_rtx (to_rtx);
  	      MEM_VOLATILE_P (to_rtx) = 1;
  	    }
*************** store_expr (exp, target, want_value)
*** 2775,2780 ****
  	 which will often result in some optimizations.  Do the conversion
  	 in two steps: first change the signedness, if needed, then
! 	 the extend.  */
!       if (! want_value)
  	{
  	  if (TREE_UNSIGNED (TREE_TYPE (exp))
--- 2763,2771 ----
  	 which will often result in some optimizations.  Do the conversion
  	 in two steps: first change the signedness, if needed, then
! 	 the extend.  But don't do this if the type of EXP is a subtype
! 	 of something else since then the conversion might involve
! 	 more than just converting modes.  */
!       if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
! 	  && TREE_TYPE (TREE_TYPE (exp)) == 0)
  	{
  	  if (TREE_UNSIGNED (TREE_TYPE (exp))
*************** store_expr (exp, target, want_value)
*** 2843,2847 ****
       Convert the value to TARGET's type first if nec.  */
  
!   if (temp != target && TREE_CODE (exp) != ERROR_MARK)
      {
        target = protect_from_queue (target, 1);
--- 2834,2838 ----
       Convert the value to TARGET's type first if nec.  */
  
!   if (! rtx_equal_p (temp, target) && TREE_CODE (exp) != ERROR_MARK)
      {
        target = protect_from_queue (target, 1);
*************** store_constructor (exp, target)
*** 3071,3074 ****
--- 3062,3073 ----
  	    }
  
+ 	  if (TREE_READONLY (field))
+ 	    {
+ 	      if (GET_CODE (to_rtx) == MEM)
+ 		to_rtx = copy_rtx (to_rtx);
+ 
+ 	      RTX_UNCHANGING_P (to_rtx) = 1;
+ 	    }
+ 
  	  store_field (to_rtx, bitsize, bitpos, mode, TREE_VALUE (elt),
  		       /* The alignment of TARGET is
*************** store_field (target, bitsize, bitpos, mo
*** 3414,3417 ****
--- 3413,3428 ----
        rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
  
+       /* If BITSIZE is narrower than the size of the type of EXP
+ 	 we will be narrowing TEMP.  Normally, what's wanted are the
+ 	 low-order bits.  However, if EXP's type is a record and this is
+ 	 big-endian machine, we want the upper BITSIZE bits.  */
+       if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
+ 	  && bitsize < GET_MODE_BITSIZE (GET_MODE (temp))
+ 	  && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
+ 	temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
+ 			     size_int (GET_MODE_BITSIZE (GET_MODE (temp))
+ 				       - bitsize),
+ 			     temp, 1);
+ 
        /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
  	 MODE.  */
*************** store_field (target, bitsize, bitpos, mo
*** 3420,3423 ****
--- 3431,3455 ----
  	temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
  
+       /* If the modes of TARGET and TEMP are both BLKmode, both
+ 	 must be in memory and BITPOS must be aligned on a byte
+ 	 boundary.  If so, we simply do a block copy.  */
+       if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
+ 	{
+ 	  if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
+ 	      || bitpos % BITS_PER_UNIT != 0)
+ 	    abort ();
+ 
+ 	  target = change_address (target, VOIDmode,
+ 				   plus_constant (XEXP (target, 0),
+ 						  bitpos / BITS_PER_UNIT));
+ 
+ 	  emit_block_move (target, temp,
+ 			   GEN_INT ((bitsize + BITS_PER_UNIT - 1)
+ 				    / BITS_PER_UNIT),
+ 			   1);
+ 
+ 	  return value_mode == VOIDmode ? const0_rtx : target;
+ 	}
+ 
        /* Store the value in the bitfield.  */
        store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
*************** store_field (target, bitsize, bitpos, mo
*** 3466,3471 ****
        /* Now build a reference to just the desired component.  */
  
!       to_rtx = change_address (target, mode,
! 			       plus_constant (addr, (bitpos / BITS_PER_UNIT)));
        MEM_IN_STRUCT_P (to_rtx) = 1;
  
--- 3498,3505 ----
        /* Now build a reference to just the desired component.  */
  
!       to_rtx
! 	= copy_rtx (change_address (target, mode,
! 				    plus_constant (addr,
! 						   (bitpos / BITS_PER_UNIT))));
        MEM_IN_STRUCT_P (to_rtx) = 1;
  
*************** store_field (target, bitsize, bitpos, mo
*** 3474,3508 ****
  }
  
- /* Return true if any object containing the innermost array is an unaligned
-    packed structure field.  */
- 
- static int
- get_inner_unaligned_p (exp)
-      tree exp;
- {
-   int needed_alignment = TYPE_ALIGN (TREE_TYPE (exp));
- 
-   while (1)
-     {
-       if (TREE_CODE (exp) == COMPONENT_REF || TREE_CODE (exp) == BIT_FIELD_REF)
- 	{
- 	  if (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
- 	      < needed_alignment)
- 	    return 1;
- 	}
-       else if (TREE_CODE (exp) != ARRAY_REF
- 	       && TREE_CODE (exp) != NON_LVALUE_EXPR
- 	       && ! ((TREE_CODE (exp) == NOP_EXPR
- 		      || TREE_CODE (exp) == CONVERT_EXPR)
- 		     && (TYPE_MODE (TREE_TYPE (exp))
- 			 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
- 	break;
- 
-       exp = TREE_OPERAND (exp, 0);
-     }
- 
-   return 0;
- }
- 
  /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
     or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
--- 3508,3511 ----
*************** get_inner_unaligned_p (exp)
*** 3515,3518 ****
--- 3518,3524 ----
     This offset is in addition to the bit position.
     If the position is not variable, we store 0 in *POFFSET.
+    We set *PALIGNMENT to the alignment in bytes of the address that will be
+    computed.  This is the alignment of the thing we return if *POFFSET
+    is zero, but can be more less strictly aligned if *POFFSET is nonzero.
  
     If any of the extraction expressions is volatile,
*************** get_inner_unaligned_p (exp)
*** 3525,3533 ****
     If the field describes a variable-sized object, *PMODE is set to
     VOIDmode and *PBITSIZE is set to -1.  An access cannot be made in
!    this case, but the address of the object can be found.  */
  
  tree
  get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
! 		     punsignedp, pvolatilep)
       tree exp;
       int *pbitsize;
--- 3531,3539 ----
     If the field describes a variable-sized object, *PMODE is set to
     VOIDmode and *PBITSIZE is set to -1.  An access cannot be made in
!    this case, but the address of the object can be found.   */
  
  tree
  get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
! 		     punsignedp, pvolatilep, palignment)
       tree exp;
       int *pbitsize;
*************** get_inner_reference (exp, pbitsize, pbit
*** 3537,3540 ****
--- 3543,3547 ----
       int *punsignedp;
       int *pvolatilep;
+      int *palignment;
  {
    tree orig_exp = exp;
*************** get_inner_reference (exp, pbitsize, pbit
*** 3542,3545 ****
--- 3549,3553 ----
    enum machine_mode mode = VOIDmode;
    tree offset = integer_zero_node;
+   int alignment = BIGGEST_ALIGNMENT;
  
    if (TREE_CODE (exp) == COMPONENT_REF)
*************** get_inner_reference (exp, pbitsize, pbit
*** 3599,3607 ****
  
  	  *pbitpos += TREE_INT_CST_LOW (constant);
! 
! 	  if (var)
! 	    offset = size_binop (PLUS_EXPR, offset,
! 				 size_binop (EXACT_DIV_EXPR, var,
! 					     size_int (BITS_PER_UNIT)));
  	}
  
--- 3607,3613 ----
  
  	  *pbitpos += TREE_INT_CST_LOW (constant);
! 	  offset = size_binop (PLUS_EXPR, offset,
! 			       size_binop (EXACT_DIV_EXPR, var,
! 					   size_int (BITS_PER_UNIT)));
  	}
  
*************** get_inner_reference (exp, pbitsize, pbit
*** 3629,3633 ****
  
  	  index = fold (build (MULT_EXPR, index_type, index,
! 			       TYPE_SIZE (TREE_TYPE (exp))));
  
  	  if (TREE_CODE (index) == INTEGER_CST
--- 3635,3640 ----
  
  	  index = fold (build (MULT_EXPR, index_type, index,
! 			       convert (index_type,
! 					TYPE_SIZE (TREE_TYPE (exp)))));
  
  	  if (TREE_CODE (index) == INTEGER_CST
*************** get_inner_reference (exp, pbitsize, pbit
*** 3652,3666 ****
        if (TREE_THIS_VOLATILE (exp))
  	*pvolatilep = 1;
        exp = TREE_OPERAND (exp, 0);
      }
  
!   /* If this was a bit-field, see if there is a mode that allows direct
!      access in case EXP is in memory.  */
!   if (mode == VOIDmode && *pbitsize != 0 && *pbitpos % *pbitsize == 0)
!     {
!       mode = mode_for_size (*pbitsize, MODE_INT, 0);
!       if (mode == BLKmode)
! 	mode = VOIDmode;
!     }
  
    if (integer_zerop (offset))
--- 3659,3675 ----
        if (TREE_THIS_VOLATILE (exp))
  	*pvolatilep = 1;
+ 
+       /* If the offset is non-constant already, then we can't assume any
+ 	 alignment more than the alignment here.  */
+       if (! integer_zerop (offset))
+ 	alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
+ 
        exp = TREE_OPERAND (exp, 0);
      }
  
!   if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
!     alignment = MIN (alignment, DECL_ALIGN (exp));
!   else if (TREE_TYPE (exp) != 0)
!     alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
  
    if (integer_zerop (offset))
*************** get_inner_reference (exp, pbitsize, pbit
*** 3672,3675 ****
--- 3681,3685 ----
    *pmode = mode;
    *poffset = offset;
+   *palignment = alignment / BITS_PER_UNIT;
    return exp;
  }
*************** init_noncopied_parts (lhs, list)
*** 3812,3820 ****
  }
  
! /* Subroutine of expand_expr: return nonzero iff there is no way that
     EXP can reference X, which is being modified.  */
  
  static int
! safe_from_p (x, exp)
       rtx x;
       tree exp;
--- 3822,3834 ----
  }
  
! static int safe_from_p_count;
! static int safe_from_p_size;
! static tree *safe_from_p_rewritten;
! 
! /* Subroutine of safe_from_p: return nonzero iff there is no way that
     EXP can reference X, which is being modified.  */
  
  static int
! safe_from_p_1 (x, exp)
       rtx x;
       tree exp;
*************** safe_from_p (x, exp)
*** 3822,3825 ****
--- 3836,3840 ----
    rtx exp_rtl = 0;
    int i, nops;
+   int is_save_expr = 0;
  
    if (x == 0
*************** safe_from_p (x, exp)
*** 3860,3878 ****
  
      case 'x':
!       if (TREE_CODE (exp) == TREE_LIST)
! 	return ((TREE_VALUE (exp) == 0
! 		 || safe_from_p (x, TREE_VALUE (exp)))
! 		&& (TREE_CHAIN (exp) == 0
! 		    || safe_from_p (x, TREE_CHAIN (exp))));
!       else
! 	return 0;
  
      case '1':
!       return safe_from_p (x, TREE_OPERAND (exp, 0));
  
      case '2':
      case '<':
!       return (safe_from_p (x, TREE_OPERAND (exp, 0))
! 	      && safe_from_p (x, TREE_OPERAND (exp, 1)));
  
      case 'e':
--- 3875,3900 ----
  
      case 'x':
!       switch (TREE_CODE (exp))
! 	{
! 	case TREE_LIST:
! 	  return ((TREE_VALUE (exp) == 0
! 		   || safe_from_p_1 (x, TREE_VALUE (exp)))
! 		  && (TREE_CHAIN (exp) == 0
! 		      || safe_from_p_1 (x, TREE_CHAIN (exp))));
! 
! 	case ERROR_MARK:
! 	  return 1;
! 
! 	default:
! 	  return 0;
! 	}
  
      case '1':
!       return safe_from_p_1 (x, TREE_OPERAND (exp, 0));
  
      case '2':
      case '<':
!       return (safe_from_p_1 (x, TREE_OPERAND (exp, 0))
! 	      && safe_from_p_1 (x, TREE_OPERAND (exp, 1)));
  
      case 'e':
*************** safe_from_p (x, exp)
*** 3887,3891 ****
  	case ADDR_EXPR:
  	  return (staticp (TREE_OPERAND (exp, 0))
! 		  || safe_from_p (x, TREE_OPERAND (exp, 0)));
  
  	case INDIRECT_REF:
--- 3909,3913 ----
  	case ADDR_EXPR:
  	  return (staticp (TREE_OPERAND (exp, 0))
! 		  || safe_from_p_1 (x, TREE_OPERAND (exp, 0)));
  
  	case INDIRECT_REF:
*************** safe_from_p (x, exp)
*** 3922,3928 ****
  
  	case CLEANUP_POINT_EXPR:
! 	  return safe_from_p (x, TREE_OPERAND (exp, 0));
  
  	case SAVE_EXPR:
  	  exp_rtl = SAVE_EXPR_RTL (exp);
  	  break;
--- 3944,3951 ----
  
  	case CLEANUP_POINT_EXPR:
! 	  return safe_from_p_1 (x, TREE_OPERAND (exp, 0));
  
  	case SAVE_EXPR:
+ 	  is_save_expr = 1;
  	  exp_rtl = SAVE_EXPR_RTL (exp);
  	  break;
*************** safe_from_p (x, exp)
*** 3931,3935 ****
  	  /* The only operand we look at is operand 1.  The rest aren't
  	     part of the expression.  */
! 	  return safe_from_p (x, TREE_OPERAND (exp, 1));
  
  	case METHOD_CALL_EXPR:
--- 3954,3958 ----
  	  /* The only operand we look at is operand 1.  The rest aren't
  	     part of the expression.  */
! 	  return safe_from_p_1 (x, TREE_OPERAND (exp, 1));
  
  	case METHOD_CALL_EXPR:
*************** safe_from_p (x, exp)
*** 3945,3949 ****
        for (i = 0; i < nops; i++)
  	if (TREE_OPERAND (exp, i) != 0
! 	    && ! safe_from_p (x, TREE_OPERAND (exp, i)))
  	  return 0;
      }
--- 3968,3972 ----
        for (i = 0; i < nops; i++)
  	if (TREE_OPERAND (exp, i) != 0
! 	    && ! safe_from_p_1 (x, TREE_OPERAND (exp, i)))
  	  return 0;
      }
*************** safe_from_p (x, exp)
*** 3969,3975 ****
--- 3992,4054 ----
  
    /* If we reach here, it is safe.  */
+   if (is_save_expr)
+     {
+       /* This SAVE_EXPR might appear many times in the top-level
+ 	 safe_from_p() expression, and if it has a complex
+ 	 subexpression, examining it multiple times could result
+ 	 in a combinatorial explosion.  E.g. on an Alpha Cabriolet
+ 	 running at least 200MHz, a Fortran test case compiled with
+ 	 optimization took about 28 minutes to compile -- even though
+ 	 it was only a few lines long, and the complicated line causing
+ 	 so much time to be spent in the earlier version of safe_from_p()
+ 	 had only 293 or so unique nodes.
+ 
+ 	 So, turn this SAVE_EXPR into an ERROR_MARK for now, but remember
+ 	 where it is so we can turn it back in the top-level safe_from_p()
+ 	 when we're done.  */
+ 
+       if (safe_from_p_count >= safe_from_p_size)
+ 	return 0;	/* For now, don't bother re-sizing the array. */
+       safe_from_p_rewritten[safe_from_p_count++] = exp;
+       TREE_SET_CODE (exp, ERROR_MARK);
+     }
+ 
    return 1;
  }
  
+ /* Subroutine of expand_expr: return nonzero iff there is no way that
+    EXP can reference X, which is being modified.  */
+ 
+ static int
+ safe_from_p (x, exp)
+      rtx x;
+      tree exp;
+ {
+   int rtn;
+   int i;
+   tree trees[128];
+ 
+   safe_from_p_count = 0;
+   safe_from_p_size = sizeof (trees) / sizeof (trees[0]);
+   safe_from_p_rewritten = &trees[0];
+ 
+   rtn = safe_from_p_1 (x, exp);
+ 
+ #if 0
+   if (safe_from_p_count != 0)
+     fprintf (stderr, "%s:%d: safe_from_p_count = %d\n",
+ 	     input_filename, lineno, safe_from_p_count);
+ #endif
+ 
+   for (i = 0; i < safe_from_p_count; ++i)
+     {
+       if (TREE_CODE (trees [i]) != ERROR_MARK)
+ 	abort ();
+       TREE_SET_CODE (trees[i], SAVE_EXPR);
+     }
+ 
+   return rtn;
+ }
+ 
  /* Subroutine of expand_expr: return nonzero iff EXP is an
     expression whose type is statically determinable.  */
*************** expand_expr (exp, target, tmode, modifie
*** 4300,4303 ****
--- 4379,4387 ----
        context = decl_function_context (exp);
  
+       /* If this SAVE_EXPR was at global context, assume we are an
+ 	 initialization function and move it into our context.  */
+       if (context == 0)
+ 	SAVE_EXPR_CONTEXT (exp) = current_function_decl;
+ 
        /* We treat inline_function_decl as an alias for the current function
  	 because that is the inline function whose vars, types, etc.
*************** expand_expr (exp, target, tmode, modifie
*** 4310,4313 ****
--- 4394,4401 ----
        if (context)
  	{
+ 	  /* The following call just exists to abort if the context is
+ 	     not of a containing function.  */
+ 	  find_function_data (context);
+ 
  	  temp = SAVE_EXPR_RTL (exp);
  	  if (temp && GET_CODE (temp) == REG)
*************** expand_expr (exp, target, tmode, modifie
*** 4381,4400 ****
        if (placeholder_list)
  	{
! 	  tree object;
  	  tree old_list = placeholder_list;
  
! 	  for (object = TREE_PURPOSE (placeholder_list);
! 	       (TYPE_MAIN_VARIANT (TREE_TYPE (object))
! 		!= TYPE_MAIN_VARIANT (type))
! 	       && (TREE_CODE_CLASS (TREE_CODE (object)) == 'r'
! 		   || TREE_CODE_CLASS (TREE_CODE (object)) == '1'
! 		   || TREE_CODE_CLASS (TREE_CODE (object)) == '2'
! 		   || TREE_CODE_CLASS (TREE_CODE (object)) == 'e');
! 	       object = TREE_OPERAND (object, 0))
! 	    ;
! 
! 	  if (object != 0
! 	      && (TYPE_MAIN_VARIANT (TREE_TYPE (object))
! 		  == TYPE_MAIN_VARIANT (type)))
  	    {
  	      /* Expand this object skipping the list entries before
--- 4469,4501 ----
        if (placeholder_list)
  	{
! 	  tree need_type = TYPE_MAIN_VARIANT (type);
! 	  tree object = 0;
  	  tree old_list = placeholder_list;
+ 	  tree elt;
+ 
+ 	  /* See if the object is the type that we want.  */
+ 	  if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_PURPOSE (placeholder_list)))
+ 	       == need_type))
+ 	    object = TREE_PURPOSE (placeholder_list);
+ 
+ 	  /* Find the innermost reference that is of the type we want.  */
+ 	  for (elt = TREE_PURPOSE (placeholder_list);
+ 	       elt != 0
+ 	       && (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
+ 		   || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
+ 		   || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
+ 		   || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e');
+ 	       elt = ((TREE_CODE (elt) == COMPOUND_EXPR
+ 		       || TREE_CODE (elt) == COND_EXPR)
+ 		      ? TREE_OPERAND (elt, 1) : TREE_OPERAND (elt, 0)))
+ 	    if (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
+ 		&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (elt, 0)))
+ 		    == need_type))
+ 	      {
+ 		object = TREE_OPERAND (elt, 0);
+ 		break;
+ 	      }
  
! 	  if (object != 0)
  	    {
  	      /* Expand this object skipping the list entries before
*************** expand_expr (exp, target, tmode, modifie
*** 4534,4537 ****
--- 4635,4647 ----
  		}
  	    }
+ 
+ 	  if (TREE_READONLY (exp))
+ 	    {
+ 	      if (GET_CODE (target) == MEM)
+ 		target = copy_rtx (target);
+ 
+ 	      RTX_UNCHANGING_P (target) = 1;
+ 	    }
+ 
  	  store_constructor (exp, target);
  	  return target;
*************** expand_expr (exp, target, tmode, modifie
*** 4543,4567 ****
  	tree exp2;
  
! 	/* A SAVE_EXPR as the address in an INDIRECT_EXPR is generated
! 	   for  *PTR += ANYTHING  where PTR is put inside the SAVE_EXPR.
! 	   This code has the same general effect as simply doing
! 	   expand_expr on the save expr, except that the expression PTR
! 	   is computed for use as a memory address.  This means different
! 	   code, suitable for indexing, may be generated.  */
! 	if (TREE_CODE (exp1) == SAVE_EXPR
! 	    && SAVE_EXPR_RTL (exp1) == 0
! 	    && TYPE_MODE (TREE_TYPE (exp1)) == ptr_mode)
! 	  {
! 	    temp = expand_expr (TREE_OPERAND (exp1, 0), NULL_RTX,
! 				VOIDmode, EXPAND_SUM);
! 	    op0 = memory_address (mode, temp);
! 	    op0 = copy_all_regs (op0);
! 	    SAVE_EXPR_RTL (exp1) = op0;
! 	  }
! 	else
! 	  {
! 	    op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
! 	    op0 = memory_address (mode, op0);
! 	  }
  
  	temp = gen_rtx (MEM, mode, op0);
--- 4653,4658 ----
  	tree exp2;
  
! 	op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
! 	op0 = memory_address (mode, op0);
  
  	temp = gen_rtx (MEM, mode, op0);
*************** expand_expr (exp, target, tmode, modifie
*** 4597,4605 ****
  	tree index = TREE_OPERAND (exp, 1);
  	tree index_type = TREE_TYPE (index);
! 	int i;
! 
! 	if (TREE_CODE (low_bound) != INTEGER_CST
! 	    && contains_placeholder_p (low_bound))
! 	  low_bound = build (WITH_RECORD_EXPR, sizetype, low_bound, exp);
  
  	/* Optimize the special-case of a zero lower bound.
--- 4688,4692 ----
  	tree index = TREE_OPERAND (exp, 1);
  	tree index_type = TREE_TYPE (index);
! 	HOST_WIDE_INT i;
  
  	/* Optimize the special-case of a zero lower bound.
*************** expand_expr (exp, target, tmode, modifie
*** 4618,4684 ****
  			       convert (sizetype, low_bound)));
  
- 	if ((TREE_CODE (index) != INTEGER_CST
- 	     || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
- 	    && (! SLOW_UNALIGNED_ACCESS || ! get_inner_unaligned_p (exp)))
- 	  {
- 	    /* Nonconstant array index or nonconstant element size, and
- 	       not an array in an unaligned (packed) structure field.
- 	       Generate the tree for *(&array+index) and expand that,
- 	       except do it in a language-independent way
- 	       and don't complain about non-lvalue arrays.
- 	       `mark_addressable' should already have been called
- 	       for any array for which this case will be reached.  */
- 
- 	    /* Don't forget the const or volatile flag from the array
- 	       element. */
- 	    tree variant_type = build_type_variant (type,
- 						    TREE_READONLY (exp),
- 						    TREE_THIS_VOLATILE (exp));
- 	    tree array_adr = build1 (ADDR_EXPR,
- 				     build_pointer_type (variant_type), array);
- 	    tree elt;
- 	    tree size = size_in_bytes (type);
- 
- 	    /* Convert the integer argument to a type the same size as sizetype
- 	       so the multiply won't overflow spuriously.  */
- 	    if (TYPE_PRECISION (index_type) != TYPE_PRECISION (sizetype))
- 	      index = convert (type_for_size (TYPE_PRECISION (sizetype), 0),
- 			       index);
- 
- 	    if (TREE_CODE (size) != INTEGER_CST
- 		&& contains_placeholder_p (size))
- 	      size = build (WITH_RECORD_EXPR, sizetype, size, exp);
- 
- 	    /* Don't think the address has side effects
- 	       just because the array does.
- 	       (In some cases the address might have side effects,
- 	       and we fail to record that fact here.  However, it should not
- 	       matter, since expand_expr should not care.)  */
- 	    TREE_SIDE_EFFECTS (array_adr) = 0;
- 
- 	    elt
- 	      = build1
- 		(INDIRECT_REF, type,
- 		 fold (build (PLUS_EXPR,
- 			      TYPE_POINTER_TO (variant_type),
- 			      array_adr,
- 			      fold
- 			      (build1
- 			       (NOP_EXPR,
- 				TYPE_POINTER_TO (variant_type),
- 				fold (build (MULT_EXPR, TREE_TYPE (index),
- 					     index,
- 					     convert (TREE_TYPE (index),
- 						      size))))))));;
- 
- 	    /* Volatility, etc., of new expression is same as old
- 	       expression.  */
- 	    TREE_SIDE_EFFECTS (elt) = TREE_SIDE_EFFECTS (exp);
- 	    TREE_THIS_VOLATILE (elt) = TREE_THIS_VOLATILE (exp);
- 	    TREE_READONLY (elt) = TREE_READONLY (exp);
- 
- 	    return expand_expr (elt, target, tmode, modifier);
- 	  }
- 
  	/* Fold an expression like: "foo"[2].
  	   This is not done in fold so it won't happen inside &.
--- 4705,4708 ----
*************** expand_expr (exp, target, tmode, modifie
*** 4720,4725 ****
  		 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
  	  {
! 	    if (TREE_CODE (index) == INTEGER_CST
! 		&& TREE_INT_CST_HIGH (index) == 0)
  	      {
  		tree init = DECL_INITIAL (array);
--- 4744,4748 ----
  		 && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
  	  {
! 	    if (TREE_CODE (index) == INTEGER_CST)
  	      {
  		tree init = DECL_INITIAL (array);
*************** expand_expr (exp, target, tmode, modifie
*** 4738,4748 ****
  		  }
  		else if (TREE_CODE (init) == STRING_CST
! 			 && i < TREE_STRING_LENGTH (init))
! 		  return GEN_INT (TREE_STRING_POINTER (init)[i]);
  	      }
  	  }
        }
  
!       /* Treat array-ref with constant index as a component-ref.  */
  
      case COMPONENT_REF:
--- 4761,4775 ----
  		  }
  		else if (TREE_CODE (init) == STRING_CST
! 			 && TREE_INT_CST_HIGH (index) == 0
! 			 && (TREE_INT_CST_LOW (index)
! 			     < TREE_STRING_LENGTH (init)))
! 		  return (GEN_INT
! 			  (TREE_STRING_POINTER
! 			   (init)[TREE_INT_CST_LOW (index)]));
  	      }
  	  }
        }
  
!       /* ... fall through ... */
  
      case COMPONENT_REF:
*************** expand_expr (exp, target, tmode, modifie
*** 4770,4776 ****
  	tree offset;
  	int volatilep = 0;
- 	tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
- 					&mode1, &unsignedp, &volatilep);
  	int alignment;
  
  	/* If we got back the original object, something is wrong.  Perhaps
--- 4797,4804 ----
  	tree offset;
  	int volatilep = 0;
  	int alignment;
+ 	tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
+ 					&mode1, &unsignedp, &volatilep,
+ 					&alignment);
  
  	/* If we got back the original object, something is wrong.  Perhaps
*************** expand_expr (exp, target, tmode, modifie
*** 4793,4797 ****
  				!= INTEGER_CST)
  			    ? target : NULL_RTX),
! 			   VOIDmode, EXPAND_SUM);
  
  	/* If this is a constant, put it into a register if it is a
--- 4821,4826 ----
  				!= INTEGER_CST)
  			    ? target : NULL_RTX),
! 			   VOIDmode,
! 			   modifier == EXPAND_INITIALIZER ? modifier : 0);
  
  	/* If this is a constant, put it into a register if it is a
*************** expand_expr (exp, target, tmode, modifie
*** 4806,4810 ****
  	  }
  
- 	alignment = TYPE_ALIGN (TREE_TYPE (tem)) / BITS_PER_UNIT;
  	if (offset != 0)
  	  {
--- 4835,4838 ----
*************** expand_expr (exp, target, tmode, modifie
*** 4816,4827 ****
  				  gen_rtx (PLUS, ptr_mode, XEXP (op0, 0),
  					   force_reg (ptr_mode, offset_rtx)));
- 	  /* If we have a variable offset, the known alignment
- 	     is only that of the innermost structure containing the field.
- 	     (Actually, we could sometimes do better by using the
- 	     size of an element of the innermost array, but no need.)  */
- 	  if (TREE_CODE (exp) == COMPONENT_REF
- 	      || TREE_CODE (exp) == BIT_FIELD_REF)
- 	    alignment = (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
- 			 / BITS_PER_UNIT);
  	  }
  
--- 4844,4847 ----
*************** expand_expr (exp, target, tmode, modifie
*** 4844,4848 ****
  		&& modifier != EXPAND_SUM
  		&& modifier != EXPAND_INITIALIZER
! 		&& ((mode1 != BLKmode && ! direct_load[(int) mode1])
  		    /* If the field isn't aligned enough to fetch as a memref,
  		       fetch it as a bit field.  */
--- 4864,4870 ----
  		&& modifier != EXPAND_SUM
  		&& modifier != EXPAND_INITIALIZER
! 		&& ((mode1 != BLKmode && ! direct_load[(int) mode1]
! 		     && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
! 		     && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
  		    /* If the field isn't aligned enough to fetch as a memref,
  		       fetch it as a bit field.  */
*************** expand_expr (exp, target, tmode, modifie
*** 4857,4861 ****
  
  	    if (ext_mode == BLKmode)
! 	      abort ();
  
  	    op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
--- 4879,4907 ----
  
  	    if (ext_mode == BLKmode)
! 	      {
! 		/* In this case, BITPOS must start at a byte boundary and
! 		   TARGET, if specified, must be a MEM.  */
! 		if (GET_CODE (op0) != MEM
! 		    || (target != 0 && GET_CODE (target) != MEM)
! 		    || bitpos % BITS_PER_UNIT != 0)
! 		  abort ();
! 
! 		op0 = change_address (op0, VOIDmode,
! 				      plus_constant (XEXP (op0, 0),
! 						     bitpos / BITS_PER_UNIT));
! 		if (target == 0)
! 		  {
! 		    target
! 		      = assign_stack_temp (mode, int_size_in_bytes (type), 0);
! 		    MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (type);
! 		  }
! 
! 		emit_block_move (target, op0,
! 				 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
! 					  / BITS_PER_UNIT),
! 				 1);
! 		
! 		return target;
! 	      }
  
  	    op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
*************** expand_expr (exp, target, tmode, modifie
*** 4863,4866 ****
--- 4909,4924 ----
  				     alignment,
  				     int_size_in_bytes (TREE_TYPE (tem)));
+ 
+ 	    /* If the result is a record type and BITSIZE is narrower than
+ 	       the mode of OP0, an integral mode, and this is a big endian
+ 	       machine, we must put the field into the high-order bits.  */
+ 	    if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
+ 		&& GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
+ 		&& bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
+ 	      op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
+ 				  size_int (GET_MODE_BITSIZE (GET_MODE (op0))
+ 					    - bitsize),
+ 				  op0, 1);
+ 
  	    if (mode == BLKmode)
  	      {
*************** expand_expr (exp, target, tmode, modifie
*** 4877,4880 ****
--- 4935,4943 ----
  	  }
  
+ 	/* If the result is BLKmode, use that to access the object
+ 	   now as well.  */
+ 	if (mode == BLKmode)
+ 	  mode1 = BLKmode;
+ 
  	/* Get a reference to just this component.  */
  	if (modifier == EXPAND_CONST_ADDRESS
*************** expand_expr (exp, target, tmode, modifie
*** 4883,4895 ****
  						    (bitpos / BITS_PER_UNIT)));
  	else
! 	  op0 = change_address (op0, mode1,
! 				plus_constant (XEXP (op0, 0),
! 					       (bitpos / BITS_PER_UNIT)));
  	MEM_IN_STRUCT_P (op0) = 1;
  	MEM_VOLATILE_P (op0) |= volatilep;
! 	if (mode == mode1 || mode1 == BLKmode || mode1 == tmode)
  	  return op0;
! 	if (target == 0)
  	  target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
  	convert_move (target, op0, unsignedp);
  	return target;
--- 4946,4964 ----
  						    (bitpos / BITS_PER_UNIT)));
  	else
! 	  op0
! 	    = copy_rtx
! 	      (change_address (op0, mode1,
! 			       plus_constant (XEXP (op0, 0),
! 					      (bitpos / BITS_PER_UNIT))));
! 
  	MEM_IN_STRUCT_P (op0) = 1;
  	MEM_VOLATILE_P (op0) |= volatilep;
! 	if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
! 	    || modifier == EXPAND_CONST_ADDRESS
! 	    || modifier == EXPAND_INITIALIZER)
  	  return op0;
! 	else if (target == 0)
  	  target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
+ 
  	convert_move (target, op0, unsignedp);
  	return target;
*************** expand_expr (exp, target, tmode, modifie
*** 6199,6203 ****
  	if (TREE_CODE (lhs) != VAR_DECL
  	    && TREE_CODE (lhs) != RESULT_DECL
! 	    && TREE_CODE (lhs) != PARM_DECL)
  	  preexpand_calls (exp);
  
--- 6268,6274 ----
  	if (TREE_CODE (lhs) != VAR_DECL
  	    && TREE_CODE (lhs) != RESULT_DECL
! 	    && TREE_CODE (lhs) != PARM_DECL
! 	    && ! (TREE_CODE (lhs) == INDIRECT_REF
! 		  && TYPE_READONLY (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
  	  preexpand_calls (exp);
  
*************** expand_builtin (exp, target, subtarget, 
*** 7986,7989 ****
--- 8057,8295 ----
  #endif
  
+       /* __builtin_setjmp is passed a pointer to an array of five words
+ 	 (not all will be used on all machines).  It operates similarly to
+ 	 the C library function of the same name, but is more efficient.
+ 	 Much of the code below (and for longjmp) is copied from the handling
+ 	 of non-local gotos.
+ 
+ 	 NOTE: This is intended for use by GNAT and will only work in
+ 	 the method used by it.  This code will likely NOT survive to 
+ 	 the GCC 2.8.0 release.  */
+     case BUILT_IN_SETJMP:
+       if (arglist == 0
+ 	  || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
+ 	break;
+ 
+       {
+ 	rtx buf_addr = expand_expr (TREE_VALUE (arglist), subtarget,
+ 				    VOIDmode, 0);
+ 	rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
+ 	enum machine_mode sa_mode = Pmode;
+ 	rtx stack_save;
+ 	int old_inhibit_defer_pop = inhibit_defer_pop;
+ 	int return_pops = RETURN_POPS_ARGS (get_identifier ("__dummy"),
+ 					    get_identifier ("__dummy"), 0);
+ 	rtx next_arg_reg;
+ 	CUMULATIVE_ARGS args_so_far;
+ 	int current_call_is_indirect = 1;
+ 	int i;
+ 
+ #ifdef POINTERS_EXTEND_UNSIGNED
+ 	buf_addr = convert_memory_address (Pmode, buf_addr);
+ #endif
+ 
+ 	buf_addr = force_reg (Pmode, buf_addr);
+ 
+ 	if (target == 0 || GET_CODE (target) != REG
+ 	    || REGNO (target) < FIRST_PSEUDO_REGISTER)
+ 	  target = gen_reg_rtx (value_mode);
+ 
+ 	emit_queue ();
+ 
+ 	CONST_CALL_P (emit_note (NULL_PTR, NOTE_INSN_SETJMP)) = 1;
+ 	current_function_calls_setjmp = 1;
+ 
+ 	/* We store the frame pointer and the address of lab1 in the buffer
+ 	   and use the rest of it for the stack save area, which is
+ 	   machine-dependent.  */
+ 	emit_move_insn (gen_rtx (MEM, Pmode, buf_addr),
+ 			virtual_stack_vars_rtx);
+ 	emit_move_insn
+ 	  (validize_mem (gen_rtx (MEM, Pmode,
+ 				  plus_constant (buf_addr,
+ 						 GET_MODE_SIZE (Pmode)))),
+ 	   gen_rtx (LABEL_REF, Pmode, lab1));
+ 
+ #ifdef HAVE_save_stack_nonlocal
+ 	if (HAVE_save_stack_nonlocal)
+ 	  sa_mode = insn_operand_mode[(int) CODE_FOR_save_stack_nonlocal][0];
+ #endif
+ 
+ 	current_function_has_nonlocal_goto = 1;
+ 
+ 	stack_save = gen_rtx (MEM, sa_mode,
+ 			      plus_constant (buf_addr,
+ 					     2 * GET_MODE_SIZE (Pmode)));
+ 	emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
+ 
+ #ifdef HAVE_setjmp
+ 	if (HAVE_setjmp)
+ 	  emit_insn (gen_setjmp ());
+ #endif
+ 
+ 	/* Set TARGET to zero and branch around the other case.  */
+ 	emit_move_insn (target, const0_rtx);
+ 	emit_jump_insn (gen_jump (lab2));
+ 	emit_barrier ();
+ 	emit_label (lab1);
+ 
+ 	/* Note that setjmp clobbers FP when we get here, so we have to
+ 	   make sure it's marked as used by this function. */
+ 	emit_insn (gen_rtx (USE, VOIDmode, hard_frame_pointer_rtx));
+ 
+ 	/* Mark the static chain as clobbered here so life information
+ 	   doesn't get messed up for it.  */
+ 	emit_insn (gen_rtx (CLOBBER, VOIDmode, static_chain_rtx));
+ 
+ 	/* Now put in the code to restore the frame pointer, and argument
+ 	   pointer, if needed.  The code below is from expand_end_bindings
+ 	   in stmt.c; see detailed documentation there.  */
+ #ifdef HAVE_nonlocal_goto
+ 	if (! HAVE_nonlocal_goto)
+ #endif
+ 	  emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
+ 
+ #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+ 	if (fixed_regs[ARG_POINTER_REGNUM])
+ 	  {
+ #ifdef ELIMINABLE_REGS
+ 	    static struct elims {int from, to;} elim_regs[] = ELIMINABLE_REGS;
+ 
+ 	    for (i = 0; i < sizeof elim_regs / sizeof elim_regs[0]; i++)
+ 	      if (elim_regs[i].from == ARG_POINTER_REGNUM
+ 		  && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
+ 		break;
+ 
+ 	    if (i == sizeof elim_regs / sizeof elim_regs [0])
+ #endif
+ 	      {
+ 		/* Now restore our arg pointer from the address at which it
+ 		   was saved in our stack frame.
+ 		   If there hasn't be space allocated for it yet, make
+ 		   some now.  */
+ 		if (arg_pointer_save_area == 0)
+ 		  arg_pointer_save_area
+ 		    = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
+ 		emit_move_insn (virtual_incoming_args_rtx,
+ 				copy_to_reg (arg_pointer_save_area));
+ 	      }
+ 	  }
+ #endif
+ 
+ #ifdef HAVE_nonlocal_goto_receiver
+ 	if (HAVE_nonlocal_goto_receiver)
+ 	  emit_insn (gen_nonlocal_goto_receiver ());
+ #endif
+ 	/* The static chain pointer contains the address of dummy function.
+ 	   We need to call it here to handle some PIC cases of restoring
+ 	   a global pointer.  Then return 1.  */
+ 	op0 = copy_to_mode_reg (Pmode, static_chain_rtx);
+ 
+ 	/* We can't actually call emit_library_call here, so do everything
+ 	   it does, which isn't much for a libfunc with no args.  */
+ 	op0 = memory_address (FUNCTION_MODE, op0);
+ 
+ 	INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE,
+ 			      gen_rtx (SYMBOL_REF, Pmode, "__dummy"));
+ 	next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1);
+ 
+ #ifndef ACCUMULATE_OUTGOING_ARGS
+ #ifdef HAVE_call_pop
+ 	if (HAVE_call_pop)
+ 	  emit_call_insn (gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, op0),
+ 					const0_rtx, next_arg_reg,
+ 					GEN_INT (return_pops)));
+ 	else
+ #endif
+ #endif
+ 
+ #ifdef HAVE_call
+ 	if (HAVE_call)
+ 	  emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, op0),
+ 				    const0_rtx, next_arg_reg, const0_rtx));
+ 	else
+ #endif
+ 	    abort ();
+ 
+ 	emit_move_insn (target, const1_rtx);
+ 	emit_label (lab2);
+ 	return target;
+       }
+ 
+       /* __builtin_longjmp is passed a pointer to an array of five words
+ 	 and a value, which is a dummy.  It's similar to the C library longjmp
+ 	 function but works with __builtin_setjmp above.  */
+     case BUILT_IN_LONGJMP:
+       if (arglist == 0 || TREE_CHAIN (arglist) == 0
+ 	  || TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
+ 	break;
+ 
+       {
+ 	tree dummy_id = get_identifier ("__dummy");
+ 	tree dummy_type = build_function_type (void_type_node, NULL_TREE);
+ 	tree dummy_decl = build_decl (FUNCTION_DECL, dummy_id, dummy_type); 
+ #ifdef POINTERS_EXTEND_UNSIGNED
+ 	rtx buf_addr
+ 	  = force_reg (Pmode,
+ 		       convert_memory_address
+ 		       (Pmode,
+ 			expand_expr (TREE_VALUE (arglist),
+ 				     NULL_RTX, VOIDmode, 0)));
+ #else
+ 	rtx buf_addr
+ 	  = force_reg (Pmode, expand_expr (TREE_VALUE (arglist),
+ 					   NULL_RTX,
+ 					   VOIDmode, 0));
+ #endif
+ 	rtx fp = gen_rtx (MEM, Pmode, buf_addr);
+ 	rtx lab = gen_rtx (MEM, Pmode,
+ 			   plus_constant (buf_addr, GET_MODE_SIZE (Pmode)));
+ 	enum machine_mode sa_mode
+ #ifdef HAVE_save_stack_nonlocal
+ 	  = (HAVE_save_stack_nonlocal
+ 	     ? insn_operand_mode[(int) CODE_FOR_save_stack_nonlocal][0]
+ 	     : Pmode);
+ #else
+ 	= Pmode;
+ #endif
+ 	rtx stack = gen_rtx (MEM, sa_mode,
+ 			     plus_constant (buf_addr,
+ 					    2 * GET_MODE_SIZE (Pmode)));
+ 
+ 	DECL_EXTERNAL (dummy_decl) = 1;
+ 	TREE_PUBLIC (dummy_decl) = 1;
+ 	make_decl_rtl (dummy_decl, NULL_PTR, 1);
+ 
+ 	/* Expand the second expression just for side-effects.  */
+ 	expand_expr (TREE_VALUE (TREE_CHAIN (arglist)),
+ 		     const0_rtx, VOIDmode, 0);
+ 
+ 	assemble_external (dummy_decl);
+ 
+ 	/* Pick up FP, label, and SP from the block and jump.  This code is
+ 	   from expand_goto in stmt.c; see there for detailed comments.  */
+ #if HAVE_nonlocal_goto
+ 	if (HAVE_nonlocal_goto)
+ 	  emit_insn (gen_nonlocal_goto (fp, lab, stack,
+ 					XEXP (DECL_RTL (dummy_decl), 0)));
+       else
+ #endif
+ 	{
+ 	  lab = copy_to_reg (lab);
+ 	  emit_move_insn (hard_frame_pointer_rtx, fp);
+ 	  emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
+ 
+ 	  /* Put in the static chain register the address of the dummy
+ 	     function.  */
+ 	  emit_move_insn (static_chain_rtx, XEXP (DECL_RTL (dummy_decl), 0));
+ 	  emit_insn (gen_rtx (USE, VOIDmode, hard_frame_pointer_rtx));
+ 	  emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
+ 	  emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
+ 	  emit_indirect_jump (lab);
+ 	}
+ 
+ 	return const0_rtx;
+       }
+ 
      default:			/* just do library call, if unknown builtin */
        error ("built-in function `%s' not currently supported",
*************** preexpand_calls (exp)
*** 8688,8701 ****
      case CALL_EXPR:
        /* Do nothing if already expanded.  */
!       if (CALL_EXPR_RTL (exp) != 0)
  	return;
  
!       /* Do nothing to built-in functions.  */
!       if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
! 	  || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL
! 	  || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
! 	  /* Do nothing if the call returns a variable-sized object.  */
! 	  || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp))) != INTEGER_CST)
! 	CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
        return;
  
--- 8994,9008 ----
      case CALL_EXPR:
        /* Do nothing if already expanded.  */
!       if (CALL_EXPR_RTL (exp) != 0
! 	  /* Do nothing if the call returns a variable-sized object.  */
! 	  || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp))) != INTEGER_CST
! 	  /* Do nothing to built-in functions.  */
! 	  || (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
! 	      && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
! 		  == FUNCTION_DECL)
! 	      && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
  	return;
  
!       CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
        return;
  
*************** do_jump (exp, if_false_label, if_true_la
*** 9087,9090 ****
--- 9394,9398 ----
        push_temp_slots ();
        expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
+       preserve_temp_slots (NULL_RTX);
        free_temp_slots ();
        pop_temp_slots ();
*************** do_jump (exp, if_false_label, if_true_la
*** 9103,9111 ****
  	tree offset;
  	int volatilep = 0;
  
  	/* Get description of this reference.  We don't actually care
  	   about the underlying object here.  */
  	get_inner_reference (exp, &bitsize, &bitpos, &offset,
! 			     &mode, &unsignedp, &volatilep);
  
  	type = type_for_size (bitsize, unsignedp);
--- 9411,9421 ----
  	tree offset;
  	int volatilep = 0;
+ 	int alignment;
  
  	/* Get description of this reference.  We don't actually care
  	   about the underlying object here.  */
  	get_inner_reference (exp, &bitsize, &bitpos, &offset,
! 			     &mode, &unsignedp, &volatilep,
! 			     &alignment);
  
  	type = type_for_size (bitsize, unsignedp);
diff -rcp2N gcc-2.7.2.3/expr.h gcc-2.7.2.3.f.2/expr.h
*** gcc-2.7.2.3/expr.h	Fri Oct 27 10:16:56 1995
--- gcc-2.7.2.3.f.2/expr.h	Tue Sep  9 07:01:31 1997
*************** enum direction {none, upward, downward};
*** 229,232 ****
--- 229,272 ----
  #define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode)
  #endif
+ 
+ /* Provide default values for the macros controlling stack checking.  */
+ 
+ #ifndef STACK_CHECK_BUILTIN
+ #define STACK_CHECK_BUILTIN 0
+ #endif
+ 
+ /* The default interval is one page.  */
+ #ifndef STACK_CHECK_PROBE_INTERVAL
+ #define STACK_CHECK_PROBE_INTERVAL 4096
+ #endif
+ 
+ /* The default is to do a store into the stack.  */
+ #ifndef STACK_CHECK_PROBE_LOAD
+ #define STACK_CHECK_PROBE_LOAD 0
+ #endif
+ 
+ /* This value is arbitrary, but should be sufficient for most machines.  */
+ #ifndef STACK_CHECK_PROTECT
+ #define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD)
+ #endif
+ 
+ /* Make the maximum frame size be the largest we can and still only need
+    one probe per function.  */
+ #ifndef STACK_CHECK_MAX_FRAME_SIZE
+ #define STACK_CHECK_MAX_FRAME_SIZE \
+   (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD)
+ #endif
+ 
+ /* This is arbitrary, but should be large enough everywhere.  */
+ #ifndef STACK_CHECK_FIXED_FRAME_SIZE
+ #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD)
+ #endif
+ 
+ /* Provide a reasonable default for the maximum size of an object to
+    allocate in the fixed frame.  We may need to be able to make this
+    controllable by the user at some point.  */
+ #ifndef STACK_CHECK_MAX_VAR_SIZE
+ #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100)
+ #endif
  
  /* Optabs are tables saying how to generate insn bodies
*************** extern void emit_stack_restore PROTO((en
*** 828,831 ****
--- 868,878 ----
     says how many bytes.  */
  extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int));
+ 
+ /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. 
+    FIRST is a constant and size is a Pmode RTX.  These are offsets from the
+    current stack pointer.  STACK_GROWS_DOWNWARD says whether to add or
+    subtract from the stack.  If SIZE is constant, this is done
+    with a fixed number of probes.  Otherwise, we must make a loop.  */
+ extern void probe_stack_range PROTO((HOST_WIDE_INT, rtx));
  
  /* Emit code to copy function value to a new temp reg and return that reg.  */
diff -rcp2N gcc-2.7.2.3/final.c gcc-2.7.2.3.f.2/final.c
*** gcc-2.7.2.3/final.c	Sun Nov 26 18:50:00 1995
--- gcc-2.7.2.3.f.2/final.c	Tue Sep  9 07:01:32 1997
*************** profile_function (file)
*** 983,991 ****
    text_section ();
  
! #ifdef STRUCT_VALUE_INCOMING_REGNUM
    if (sval)
      ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
  #else
! #ifdef STRUCT_VALUE_REGNUM
    if (sval)
      ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
--- 983,991 ----
    text_section ();
  
! #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (sval)
      ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
  #else
! #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (sval)
      ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
*************** profile_function (file)
*** 993,1027 ****
  #endif
  
! #if 0
! #ifdef STATIC_CHAIN_INCOMING_REGNUM
    if (cxt)
      ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
  #else
! #ifdef STATIC_CHAIN_REGNUM
    if (cxt)
      ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
  #endif
  #endif
- #endif				/* 0 */
  
    FUNCTION_PROFILER (file, profile_label_no);
  
! #if 0
! #ifdef STATIC_CHAIN_INCOMING_REGNUM
    if (cxt)
      ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
  #else
! #ifdef STATIC_CHAIN_REGNUM
    if (cxt)
      ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
  #endif
  #endif
- #endif				/* 0 */
  
! #ifdef STRUCT_VALUE_INCOMING_REGNUM
    if (sval)
      ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
  #else
! #ifdef STRUCT_VALUE_REGNUM
    if (sval)
      ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
--- 993,1023 ----
  #endif
  
! #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (cxt)
      ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
  #else
! #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (cxt)
      ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
  #endif
  #endif
  
    FUNCTION_PROFILER (file, profile_label_no);
  
! #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (cxt)
      ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
  #else
! #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (cxt)
      ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
  #endif
  #endif
  
! #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (sval)
      ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
  #else
! #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
    if (sval)
      ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
diff -rcp2N gcc-2.7.2.3/flags.h gcc-2.7.2.3.f.2/flags.h
*** gcc-2.7.2.3/flags.h	Thu Jun 15 11:34:11 1995
--- gcc-2.7.2.3.f.2/flags.h	Sun Mar  1 03:29:49 1998
*************** extern int flag_unroll_loops;
*** 204,207 ****
--- 204,221 ----
  extern int flag_unroll_all_loops;
  
+ /* Nonzero forces all invariant computations in loops to be moved
+    outside the loop. */
+ 
+ extern int flag_move_all_movables;
+ 
+ /* Nonzero forces all general induction variables in loops to be
+    strength reduced. */
+ 
+ extern int flag_reduce_all_givs;
+ 
+ /* Nonzero gets another run of loop_optimize performed. */
+ 
+ extern int flag_rerun_loop_opt;
+ 
  /* Nonzero for -fcse-follow-jumps:
     have cse follow jumps to do a more extensive job.  */
*************** extern int flag_gnu_linker;
*** 339,342 ****
--- 353,373 ----
  /* Tag all structures with __attribute__(packed) */
  extern int flag_pack_struct;
+ 
+ /* Emit code to check for stack overflow; also may cause large objects
+    to be allocated dynamically.  */
+ extern int flag_stack_check;
+ 
+ /* 1 if alias checking is enabled: symbols do not alias each other
+    and parameters do not alias the current stack frame.  */
+ extern int flag_alias_check;
+ 
+ /* This flag is only tested if alias checking is enabled.
+    0 if pointer arguments may alias each other.  True in C.
+    1 if pointer arguments may not alias each other but may alias
+    global variables.
+    2 if pointer arguments may not alias each other and may not
+    alias global variables.  True in Fortran.
+    The value is ignored if flag_alias_check is 0.  */
+ extern int flag_argument_noalias;
  
  /* Other basic status info about current function.  */
*************** extern int current_function_has_nonlocal
*** 362,363 ****
--- 393,401 ----
  
  extern int current_function_has_nonlocal_goto;
+ 
+ /* If reg-stack will be run and this function has a computed goto, we can't
+    put pseudos into stack registers, since reg-stack will be unable to cope.
+    This variable is nonzero if we have found a computed goto.  This is
+    computed in flow.c or in stupid.c.  */
+ 
+ extern int current_function_has_computed_jump;
diff -rcp2N gcc-2.7.2.3/flow.c gcc-2.7.2.3.f.2/flow.c
*** gcc-2.7.2.3/flow.c	Mon Aug 28 10:23:34 1995
--- gcc-2.7.2.3.f.2/flow.c	Sun Mar  1 03:59:40 1998
*************** rtx *basic_block_head;
*** 236,239 ****
--- 236,244 ----
  rtx *basic_block_end;
  
+ /* Element N indicates whether basic block N can be reached through a
+    computed jump.  */
+ 
+ char *basic_block_computed_jump_target;
+ 
  /* Element N is a regset describing the registers live
     at the start of basic block N.
*************** static HARD_REG_SET elim_reg_set;
*** 288,292 ****
  /* Forward declarations */
  static void find_basic_blocks		PROTO((rtx, rtx));
- static int uses_reg_or_mem		PROTO((rtx));
  static void mark_label_ref		PROTO((rtx, rtx, int));
  static void life_analysis		PROTO((rtx, int));
--- 293,296 ----
*************** flow_analysis (f, nregs, file)
*** 376,379 ****
--- 380,384 ----
    basic_block_head = (rtx *) oballoc (n_basic_blocks * sizeof (rtx));
    basic_block_end = (rtx *) oballoc (n_basic_blocks * sizeof (rtx));
+   basic_block_computed_jump_target = (char *) oballoc (n_basic_blocks);
    basic_block_drops_in = (char *) alloca (n_basic_blocks);
    basic_block_loop_depth = (short *) alloca (n_basic_blocks * sizeof (short));
*************** find_basic_blocks (f, nonlocal_label_lis
*** 422,425 ****
--- 427,432 ----
    bzero (block_live, n_basic_blocks);
    bzero (block_marked, n_basic_blocks);
+   bzero (basic_block_computed_jump_target, n_basic_blocks);
+   current_function_has_computed_jump = 0;
  
    /* Initialize with just block 0 reachable and no blocks marked.  */
*************** find_basic_blocks (f, nonlocal_label_lis
*** 534,574 ****
  
        for (insn = f; insn; insn = NEXT_INSN (insn))
! 	if (GET_CODE (insn) == JUMP_INSN)
  	  {
! 	    rtx pat = PATTERN (insn);
! 	    int computed_jump = 0;
! 
! 	    if (GET_CODE (pat) == PARALLEL)
  	      {
! 		int len = XVECLEN (pat, 0);
! 		int has_use_labelref = 0;
! 
! 		for (i = len - 1; i >= 0; i--)
! 		  if (GET_CODE (XVECEXP (pat, 0, i)) == USE
! 		      && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
! 			  == LABEL_REF))
! 		    has_use_labelref = 1;
! 
! 		if (! has_use_labelref)
! 		  for (i = len - 1; i >= 0; i--)
! 		    if (GET_CODE (XVECEXP (pat, 0, i)) == SET
! 			&& SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
! 			&& uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
! 		      computed_jump = 1;
  	      }
- 	    else if (GET_CODE (pat) == SET
- 		     && SET_DEST (pat) == pc_rtx
- 		     && uses_reg_or_mem (SET_SRC (pat)))
- 	      computed_jump = 1;
- 		    
- 	    if (computed_jump)
- 	      {
- 		for (x = label_value_list; x; x = XEXP (x, 1))
- 		  mark_label_ref (gen_rtx (LABEL_REF, VOIDmode, XEXP (x, 0)),
- 				  insn, 0);
  
! 		for (x = forced_labels; x; x = XEXP (x, 1))
! 		  mark_label_ref (gen_rtx (LABEL_REF, VOIDmode, XEXP (x, 0)),
! 			      insn, 0);
  	      }
  	  }
--- 541,561 ----
  
        for (insn = f; insn; insn = NEXT_INSN (insn))
! 	if (computed_jump_p (insn))
  	  {
! 	    for (x = label_value_list; x; x = XEXP (x, 1))
  	      {
! 		int b = BLOCK_NUM (XEXP (x, 0));
! 		basic_block_computed_jump_target[b] = 1;
! 		mark_label_ref (gen_rtx (LABEL_REF, VOIDmode,
! 					 XEXP (x, 0)),
! 				insn, 0);
  	      }
  
! 	    for (x = forced_labels; x; x = XEXP (x, 1))
! 	      {
! 		int b = BLOCK_NUM (XEXP (x, 0));
! 		basic_block_computed_jump_target[b] = 1;
! 		mark_label_ref (gen_rtx (LABEL_REF, VOIDmode, XEXP (x, 0)),
! 				insn, 0);
  	      }
  	  }
*************** find_basic_blocks (f, nonlocal_label_lis
*** 760,795 ****
  /* Subroutines of find_basic_blocks.  */
  
- /* Return 1 if X contain a REG or MEM that is not in the constant pool.  */
- 
- static int
- uses_reg_or_mem (x)
-      rtx x;
- {
-   enum rtx_code code = GET_CODE (x);
-   int i, j;
-   char *fmt;
- 
-   if (code == REG
-       || (code == MEM
- 	  && ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
- 		&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))))
-     return 1;
- 
-   fmt = GET_RTX_FORMAT (code);
-   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-     {
-       if (fmt[i] == 'e'
- 	  && uses_reg_or_mem (XEXP (x, i)))
- 	return 1;
- 
-       if (fmt[i] == 'E')
- 	for (j = 0; j < XVECLEN (x, i); j++)
- 	  if (uses_reg_or_mem (XVECEXP (x, i, j)))
- 	    return 1;
-     }
- 
-   return 0;
- }
- 
  /* Check expression X for label references;
     if one is found, add INSN to the label's chain of references.
--- 747,750 ----
*************** propagate_block (old, first, last, final
*** 1605,1614 ****
  
  		  /* Each call clobbers all call-clobbered regs that are not
! 		     global.  Note that the function-value reg is a
  		     call-clobbered reg, and mark_set_regs has already had
  		     a chance to handle it.  */
  
  		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
! 		    if (call_used_regs[i] && ! global_regs[i])
  		      dead[i / REGSET_ELT_BITS]
  			|= ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS));
--- 1560,1570 ----
  
  		  /* Each call clobbers all call-clobbered regs that are not
! 		     global or fixed.  Note that the function-value reg is a
  		     call-clobbered reg, and mark_set_regs has already had
  		     a chance to handle it.  */
  
  		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
! 		    if (call_used_regs[i] && ! global_regs[i]
! 			&& ! fixed_regs[i])
  		      dead[i / REGSET_ELT_BITS]
  			|= ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS));
diff -rcp2N gcc-2.7.2.3/fold-const.c gcc-2.7.2.3.f.2/fold-const.c
*** gcc-2.7.2.3/fold-const.c	Fri Sep 15 22:26:12 1995
--- gcc-2.7.2.3.f.2/fold-const.c	Tue Sep  9 07:01:33 1997
*************** static tree unextend	PROTO((tree, int, i
*** 80,83 ****
--- 80,84 ----
  static tree fold_truthop PROTO((enum tree_code, tree, tree, tree));
  static tree strip_compound_expr PROTO((tree, tree));
+ static int multiple_of_p PROTO((tree, tree, tree));
  
  #ifndef BRANCH_COST
*************** const_binop (code, arg1, arg2, notrunc)
*** 1077,1080 ****
--- 1078,1083 ----
  	  if (int2h == 0 && int2l > 0
  	      && TREE_TYPE (arg1) == sizetype
+ 	      && ! TREE_CONSTANT_OVERFLOW (arg1)
+ 	      && ! TREE_CONSTANT_OVERFLOW (arg2)
  	      && int1h == 0 && int1l >= 0)
  	    {
*************** const_binop (code, arg1, arg2, notrunc)
*** 1230,1233 ****
--- 1233,1237 ----
    if (TREE_CODE (arg1) == COMPLEX_CST)
      {
+       register tree type = TREE_TYPE (arg1);
        register tree r1 = TREE_REALPART (arg1);
        register tree i1 = TREE_IMAGPART (arg1);
*************** const_binop (code, arg1, arg2, notrunc)
*** 1239,1253 ****
  	{
  	case PLUS_EXPR:
! 	  t = build_complex (const_binop (PLUS_EXPR, r1, r2, notrunc),
  			     const_binop (PLUS_EXPR, i1, i2, notrunc));
  	  break;
  
  	case MINUS_EXPR:
! 	  t = build_complex (const_binop (MINUS_EXPR, r1, r2, notrunc),
  			     const_binop (MINUS_EXPR, i1, i2, notrunc));
  	  break;
  
  	case MULT_EXPR:
! 	  t = build_complex (const_binop (MINUS_EXPR,
  					  const_binop (MULT_EXPR,
  						       r1, r2, notrunc),
--- 1243,1260 ----
  	{
  	case PLUS_EXPR:
! 	  t = build_complex (type,
! 			     const_binop (PLUS_EXPR, r1, r2, notrunc),
  			     const_binop (PLUS_EXPR, i1, i2, notrunc));
  	  break;
  
  	case MINUS_EXPR:
! 	  t = build_complex (type,
! 			     const_binop (MINUS_EXPR, r1, r2, notrunc),
  			     const_binop (MINUS_EXPR, i1, i2, notrunc));
  	  break;
  
  	case MULT_EXPR:
! 	  t = build_complex (type,
! 			     const_binop (MINUS_EXPR,
  					  const_binop (MULT_EXPR,
  						       r1, r2, notrunc),
*************** const_binop (code, arg1, arg2, notrunc)
*** 1271,1293 ****
  			     notrunc);
  
! 	    t = build_complex
! 	      (const_binop (INTEGRAL_TYPE_P (TREE_TYPE (r1))
! 			    ? TRUNC_DIV_EXPR : RDIV_EXPR,
! 			    const_binop (PLUS_EXPR,
! 					 const_binop (MULT_EXPR, r1, r2,
! 						      notrunc),
! 					 const_binop (MULT_EXPR, i1, i2,
! 						      notrunc),
! 					 notrunc),
! 			    magsquared, notrunc),
! 	       const_binop (INTEGRAL_TYPE_P (TREE_TYPE (r1))
! 			    ? TRUNC_DIV_EXPR : RDIV_EXPR,
! 			    const_binop (MINUS_EXPR,
! 					 const_binop (MULT_EXPR, i1, r2,
! 						      notrunc),
! 					 const_binop (MULT_EXPR, r1, i2,
! 						      notrunc),
! 					 notrunc),
! 			    magsquared, notrunc));
  	  }
  	  break;
--- 1278,1302 ----
  			     notrunc);
  
! 	    t = build_complex (type,
! 			       const_binop
! 			       (INTEGRAL_TYPE_P (TREE_TYPE (r1))
! 				? TRUNC_DIV_EXPR : RDIV_EXPR,
! 				const_binop (PLUS_EXPR,
! 					     const_binop (MULT_EXPR, r1, r2,
! 							  notrunc),
! 					     const_binop (MULT_EXPR, i1, i2,
! 							  notrunc),
! 					     notrunc),
! 				magsquared, notrunc),
! 			       const_binop
! 			       (INTEGRAL_TYPE_P (TREE_TYPE (r1))
! 				? TRUNC_DIV_EXPR : RDIV_EXPR,
! 				const_binop (MINUS_EXPR,
! 					     const_binop (MULT_EXPR, i1, r2,
! 							  notrunc),
! 					     const_binop (MULT_EXPR, r1, i2,
! 							  notrunc),
! 					     notrunc),
! 				magsquared, notrunc));
  	  }
  	  break;
*************** const_binop (code, arg1, arg2, notrunc)
*** 1296,1300 ****
  	  abort ();
  	}
-       TREE_TYPE (t) = TREE_TYPE (arg1);
        return t;
      }
--- 1305,1308 ----
*************** size_binop (code, arg0, arg1)
*** 1346,1363 ****
      {
        /* And some specific cases even faster than that.  */
!       if (code == PLUS_EXPR
! 	  && TREE_INT_CST_LOW (arg0) == 0
! 	  && TREE_INT_CST_HIGH (arg0) == 0)
  	return arg1;
!       if (code == MINUS_EXPR
! 	  && TREE_INT_CST_LOW (arg1) == 0
! 	  && TREE_INT_CST_HIGH (arg1) == 0)
  	return arg0;
!       if (code == MULT_EXPR
! 	  && TREE_INT_CST_LOW (arg0) == 1
! 	  && TREE_INT_CST_HIGH (arg0) == 0)
  	return arg1;
        /* Handle general case of two integer constants.  */
!       return const_binop (code, arg0, arg1, 0);
      }
  
--- 1354,1367 ----
      {
        /* And some specific cases even faster than that.  */
!       if (code == PLUS_EXPR && integer_zerop (arg0))
  	return arg1;
!       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
! 	       && integer_zerop (arg1))
  	return arg0;
!       else if (code == MULT_EXPR && integer_onep (arg0))
  	return arg1;
+ 
        /* Handle general case of two integer constants.  */
!       return const_binop (code, arg0, arg1, 1);
      }
  
*************** fold_convert (t, arg1)
*** 1482,1486 ****
  	{
  	  if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
! 	    return arg1;
  	  else if (setjmp (float_error))
  	    {
--- 1486,1494 ----
  	{
  	  if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
! 	    {
! 	      t = arg1;
! 	      TREE_TYPE (arg1) = type;
! 	      return t;
! 	    }
  	  else if (setjmp (float_error))
  	    {
*************** operand_equal_p (arg0, arg1, only_const)
*** 1644,1687 ****
    STRIP_NOPS (arg1);
  
!   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
!      We don't care about side effects in that case because the SAVE_EXPR
!      takes care of that for us.  */
!   if (TREE_CODE (arg0) == SAVE_EXPR && arg0 == arg1)
!     return ! only_const;
! 
!   if (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1))
      return 0;
  
!   if (TREE_CODE (arg0) == TREE_CODE (arg1)
!       && TREE_CODE (arg0) == ADDR_EXPR
!       && TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0))
!     return 1;
! 
!   if (TREE_CODE (arg0) == TREE_CODE (arg1)
!       && TREE_CODE (arg0) == INTEGER_CST
!       && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
!       && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1))
      return 1;
  
!   /* Detect when real constants are equal.  */
!   if (TREE_CODE (arg0) == TREE_CODE (arg1)
!       && TREE_CODE (arg0) == REAL_CST)
!     return !bcmp ((char *) &TREE_REAL_CST (arg0),
! 		  (char *) &TREE_REAL_CST (arg1),
! 		  sizeof (REAL_VALUE_TYPE));
  
    if (only_const)
      return 0;
  
-   if (arg0 == arg1)
-     return 1;
- 
-   if (TREE_CODE (arg0) != TREE_CODE (arg1))
-     return 0;
-   /* This is needed for conversions and for COMPONENT_REF.
-      Might as well play it safe and always test this.  */
-   if (TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
-     return 0;
- 
    switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
      {
--- 1652,1710 ----
    STRIP_NOPS (arg1);
  
!   if (TREE_CODE (arg0) != TREE_CODE (arg1)
!       /* This is needed for conversions and for COMPONENT_REF.
! 	 Might as well play it safe and always test this.  */
!       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
      return 0;
  
!   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
!      We don't care about side effects in that case because the SAVE_EXPR
!      takes care of that for us. In all other cases, two expressions are
!      equal if they have no side effects.  If we have two identical
!      expressions with side effects that should be treated the same due
!      to the only side effects being identical SAVE_EXPR's, that will
!      be detected in the recursive calls below.  */
!   if (arg0 == arg1 && ! only_const
!       && (TREE_CODE (arg0) == SAVE_EXPR
! 	  || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
      return 1;
  
!   /* Next handle constant cases, those for which we can return 1 even
!      if ONLY_CONST is set.  */
!   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
!     switch (TREE_CODE (arg0))
!       {
!       case INTEGER_CST:
! 	return (! TREE_CONSTANT_OVERFLOW (arg0)
! 		&& ! TREE_CONSTANT_OVERFLOW (arg1)
! 		&& TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
! 		&& TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
! 
!       case REAL_CST:
! 	return (! TREE_CONSTANT_OVERFLOW (arg0)
! 		&& ! TREE_CONSTANT_OVERFLOW (arg1)
! 		&& REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
! 				      TREE_REAL_CST (arg1)));
! 
!       case COMPLEX_CST:
! 	return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
! 				 only_const)
! 		&& operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
! 				    only_const));
! 
!       case STRING_CST:
! 	return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
! 		&& ! strncmp (TREE_STRING_POINTER (arg0),
! 			      TREE_STRING_POINTER (arg1),
! 			      TREE_STRING_LENGTH (arg0)));
! 
!       case ADDR_EXPR:
! 	return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
! 				0);
!       }
  
    if (only_const)
      return 0;
  
    switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
      {
*************** operand_equal_p (arg0, arg1, only_const)
*** 1698,1705 ****
      case '<':
      case '2':
!       return (operand_equal_p (TREE_OPERAND (arg0, 0),
! 			       TREE_OPERAND (arg1, 0), 0)
  	      && operand_equal_p (TREE_OPERAND (arg0, 1),
! 				  TREE_OPERAND (arg1, 1), 0));
  
      case 'r':
--- 1721,1740 ----
      case '<':
      case '2':
!       if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
! 	  && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
! 			      0))
! 	return 1;
! 
!       /* For commutative ops, allow the other order.  */
!       return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
! 	       || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
! 	       || TREE_CODE (arg0) == BIT_IOR_EXPR
! 	       || TREE_CODE (arg0) == BIT_XOR_EXPR
! 	       || TREE_CODE (arg0) == BIT_AND_EXPR
! 	       || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
! 	      && operand_equal_p (TREE_OPERAND (arg0, 0),
! 				  TREE_OPERAND (arg1, 1), 0)
  	      && operand_equal_p (TREE_OPERAND (arg0, 1),
! 				  TREE_OPERAND (arg1, 0), 0));
  
      case 'r':
*************** optimize_bit_field_compare (code, compar
*** 2212,2215 ****
--- 2247,2251 ----
    int lunsignedp, runsignedp;
    int lvolatilep = 0, rvolatilep = 0;
+   int alignment;
    tree linner, rinner;
    tree mask;
*************** optimize_bit_field_compare (code, compar
*** 2220,2224 ****
       extraction at all and so can do nothing.  */
    linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
! 				&lunsignedp, &lvolatilep);
    if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
        || offset != 0)
--- 2256,2260 ----
       extraction at all and so can do nothing.  */
    linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
! 				&lunsignedp, &lvolatilep, &alignment);
    if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
        || offset != 0)
*************** optimize_bit_field_compare (code, compar
*** 2229,2234 ****
       /* If this is not a constant, we can only do something if bit positions,
  	sizes, and signedness are the same.   */
!      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset,
! 				   &rmode, &runsignedp, &rvolatilep);
  
       if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
--- 2265,2270 ----
       /* If this is not a constant, we can only do something if bit positions,
  	sizes, and signedness are the same.   */
!      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
! 				   &runsignedp, &rvolatilep, &alignment);
  
       if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
*************** decode_field_reference (exp, pbitsize, p
*** 2403,2406 ****
--- 2439,2443 ----
    tree unsigned_type;
    int precision;
+   int alignment;
  
    /* All the optimizations using this function assume integer fields.  
*************** decode_field_reference (exp, pbitsize, p
*** 2423,2427 ****
  
    inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
! 			       punsignedp, pvolatilep);
    if ((inner == exp && and_mask == 0)
        || *pbitsize < 0 || offset != 0)
--- 2460,2464 ----
  
    inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
! 			       punsignedp, pvolatilep, &alignment);
    if ((inner == exp && and_mask == 0)
        || *pbitsize < 0 || offset != 0)
*************** fold_truthop (code, truth_type, lhs, rhs
*** 2767,2770 ****
--- 2804,2810 ----
  	    {
  	      /* Avoid evaluating the variable part twice.  */
+ 	      if (current_function_decl == 0)
+ 		return 0;
+ 
  	      ll_arg = save_expr (ll_arg);
  	      lhs = build (lcode, TREE_TYPE (lhs), ll_arg, lr_arg);
*************** strip_compound_expr (t, s)
*** 3065,3068 ****
--- 3105,3208 ----
  }
  
+ /* Determine if first argument is a multiple of second argument.
+    Return 0 if it is not, or is not easily determined to so be.
+ 
+    An example of the sort of thing we care about (at this point --
+    this routine could surely be made more general, and expanded
+    to do what the *_DIV_EXPR's fold() cases do now) is discovering
+    that
+ 
+      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
+ 
+    is a multiple of
+ 
+      SAVE_EXPR (J * 8)
+ 
+    when we know that the two `SAVE_EXPR (J * 8)' nodes are the
+    same node (which means they will have the same value at run
+    time, even though we don't know when they'll be assigned).
+ 
+    This code also handles discovering that
+ 
+      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
+ 
+    is a multiple of
+ 
+      8
+ 
+    (of course) so we don't have to worry about dealing with a
+    possible remainder.
+ 
+    Note that we _look_ inside a SAVE_EXPR only to determine
+    how it was calculated; it is not safe for fold() to do much
+    of anything else with the internals of a SAVE_EXPR, since
+    fold() cannot know when it will be evaluated at run time.
+    For example, the latter example above _cannot_ be implemented
+    as
+ 
+      SAVE_EXPR (I) * J
+ 
+    or any variant thereof, since the value of J at evaluation time
+    of the original SAVE_EXPR is not necessarily the same at the time
+    the new expression is evaluated.  The only optimization of this
+    sort that would be valid is changing
+ 
+      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
+    divided by
+      8
+ 
+    to
+ 
+      SAVE_EXPR (I) * SAVE_EXPR (J)
+ 
+    (where the same SAVE_EXPR (J) is used in the original and the
+    transformed version).  */
+ 
+ static int
+ multiple_of_p (type, top, bottom)
+      tree type;
+      tree top;
+      tree bottom;
+ {
+   if (operand_equal_p (top, bottom, 0))
+     return 1;
+ 
+   if (TREE_CODE (type) != INTEGER_TYPE)
+     return 0;
+ 
+   switch (TREE_CODE (top))
+     {
+     case MULT_EXPR:
+       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
+ 	      || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
+ 
+     case PLUS_EXPR:
+     case MINUS_EXPR:
+       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
+ 	      && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
+ 
+     case NOP_EXPR:
+       /* Punt if conversion from non-integral or wider integral type.  */
+       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
+ 	  || (TYPE_PRECISION (type)
+ 	      < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
+ 	return 0;
+       /* Fall through. */
+     case SAVE_EXPR:
+       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
+ 
+     case INTEGER_CST:
+       if ((TREE_CODE (bottom) != INTEGER_CST)
+ 	  || (tree_int_cst_sgn (top) < 0)
+ 	  || (tree_int_cst_sgn (bottom) < 0))
+ 	return 0;
+       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
+ 					 top, bottom, 0));
+ 
+     default:
+       return 0;
+     }
+ }
+ 
  /* Perform constant folding and related simplification of EXPR.
     The related simplifications include x*1 => x, x*0 => 0, etc.,
*************** fold (expr) 
*** 3091,3096 ****
    int wins = 1;
  
!   /* Don't try to process an RTL_EXPR since its operands aren't trees.  */
!   if (code == RTL_EXPR)
      return t;
  
--- 3231,3237 ----
    int wins = 1;
  
!   /* Don't try to process an RTL_EXPR since its operands aren't trees. 
!      Likewise for a SAVE_EXPR that's already been evaluated.  */
!   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
      return t;
  
*************** fold (expr) 
*** 3280,3285 ****
  		      fold (build (code, type,
  				   arg0, TREE_OPERAND (arg1, 1))));
!       else if (TREE_CODE (arg1) == COND_EXPR
! 	       || TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
  	{
  	  tree test, true_value, false_value;
--- 3421,3427 ----
  		      fold (build (code, type,
  				   arg0, TREE_OPERAND (arg1, 1))));
!       else if ((TREE_CODE (arg1) == COND_EXPR
! 		|| TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
! 	       && (! TREE_SIDE_EFFECTS (arg0) || current_function_decl != 0))
  	{
  	  tree test, true_value, false_value;
*************** fold (expr) 
*** 3319,3323 ****
  		return fold (build (COND_EXPR, type, test, lhs, rhs));
  
! 	      arg0 = save_expr (arg0);
  	    }
  
--- 3461,3466 ----
  		return fold (build (COND_EXPR, type, test, lhs, rhs));
  
! 	      if (current_function_decl != 0)
! 		arg0 = save_expr (arg0);
  	    }
  
*************** fold (expr) 
*** 3336,3341 ****
  	return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
  		      fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
!       else if (TREE_CODE (arg0) == COND_EXPR
! 	       || TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
  	{
  	  tree test, true_value, false_value;
--- 3479,3485 ----
  	return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
  		      fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
!       else if ((TREE_CODE (arg0) == COND_EXPR
! 		|| TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
! 	       && (! TREE_SIDE_EFFECTS (arg1) || current_function_decl != 0))
  	{
  	  tree test, true_value, false_value;
*************** fold (expr) 
*** 3367,3371 ****
  		return fold (build (COND_EXPR, type, test, lhs, rhs));
  
! 	      arg1 = save_expr (arg1);
  	    }
  
--- 3511,3516 ----
  		return fold (build (COND_EXPR, type, test, lhs, rhs));
  
! 	      if (current_function_decl != 0)
! 		arg1 = save_expr (arg1);
  	    }
  
*************** fold (expr) 
*** 3611,3615 ****
  				    TREE_OPERAND (arg0, 1))));
        else if (TREE_CODE (arg0) == COMPLEX_CST)
! 	return build_complex (TREE_OPERAND (arg0, 0),
  			      fold (build1 (NEGATE_EXPR,
  					    TREE_TYPE (TREE_TYPE (arg0)),
--- 3756,3760 ----
  				    TREE_OPERAND (arg0, 1))));
        else if (TREE_CODE (arg0) == COMPLEX_CST)
! 	return build_complex (type, TREE_OPERAND (arg0, 0),
  			      fold (build1 (NEGATE_EXPR,
  					    TREE_TYPE (TREE_TYPE (arg0)),
*************** fold (expr) 
*** 3889,3893 ****
  	    return non_lvalue (convert (type, arg0));
  	  /* x*2 is x+x */
! 	  if (! wins && real_twop (arg1))
  	    {
  	      tree arg = save_expr (arg0);
--- 4034,4038 ----
  	    return non_lvalue (convert (type, arg0));
  	  /* x*2 is x+x */
! 	  if (! wins && real_twop (arg1) && current_function_decl != 0)
  	    {
  	      tree arg = save_expr (arg0);
*************** fold (expr) 
*** 4014,4018 ****
  	return non_lvalue (convert (type, arg0));
        if (integer_zerop (arg1))
! 	return t;
  
        /* If we have ((a / C1) / C2) where both division are the same type, try
--- 4159,4179 ----
  	return non_lvalue (convert (type, arg0));
        if (integer_zerop (arg1))
! 	{
! 	  if (extra_warnings)
! 	    warning ("integer division by zero");
! 	  return t;
! 	}
! 
!       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
! 	 operation, EXACT_DIV_EXPR.  Otherwise, handle folding of
! 	 general divide.  Note that only CEIL_DIV_EXPR is rewritten now,
! 	 only because the others seem to be faster in some cases, e.g. the
! 	 nonoptimized TRUNC_DIV_EXPR or FLOOR_DIV_EXPR on DEC Alpha.  This
! 	 is probably just due to more work being done on it in expmed.c than
! 	 on EXACT_DIV_EXPR, and could presumably be fixed, since
! 	 EXACT_DIV_EXPR should _never_ be slower than *_DIV_EXPR.  */
!       if ((code == CEIL_DIV_EXPR)
! 	  && multiple_of_p (type, arg0, arg1))
! 	return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
  
        /* If we have ((a / C1) / C2) where both division are the same type, try
*************** fold (expr) 
*** 4049,4053 ****
  	  tree xarg0 = arg0;
  
! 	  if (TREE_CODE (xarg0) == SAVE_EXPR)
  	    have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
  
--- 4210,4214 ----
  	  tree xarg0 = arg0;
  
! 	  if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
  	    have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
  
*************** fold (expr) 
*** 4067,4071 ****
  	    }
  
! 	  if (TREE_CODE (xarg0) == SAVE_EXPR)
  	    have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
  
--- 4228,4232 ----
  	    }
  
! 	  if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
  	    have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
  
*************** fold (expr) 
*** 5050,5054 ****
      case COMPLEX_EXPR:
        if (wins)
! 	return build_complex (arg0, arg1);
        return t;
  
--- 5211,5215 ----
      case COMPLEX_EXPR:
        if (wins)
! 	return build_complex (type, arg0, arg1);
        return t;
  
diff -rcp2N gcc-2.7.2.3/function.c gcc-2.7.2.3.f.2/function.c
*** gcc-2.7.2.3/function.c	Wed Aug 13 17:23:26 1997
--- gcc-2.7.2.3.f.2/function.c	Sun Mar  1 03:35:26 1998
*************** int current_function_has_nonlocal_label;
*** 125,128 ****
--- 125,135 ----
  int current_function_has_nonlocal_goto;
  
+ /* If reg-stack will be run and this function has a computed goto, we can't
+    put pseudos into stack registers, since reg-stack will be unable to cope.
+    This variable is nonzero if we have found a computed goto.  This is
+    computed in flow.c or in stupid.c.  */
+ 
+ int current_function_has_computed_jump;
+ 
  /* Nonzero if function being compiled contains nested functions.  */
  
*************** assign_stack_temp (mode, size, keep)
*** 917,920 ****
--- 924,932 ----
        p->keep = keep;
      }
+ 
+   /* We may be reusing an old slot, so clear any MEM flags that may have been
+      set from before.  */
+   RTX_UNCHANGING_P (p->slot) = 0;
+   MEM_IN_STRUCT_P (p->slot) = 0;
    return p->slot;
  }
*************** find_temp_slot_from_address (x)
*** 994,999 ****
        if (! p->in_use)
  	continue;
!       else if (XEXP (p->slot, 0) == x
! 	       || p->address == x)
  	return p;
  
--- 1006,1011 ----
        if (! p->in_use)
  	continue;
!       else if (rtx_equal_p (XEXP (p->slot, 0), x)
! 	       || rtx_equal_p (p->address, x))
  	return p;
  
*************** free_temps_for_rtl_expr (t)
*** 1184,1187 ****
--- 1196,1214 ----
  }
  
+ /* Mark all temporaries ever allocated in this functon as not suitable
+    for reuse until the current level is exited.  */
+ 
+ void
+ mark_all_temps_used ()
+ {
+   struct temp_slot *p;
+ 
+   for (p = temp_slots; p; p = p->next)
+     {
+       p->in_use = p->keep = 1;
+       p->level = MIN (p->level, temp_slot_level);
+     }
+ }
+ 
  /* Push deeper into the nesting level for stack temporaries.  */
  
*************** pop_temp_slots ()
*** 1208,1211 ****
--- 1235,1249 ----
    temp_slot_level--;
  }
+ 
+ /* Initialize temporary slots.  */
+ 
+ void
+ init_temp_slots ()
+ {
+   /* We have not allocated any temporaries yet.  */
+   temp_slots = 0;
+   temp_slot_level = 0;
+   target_temp_slot_level = 0;
+ }
  
  /* Retroactively move an auto variable from a register to a stack slot.
*************** instantiate_virtual_regs_1 (loc, object,
*** 2838,2842 ****
      case MEM:
        /* Most cases of MEM that convert to valid addresses have already been
! 	 handled by our scan of regno_reg_rtx.  The only special handling we
  	 need here is to make a copy of the rtx to ensure it isn't being
  	 shared if we have to change it to a pseudo. 
--- 2876,2880 ----
      case MEM:
        /* Most cases of MEM that convert to valid addresses have already been
! 	 handled by our scan of decls.  The only special handling we
  	 need here is to make a copy of the rtx to ensure it isn't being
  	 shared if we have to change it to a pseudo. 
*************** instantiate_virtual_regs_1 (loc, object,
*** 2896,2900 ****
  	     has less restrictions on an address that some other insn.
  	     In that case, we will modify the shared address.  This case
! 	     doesn't seem very likely, though.  */
  
  	  if (instantiate_virtual_regs_1 (&XEXP (x, 0),
--- 2934,2940 ----
  	     has less restrictions on an address that some other insn.
  	     In that case, we will modify the shared address.  This case
! 	     doesn't seem very likely, though.  One case where this could
! 	     happen is in the case of a USE or CLOBBER reference, but we
! 	     take care of that below.  */
  
  	  if (instantiate_virtual_regs_1 (&XEXP (x, 0),
*************** instantiate_virtual_regs_1 (loc, object,
*** 2909,2914 ****
  
        /* Fall through to generic unary operation case.  */
-     case USE:
-     case CLOBBER:
      case SUBREG:
      case STRICT_LOW_PART:
--- 2949,2952 ----
*************** instantiate_virtual_regs_1 (loc, object,
*** 2927,2930 ****
--- 2965,2985 ----
        goto restart;
  
+     case USE:
+     case CLOBBER:
+       /* If the operand is a MEM, see if the change is a valid MEM.  If not,
+ 	 go ahead and make the invalid one, but do it to a copy.  For a REG,
+ 	 just make the recursive call, since there's no chance of a problem. */
+ 
+       if ((GET_CODE (XEXP (x, 0)) == MEM
+ 	   && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
+ 					  0))
+ 	  || (GET_CODE (XEXP (x, 0)) == REG
+ 	      && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
+ 	return 1;
+ 
+       XEXP (x, 0) = copy_rtx (XEXP (x, 0));
+       loc = &XEXP (x, 0);
+       goto restart;
+ 
      case REG:
        /* Try to replace with a PLUS.  If that doesn't work, compute the sum
*************** assign_parms (fndecl, second_time)
*** 3404,3409 ****
  
  	  /* If this is a memory ref that contains aggregate components,
! 	     mark it as such for cse and loop optimize.  */
  	  MEM_IN_STRUCT_P (stack_parm) = aggregate;
  	}
  
--- 3459,3466 ----
  
  	  /* If this is a memory ref that contains aggregate components,
! 	     mark it as such for cse and loop optimize.  Likewise if it
! 	     is readonly.  */
  	  MEM_IN_STRUCT_P (stack_parm) = aggregate;
+ 	  RTX_UNCHANGING_P (stack_parm) = TREE_READONLY (parm);
  	}
  
*************** assign_parms (fndecl, second_time)
*** 3627,3631 ****
  
  	  parmreg = gen_reg_rtx (promoted_nominal_mode);
! 	  REG_USERVAR_P (parmreg) = 1;
  
  	  /* If this was an item that we received a pointer to, set DECL_RTL
--- 3684,3688 ----
  
  	  parmreg = gen_reg_rtx (promoted_nominal_mode);
! 	  mark_user_reg (parmreg);
  
  	  /* If this was an item that we received a pointer to, set DECL_RTL
*************** assign_parms (fndecl, second_time)
*** 3695,3699 ****
  		 Pmode above.  We must use the actual mode of the parm.  */
  	      parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
! 	      REG_USERVAR_P (parmreg) = 1;
  	      emit_move_insn (parmreg, DECL_RTL (parm));
  	      DECL_RTL (parm) = parmreg;
--- 3752,3756 ----
  		 Pmode above.  We must use the actual mode of the parm.  */
  	      parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
! 	      mark_user_reg (parmreg);
  	      emit_move_insn (parmreg, DECL_RTL (parm));
  	      DECL_RTL (parm) = parmreg;
*************** init_function_start (subr, filename, lin
*** 4814,4821 ****
    rtl_expr_chain = 0;
  
!   /* We have not allocated any temporaries yet.  */
!   temp_slots = 0;
!   temp_slot_level = 0;
!   target_temp_slot_level = 0;
  
    /* Within function body, compute a type's size as soon it is laid out.  */
--- 4871,4876 ----
    rtl_expr_chain = 0;
  
!   /* Set up to allocate temporaries.  */
!   init_temp_slots ();
  
    /* Within function body, compute a type's size as soon it is laid out.  */
*************** expand_function_end (filename, line, end
*** 5295,5298 ****
--- 5350,5373 ----
        /* Put those insns at entry to the containing function (this one).  */
        emit_insns_before (seq, tail_recursion_reentry);
+     }
+ 
+   /* If we are doing stack checking and this function makes calls,
+      do a stack probe at the start of the function to ensure we have enough
+      space for another stack frame.  */
+   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
+     {
+       rtx insn, seq;
+ 
+       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ 	if (GET_CODE (insn) == CALL_INSN)
+ 	  {
+ 	    start_sequence ();
+ 	    probe_stack_range (STACK_CHECK_PROTECT,
+ 			       GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
+ 	    seq = get_insns ();
+ 	    end_sequence ();
+ 	    emit_insns_before (seq, tail_recursion_reentry);
+ 	    break;
+ 	  }
      }
  
diff -rcp2N gcc-2.7.2.3/gcc.c gcc-2.7.2.3.f.2/gcc.c
*** gcc-2.7.2.3/gcc.c	Tue Jun 24 18:42:50 1997
--- gcc-2.7.2.3.f.2/gcc.c	Tue Sep  9 07:01:34 1997
*************** static int is_directory		PROTO((char *, 
*** 296,300 ****
  static void validate_switches	PROTO((char *));
  static void validate_all_switches PROTO((void));
! static void give_switch		PROTO((int, int));
  static int used_arg		PROTO((char *, int));
  static int default_arg		PROTO((char *, int));
--- 296,300 ----
  static void validate_switches	PROTO((char *));
  static void validate_all_switches PROTO((void));
! static void give_switch		PROTO((int, int, int));
  static int used_arg		PROTO((char *, int));
  static int default_arg		PROTO((char *, int));
*************** or with constant text in a single argume
*** 405,408 ****
--- 405,409 ----
  	name starts with `o'.  %{o*} would substitute this text,
  	including the space; thus, two arguments would be generated.
+  %{^S*} likewise, but don't put a blank between a switch and any args.
   %{S*:X} substitutes X if one or more switches whose names start with -S are
  	specified to CC.  Note that the tail part of the -S option
*************** process_command (argc, argv)
*** 2649,2655 ****
  		      else
  			{
! 			  char *string = xmalloc (len + 1);
  			  strncpy (string, value, len-7);
! 			  strcat (string, "include");
  			  add_prefix (&include_prefixes, string, 1, 0, 0);
  			}
--- 2650,2656 ----
  		      else
  			{
! 			  char *string = xmalloc (len);
  			  strncpy (string, value, len-7);
! 			  strcpy (string+len-7, "include");
  			  add_prefix (&include_prefixes, string, 1, 0, 0);
  			}
*************** process_command (argc, argv)
*** 2828,2831 ****
--- 2829,2835 ----
  	  infiles[n_infiles++].name = argv[i];
  	}
+       /* -save-temps overrides -pipe, so that temp files are produced */
+       else if (save_temps_flag && strcmp (argv[i], "-pipe") == 0)
+ 	;
        else if (argv[i][0] == '-' && argv[i][1] != 0)
  	{
*************** handle_braces (p)
*** 3832,3835 ****
--- 3836,3844 ----
    int negate = 0;
    int suffix = 0;
+   int include_blanks = 1;
+ 
+   if (*p == '^')
+     /* A '^' after the open-brace means to not give blanks before args.  */
+     include_blanks = 0, ++p;
  
    if (*p == '|')
*************** handle_braces (p)
*** 3897,3901 ****
  	if (!strncmp (switches[i].part1, filter, p - filter)
  	    && check_live_switch (i, p - filter))
! 	  give_switch (i, 0);
      }
    else
--- 3906,3910 ----
  	if (!strncmp (switches[i].part1, filter, p - filter)
  	    && check_live_switch (i, p - filter))
! 	  give_switch (i, 0, include_blanks);
      }
    else
*************** handle_braces (p)
*** 3936,3940 ****
  		    do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
  		    /* Pass any arguments this switch has.  */
! 		    give_switch (i, 1);
  		  }
  
--- 3945,3949 ----
  		    do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
  		    /* Pass any arguments this switch has.  */
! 		    give_switch (i, 1, 1);
  		  }
  
*************** handle_braces (p)
*** 3980,3984 ****
  	  if (*p == '}')
  	    {
! 	      give_switch (i, 0);
  	    }
  	  else
--- 3989,3993 ----
  	  if (*p == '}')
  	    {
! 	      give_switch (i, 0, include_blanks);
  	    }
  	  else
*************** check_live_switch (switchnum, prefix_len
*** 4081,4090 ****
     This cannot fail since it never finishes a command line.
  
!    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
  
  static void
! give_switch (switchnum, omit_first_word)
       int switchnum;
       int omit_first_word;
  {
    if (!omit_first_word)
--- 4090,4103 ----
     This cannot fail since it never finishes a command line.
  
!    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
! 
!    If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
!    of the switch.  */
  
  static void
! give_switch (switchnum, omit_first_word, include_blanks)
       int switchnum;
       int omit_first_word;
+      int include_blanks;
  {
    if (!omit_first_word)
*************** give_switch (switchnum, omit_first_word)
*** 4093,4097 ****
        do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
      }
!   do_spec_1 (" ", 0, NULL_PTR);
    if (switches[switchnum].args != 0)
      {
--- 4106,4110 ----
        do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
      }
! 
    if (switches[switchnum].args != 0)
      {
*************** give_switch (switchnum, omit_first_word)
*** 4099,4106 ****
        for (p = switches[switchnum].args; *p; p++)
  	{
  	  do_spec_1 (*p, 1, NULL_PTR);
- 	  do_spec_1 (" ", 0, NULL_PTR);
  	}
      }
    switches[switchnum].valid = 1;
  }
--- 4112,4122 ----
        for (p = switches[switchnum].args; *p; p++)
  	{
+ 	  if (include_blanks)
+ 	    do_spec_1 (" ", 0, NULL_PTR);
  	  do_spec_1 (*p, 1, NULL_PTR);
  	}
      }
+ 
+   do_spec_1 (" ", 0, NULL_PTR);
    switches[switchnum].valid = 1;
  }
diff -rcp2N gcc-2.7.2.3/gcc.texi gcc-2.7.2.3.f.2/gcc.texi
*** gcc-2.7.2.3/gcc.texi	Wed Jul 24 18:57:41 1996
--- gcc-2.7.2.3.f.2/gcc.texi	Tue Sep  9 07:01:35 1997
*************** original English.
*** 149,152 ****
--- 149,153 ----
  @sp 3
  @center Last updated 29 June 1996
+ @center (Revised for GNU Fortran 1997-01-10)
  @sp 1
  @c The version number appears twice more in this file.  
diff -rcp2N gcc-2.7.2.3/genattrtab.c gcc-2.7.2.3.f.2/genattrtab.c
*** gcc-2.7.2.3/genattrtab.c	Thu Jun 15 11:39:24 1995
--- gcc-2.7.2.3.f.2/genattrtab.c	Sun Mar  1 04:29:39 1998
*************** static char *alternative_name;
*** 360,364 ****
  
  rtx frame_pointer_rtx, hard_frame_pointer_rtx, stack_pointer_rtx;
! rtx arg_pointer_rtx;
  
  static rtx attr_rtx		PVPROTO((enum rtx_code, ...));
--- 360,364 ----
  
  rtx frame_pointer_rtx, hard_frame_pointer_rtx, stack_pointer_rtx;
! rtx arg_pointer_rtx, pc_rtx;
  
  static rtx attr_rtx		PVPROTO((enum rtx_code, ...));
diff -rcp2N gcc-2.7.2.3/glimits.h gcc-2.7.2.3.f.2/glimits.h
*** gcc-2.7.2.3/glimits.h	Wed Sep 29 21:30:54 1993
--- gcc-2.7.2.3.f.2/glimits.h	Tue Sep  9 07:01:35 1997
***************
*** 64,68 ****
     (Same as `int').  */
  #ifndef __LONG_MAX__
! #define __LONG_MAX__ 2147483647L
  #endif
  #undef LONG_MIN
--- 64,72 ----
     (Same as `int').  */
  #ifndef __LONG_MAX__
! # ifndef __alpha__
! #  define __LONG_MAX__ 2147483647L
! # else
! #  define __LONG_MAX__ 9223372036854775807LL
! # endif /* __alpha__ */
  #endif
  #undef LONG_MIN
diff -rcp2N gcc-2.7.2.3/global.c gcc-2.7.2.3.f.2/global.c
*** gcc-2.7.2.3/global.c	Thu Jun 15 11:44:32 1995
--- gcc-2.7.2.3.f.2/global.c	Sun Mar  1 03:28:17 1998
*************** global_conflicts ()
*** 676,679 ****
--- 676,688 ----
  
  	record_conflicts (block_start_allocnos, ax);
+ 
+ #ifdef STACK_REGS
+ 	/* Pseudos can't go in stack regs at the start of a basic block
+ 	   that can be reached through a computed goto, since reg-stack
+ 	   can't handle computed gotos.  */
+ 	if (basic_block_computed_jump_target[b])
+ 	  for (ax = FIRST_STACK_REG; ax <= LAST_STACK_REG; ax++)
+ 	    record_one_conflict (ax);
+ #endif
        }
  
diff -rcp2N gcc-2.7.2.3/integrate.c gcc-2.7.2.3.f.2/integrate.c
*** gcc-2.7.2.3/integrate.c	Fri Oct 20 22:48:13 1995
--- gcc-2.7.2.3.f.2/integrate.c	Tue Sep  9 07:01:36 1997
*************** static rtx copy_for_inline	PROTO((rtx));
*** 67,70 ****
--- 67,71 ----
  static void integrate_parm_decls PROTO((tree, struct inline_remap *, rtvec));
  static void integrate_decl_tree	PROTO((tree, int, struct inline_remap *));
+ static void save_constants_in_decl_trees PROTO ((tree));
  static void subst_constants	PROTO((rtx *, rtx, struct inline_remap *));
  static void restore_constants	PROTO((rtx *));
*************** save_for_inline_copying (fndecl)
*** 435,438 ****
--- 436,443 ----
  	  }
  
+       /* Also scan all decls, and replace any constant pool references with the
+ 	 actual constant.  */
+       save_constants_in_decl_trees (DECL_INITIAL (fndecl));
+ 
        /* Clear out the constant pool so that we can recreate it with the
  	 copied constants below.  */
*************** save_for_inline_nocopy (fndecl)
*** 781,784 ****
--- 786,793 ----
      }
  
+   /* Also scan all decls, and replace any constant pool references with the
+      actual constant.  */
+   save_constants_in_decl_trees (DECL_INITIAL (fndecl));
+ 
    /* We have now allocated all that needs to be allocated permanently
       on the rtx obstack.  Set our high-water mark, so that we
*************** expand_inline_function (fndecl, parms, t
*** 1571,1575 ****
        if (GET_CODE (XEXP (loc, 0)) == REG)
  	{
! 	  temp = force_reg (Pmode, structure_value_addr);
  	  map->reg_map[REGNO (XEXP (loc, 0))] = temp;
  	  if ((CONSTANT_P (structure_value_addr)
--- 1580,1585 ----
        if (GET_CODE (XEXP (loc, 0)) == REG)
  	{
! 	  temp = force_reg (Pmode,
! 			    force_operand (structure_value_addr, NULL_RTX));
  	  map->reg_map[REGNO (XEXP (loc, 0))] = temp;
  	  if ((CONSTANT_P (structure_value_addr)
*************** integrate_decl_tree (let, level, map)
*** 2029,2032 ****
--- 2039,2059 ----
  	}
      }
+ }
+ 
+ /* Given a BLOCK node LET, search for all DECL_RTL fields, and pass them
+    through save_constants.  */
+ 
+ static void
+ save_constants_in_decl_trees (let)
+      tree let;
+ {
+   tree t;
+ 
+   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
+     if (DECL_RTL (t) != 0)
+       save_constants (&DECL_RTL (t));
+ 
+   for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
+     save_constants_in_decl_trees (t);
  }
  
diff -rcp2N gcc-2.7.2.3/invoke.texi gcc-2.7.2.3.f.2/invoke.texi
*** gcc-2.7.2.3/invoke.texi	Tue Oct  3 15:40:43 1995
--- gcc-2.7.2.3.f.2/invoke.texi	Tue Sep  9 07:01:36 1997
***************
*** 1,3 ****
! @c Copyright (C) 1988, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
  @c This is part of the GCC manual.
  @c For copying conditions, see the file gcc.texi.
--- 1,3 ----
! @c Copyright (C) 1988, 89, 92-95, 1997 Free Software Foundation, Inc.
  @c This is part of the GCC manual.
  @c For copying conditions, see the file gcc.texi.
*************** in the following sections.
*** 149,152 ****
--- 149,153 ----
  -fschedule-insns2  -fstrength-reduce  -fthread-jumps 
  -funroll-all-loops  -funroll-loops
+ -fmove-all-movables  -freduce-all-givs  -frerun-loop-opt
  -O  -O0  -O1  -O2  -O3
  @end smallexample
*************** in addition to the above:
*** 330,334 ****
  -freg-struct-return  -fshared-data  -fshort-enums
  -fshort-double  -fvolatile  -fvolatile-global
! -fverbose-asm -fpack-struct +e0  +e1
  @end smallexample
  @end table
--- 331,337 ----
  -freg-struct-return  -fshared-data  -fshort-enums
  -fshort-double  -fvolatile  -fvolatile-global
! -fverbose-asm -fpack-struct -fstack-check +e0  +e1
! -fargument-alias  -fargument-noalias
! -fargument-noalias-global
  @end smallexample
  @end table
*************** Print extra warning messages for these e
*** 1253,1256 ****
--- 1256,1304 ----
  
  @itemize @bullet
+ @cindex division by zero
+ @cindex zero, division by
+ @item
+ An integer division by zero is detected.
+ 
+ Some cases of division by zero might occur as the result
+ of using so-called ``safe'' macros.
+ For example:
+ 
+ @smallexample
+ #define BUCKETS(b) (((b) != NULL) ? (b)->buckets : 0)
+ @dots{...}
+   i = j / BUCKETS(b);
+ @end smallexample
+ 
+ Although analysis of the context of the above code could
+ prove that @samp{b} is never null when it is executed,
+ the division-by-zero warning is still useful, because
+ @code{gcc} generates code to do the division by zero at
+ run time so as to generate a run-time fault,
+ and tidy programmers will want to find ways to prevent
+ this needless code from being generated.
+ 
+ Note that @code{gcc} transforms expressions so as to find
+ opportunities for performing expensive operations
+ (such as division) at compile time instead of generating
+ code to perform them at run time.
+ For example, @code{gcc} transforms:
+ 
+ @smallexample
+ 2 / (i == 0)
+ @end smallexample
+ 
+ into:
+ 
+ @smallexample
+ (i == 0) ? (2 / 1) : (2 / 0)
+ @end smallexample
+ 
+ As a result, the division-by-zero warning might occur
+ in contexts where the divisor seems to be a non-constant.
+ It is useful in this case as well, because programmers might want
+ to clean up the code so the compiled code does not include
+ dead code to divide by zero.
+ 
  @cindex @code{longjmp} warnings
  @item
*************** and usually makes programs run more slow
*** 1941,1944 ****
--- 1989,2037 ----
  implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
  
+ @item -fmove-all-movables
+ Forces all invariant computations in loops to be moved
+ outside the loop.
+ This option is provided primarily to improve performance
+ for some Fortran code, though it might improve code written
+ in other languages.
+ 
+ @emph{Note:} When compiling programs written in Fortran,
+ this option is enabled by default.
+ 
+ Analysis of Fortran code optimization and the resulting
+ optimizations triggered by this option, and the
+ @samp{-freduce-all-givs} and @samp{-frerun-loop-opt}
+ options as well, were
+ contributed by Toon Moene (@code{toon@@moene.indiv.nluug.nl}).
+ 
+ These three options are intended to be removed someday, once
+ they have helped determine the efficacy of various
+ approaches to improving the performance of Fortran code.
+ 
+ Please let us (@code{fortran@@gnu.ai.mit.edu})
+ know how use of these options affects
+ the performance of your production code.
+ We're very interested in code that runs @emph{slower}
+ when these options are @emph{enabled}.
+ 
+ @item -freduce-all-givs
+ Forces all general-induction variables in loops to be
+ strength-reduced.
+ This option is provided primarily to improve performance
+ for some Fortran code, though it might improve code written
+ in other languages.
+ 
+ @emph{Note:} When compiling programs written in Fortran,
+ this option is enabled by default.
+ 
+ @item -frerun-loop-opt
+ Runs loop optimizations a second time.
+ This option is provided primarily to improve performance
+ for some Fortran code, though it might improve code written
+ in other languages.
+ 
+ @emph{Note:} When compiling programs written in Fortran,
+ this option is enabled by default.
+ 
  @item -fno-peephole
  Disable any machine-specific peephole optimizations.
*************** not want to use this option, since it ma
*** 4212,4215 ****
--- 4305,4315 ----
  the offsets of structure members won't agree with system libraries.
  
+ @item -fstack-check
+ Generate code to verify that you do not go beyond the boundary of the
+ stack.  You should specify this flag if you are running in an
+ environment with multiple threads, but only rarely need to specify it in
+ a single-threaded environment since stack overflow is automatically
+ detected on nearly all systems if there is only one stack.
+ 
  @item +e0
  @itemx +e1
*************** compilation).
*** 4229,4232 ****
--- 4329,4404 ----
  With @samp{+e1}, G++ actually generates the code implementing virtual
  functions defined in the code, and makes them publicly visible.
+ 
+ @cindex aliasing of parameters
+ @cindex parameters, aliased
+ @item -fargument-alias
+ @item -fargument-noalias
+ @item -fargument-noalias-global
+ Specify the possible relationships among parameters and between
+ parameters and global data.
+ 
+ @samp{-fargument-alias} specifies that arguments (parameters) may
+ alias each other and may alias global storage.
+ @samp{-fargument-noalias} specifies that arguments do not alias
+ each other, but may alias global storage.
+ @samp{-fargument-noalias-global} specifies that arguments do not
+ alias each other and do not alias global storage.
+ 
+ For code written in C, C++, and Objective-C, @samp{-fargument-alias}
+ is the default.
+ For code written in Fortran, @samp{-fargument-noalias-global} is
+ the default, though this is pertinent only on systems where
+ @code{g77} is installed.
+ (See the documentation for other compilers for information on the
+ defaults for their respective languages.)
+ 
+ Normally, @code{gcc} assumes that a write through a pointer
+ passed as a parameter to the current function might modify a
+ value pointed to by another pointer passed as a parameter, or
+ in global storage.
+ 
+ For example, consider this code:
+ 
+ @example
+ void x(int *i, int *j)
+ @{
+   extern int k;
+ 
+   ++*i;
+   ++*j;
+   ++k;
+ @}
+ @end example
+ 
+ When compiling the above function, @code{gcc} assumes that @samp{i} might
+ be a pointer to the same variable as @samp{j}, and that either @samp{i},
+ @samp{j}, or both might be a pointer to @samp{k}.
+ 
+ Therefore, @code{gcc} does not assume it can generate code to read
+ @samp{*i}, @samp{*j}, and @samp{k} into separate registers, increment
+ each register, then write the incremented values back out.
+ 
+ Instead, @code{gcc} must generate code that reads @samp{*i},
+ increments it, and writes it back before reading @samp{*j},
+ in case @samp{i} and @samp{j} are aliased, and, similarly,
+ that writes @samp{*j} before reading @samp{k}.
+ The result is code that, on many systems, takes longer to execute,
+ due to the way many processors schedule instruction execution.
+ 
+ Compiling the above code with the @samp{-fargument-noalias} option
+ allows @code{gcc} to assume that @samp{i} and @samp{j} do not alias
+ each other, but either might alias @samp{k}.
+ 
+ Compiling the above code with the @samp{-fargument-noalias-global}
+ option allows @code{gcc} to assume that no combination of @samp{i},
+ @samp{j}, and @samp{k} are aliases for each other.
+ 
+ @emph{Note:} Use the @samp{-fargument-noalias} and
+ @samp{-fargument-noalias-global} options with care.
+ While they can result in faster executables, they can
+ also result in executables with subtle bugs, bugs that
+ show up only when compiled for specific target systems,
+ or bugs that show up only when compiled by specific versions
+ of @code{g77}.
  @end table
  
diff -rcp2N gcc-2.7.2.3/libgcc2.c gcc-2.7.2.3.f.2/libgcc2.c
*** gcc-2.7.2.3/libgcc2.c	Sun Nov 26 19:39:21 1995
--- gcc-2.7.2.3.f.2/libgcc2.c	Tue Sep  9 07:01:36 1997
*************** __gcc_bcmp (s1, s2, size)
*** 1193,1196 ****
--- 1193,1201 ----
  #endif
  
+ #ifdef L__dummy
+ void
+ __dummy () {}
+ #endif
+ 
  #ifdef L_varargs
  #ifdef __i860__
diff -rcp2N gcc-2.7.2.3/local-alloc.c gcc-2.7.2.3.f.2/local-alloc.c
*** gcc-2.7.2.3/local-alloc.c	Mon Aug 21 17:15:44 1995
--- gcc-2.7.2.3.f.2/local-alloc.c	Tue Sep  9 07:01:37 1997
*************** static int this_insn_number;
*** 243,246 ****
--- 243,250 ----
  static rtx this_insn;
  
+ /* Used to communicate changes made by update_equiv_regs to
+    memref_referenced_p.  */
+ static rtx *reg_equiv_replacement;
+ 
  static void alloc_qty		PROTO((int, enum machine_mode, int, int));
  static void alloc_qty_for_scratch PROTO((rtx, int, rtx, int, int));
*************** validate_equiv_mem_from_store (dest, set
*** 545,549 ****
         && reg_overlap_mentioned_p (dest, equiv_mem))
        || (GET_CODE (dest) == MEM
! 	  && true_dependence (dest, equiv_mem)))
      equiv_mem_modified = 1;
  }
--- 549,553 ----
         && reg_overlap_mentioned_p (dest, equiv_mem))
        || (GET_CODE (dest) == MEM
! 	  && true_dependence (dest, VOIDmode, equiv_mem, rtx_varies_p)))
      equiv_mem_modified = 1;
  }
*************** memref_referenced_p (memref, x)
*** 617,621 ****
    switch (code)
      {
-     case REG:
      case CONST_INT:
      case CONST:
--- 621,624 ----
*************** memref_referenced_p (memref, x)
*** 629,634 ****
        return 0;
  
      case MEM:
!       if (true_dependence (memref, x))
  	return 1;
        break;
--- 632,642 ----
        return 0;
  
+     case REG:
+       return (reg_equiv_replacement[REGNO (x)] == 0
+ 	      || memref_referenced_p (memref,
+ 				      reg_equiv_replacement[REGNO (x)]));
+ 
      case MEM:
!       if (true_dependence (memref, VOIDmode, x, rtx_varies_p))
  	return 1;
        break;
*************** optimize_reg_copy_1 (insn, dest, src)
*** 818,827 ****
  	      if (sregno >= FIRST_PSEUDO_REGISTER)
  		{
! 		  reg_live_length[sregno] -= length;
! 		  /* reg_live_length is only an approximation after combine
! 		     if sched is not run, so make sure that we still have
! 		     a reasonable value.  */
! 		  if (reg_live_length[sregno] < 2)
! 		    reg_live_length[sregno] = 2;
  		  reg_n_calls_crossed[sregno] -= n_calls;
  		}
--- 826,839 ----
  	      if (sregno >= FIRST_PSEUDO_REGISTER)
  		{
! 		  if (reg_live_length[sregno] >= 0)
! 		    {
! 		      reg_live_length[sregno] -= length;
! 		      /* reg_live_length is only an approximation after
! 			 combine if sched is not run, so make sure that we
! 			 still have a reasonable value.  */
! 		      if (reg_live_length[sregno] < 2)
! 			reg_live_length[sregno] = 2;
! 		    }
! 
  		  reg_n_calls_crossed[sregno] -= n_calls;
  		}
*************** optimize_reg_copy_1 (insn, dest, src)
*** 829,833 ****
  	      if (dregno >= FIRST_PSEUDO_REGISTER)
  		{
! 		  reg_live_length[dregno] += d_length;
  		  reg_n_calls_crossed[dregno] += d_n_calls;
  		}
--- 841,847 ----
  	      if (dregno >= FIRST_PSEUDO_REGISTER)
  		{
! 		  if (reg_live_length[dregno] >= 0)
! 		    reg_live_length[dregno] += d_length;
! 
  		  reg_n_calls_crossed[dregno] += d_n_calls;
  		}
*************** update_equiv_regs ()
*** 948,953 ****
  {
    rtx *reg_equiv_init_insn = (rtx *) alloca (max_regno * sizeof (rtx *));
-   rtx *reg_equiv_replacement = (rtx *) alloca (max_regno * sizeof (rtx *));
    rtx insn;
  
    bzero ((char *) reg_equiv_init_insn, max_regno * sizeof (rtx *));
--- 962,968 ----
  {
    rtx *reg_equiv_init_insn = (rtx *) alloca (max_regno * sizeof (rtx *));
    rtx insn;
+ 
+   reg_equiv_replacement = (rtx *) alloca (max_regno * sizeof (rtx *));
  
    bzero ((char *) reg_equiv_init_insn, max_regno * sizeof (rtx *));
diff -rcp2N gcc-2.7.2.3/loop.c gcc-2.7.2.3.f.2/loop.c
*** gcc-2.7.2.3/loop.c	Sat Jun 29 16:26:59 1996
--- gcc-2.7.2.3.f.2/loop.c	Tue Sep  9 07:01:37 1997
*************** int *loop_number_exit_count;
*** 111,116 ****
  unsigned HOST_WIDE_INT loop_n_iterations;
  
! /* Nonzero if there is a subroutine call in the current loop.
!    (unknown_address_altered is also nonzero in this case.)  */
  
  static int loop_has_call;
--- 111,115 ----
  unsigned HOST_WIDE_INT loop_n_iterations;
  
! /* Nonzero if there is a subroutine call in the current loop.  */
  
  static int loop_has_call;
*************** static char *moved_once;
*** 160,164 ****
     here, we just turn on unknown_address_altered.  */
  
! #define NUM_STORES 20
  static rtx loop_store_mems[NUM_STORES];
  
--- 159,163 ----
     here, we just turn on unknown_address_altered.  */
  
! #define NUM_STORES 30
  static rtx loop_store_mems[NUM_STORES];
  
*************** scan_loop (loop_start, end, nregs)
*** 669,673 ****
  	    {
  	      temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
! 	      if (temp && CONSTANT_P (XEXP (temp, 0)))
  		src = XEXP (temp, 0), move_insn = 1;
  	      if (temp && find_reg_note (p, REG_RETVAL, NULL_RTX))
--- 668,673 ----
  	    {
  	      temp = find_reg_note (p, REG_EQUAL, NULL_RTX);
! 	      if (temp && CONSTANT_P (XEXP (temp, 0))
! 		  && LEGITIMATE_CONSTANT_P (XEXP (temp, 0)))
  		src = XEXP (temp, 0), move_insn = 1;
  	      if (temp && find_reg_note (p, REG_RETVAL, NULL_RTX))
*************** move_movables (movables, threshold, insn
*** 1629,1632 ****
--- 1629,1633 ----
  
  	  if (already_moved[regno]
+ 	      || flag_move_all_movables
  	      || (threshold * savings * m->lifetime) >= insn_count
  	      || (m->forces && m->forces->done
*************** prescan_loop (start, end)
*** 2199,2203 ****
        else if (GET_CODE (insn) == CALL_INSN)
  	{
! 	  unknown_address_altered = 1;
  	  loop_has_call = 1;
  	}
--- 2200,2205 ----
        else if (GET_CODE (insn) == CALL_INSN)
  	{
! 	  if (! CONST_CALL_P (insn))
! 	    unknown_address_altered = 1;
  	  loop_has_call = 1;
  	}
*************** invariant_p (x)
*** 2777,2781 ****
        /* See if there is any dependence between a store and this load.  */
        for (i = loop_store_mems_idx - 1; i >= 0; i--)
! 	if (true_dependence (loop_store_mems[i], x))
  	  return 0;
  
--- 2779,2783 ----
        /* See if there is any dependence between a store and this load.  */
        for (i = loop_store_mems_idx - 1; i >= 0; i--)
! 	if (true_dependence (loop_store_mems[i], VOIDmode, x, rtx_varies_p))
  	  return 0;
  
*************** strength_reduce (scan_start, end, loop_t
*** 3821,3826 ****
  	     exit.  */
  
! 	  if (v->lifetime * threshold * benefit < insn_count
! 	      && ! bl->reversed)
  	    {
  	      if (loop_dump_stream)
--- 3823,3828 ----
  	     exit.  */
  
! 	  if ( ! flag_reduce_all_givs && v->lifetime * threshold * benefit < insn_count
! 	      && ! bl->reversed )
  	    {
  	      if (loop_dump_stream)
*************** record_giv (v, insn, src_reg, dest_reg, 
*** 4375,4378 ****
--- 4377,4382 ----
    v->final_value = 0;
    v->same_insn = 0;
+   v->unrolled = 0;
+   v->shared = 0;
  
    /* The v->always_computable field is used in update_giv_derive, to
*************** check_final_value (v, loop_start, loop_e
*** 4652,4657 ****
  	      if (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p)
  		  && LABEL_NAME (JUMP_LABEL (p))
! 		  && ((INSN_LUID (JUMP_LABEL (p)) < INSN_LUID (v->insn)
! 		       && INSN_LUID (JUMP_LABEL (p)) > INSN_LUID (loop_start))
  		      || (INSN_LUID (JUMP_LABEL (p)) > INSN_LUID (last_giv_use)
  			  && INSN_LUID (JUMP_LABEL (p)) < INSN_LUID (loop_end))))
--- 4656,4664 ----
  	      if (GET_CODE (p) == JUMP_INSN && JUMP_LABEL (p)
  		  && LABEL_NAME (JUMP_LABEL (p))
! 		  && ((INSN_UID (JUMP_LABEL (p)) >= max_uid_for_loop)
! 		      || (INSN_UID (v->insn) >= max_uid_for_loop)
! 		      || (INSN_UID (last_giv_use) >= max_uid_for_loop)
! 		      || (INSN_LUID (JUMP_LABEL (p)) < INSN_LUID (v->insn)
! 			  && INSN_LUID (JUMP_LABEL (p)) > INSN_LUID (loop_start))
  		      || (INSN_LUID (JUMP_LABEL (p)) > INSN_LUID (last_giv_use)
  			  && INSN_LUID (JUMP_LABEL (p)) < INSN_LUID (loop_end))))
*************** emit_iv_add_mult (b, m, a, reg, insert_b
*** 5560,5563 ****
--- 5567,5572 ----
  
    emit_insn_before (seq, insert_before);
+ 
+   record_base_value (REGNO (reg), b);
  }
  
diff -rcp2N gcc-2.7.2.3/loop.h gcc-2.7.2.3.f.2/loop.h
*** gcc-2.7.2.3/loop.h	Fri Jul 14 12:23:28 1995
--- gcc-2.7.2.3.f.2/loop.h	Tue Sep  9 07:01:38 1997
*************** struct induction
*** 89,92 ****
--- 89,95 ----
  				   we won't use it to eliminate a biv, it
  				   would probably lose. */
+   unsigned unrolled : 1;	/* 1 if new register has been allocated in
+ 				   unrolled loop.  */
+   unsigned shared : 1;
    int lifetime;			/* Length of life of this giv */
    int times_used;		/* # times this giv is used. */
diff -rcp2N gcc-2.7.2.3/md.texi gcc-2.7.2.3.f.2/md.texi
*** gcc-2.7.2.3/md.texi	Sun Nov 26 19:05:33 1995
--- gcc-2.7.2.3.f.2/md.texi	Tue Sep  9 07:01:38 1997
*************** Some machines require other operations s
*** 2334,2337 ****
--- 2334,2347 ----
  maintaining the back chain.  Define this pattern to emit those
  operations in addition to updating the stack pointer.
+  
+ @cindex @code{check_stack} instruction pattern
+ @item @samp{check_stack}
+ If stack checking cannot be done on your system by probing the stack with
+ a load or store instruction (@pxref{Stack Checking}), define this pattern
+ to perform the needed check and signaling an error if the stack
+ has overflowed.  The single operand is the location in the stack furthest
+ from the current stack pointer that you need to validate.  Normally,
+ on machines where this pattern is needed, you would obtain the stack
+ limit from a global or thread-specific variable or register.
  @end table
  
diff -rcp2N gcc-2.7.2.3/optabs.c gcc-2.7.2.3.f.2/optabs.c
*** gcc-2.7.2.3/optabs.c	Sat Oct 21 22:16:13 1995
--- gcc-2.7.2.3.f.2/optabs.c	Tue Sep  9 07:01:39 1997
*************** expand_fix (to, from, unsignedp)
*** 3878,3885 ****
      }
        
!   if (GET_MODE (to) == GET_MODE (target))
!     emit_move_insn (to, target);
!   else
!     convert_move (to, target, 0);
  }
  
--- 3878,3888 ----
      }
        
!   if (target != to)
!     {
!       if (GET_MODE (to) == GET_MODE (target))
!         emit_move_insn (to, target);
!       else
!         convert_move (to, target, 0);
!     }
  }
  
diff -rcp2N gcc-2.7.2.3/real.c gcc-2.7.2.3.f.2/real.c
*** gcc-2.7.2.3/real.c	Tue Aug 15 21:57:18 1995
--- gcc-2.7.2.3.f.2/real.c	Tue Sep  9 07:01:39 1997
*************** make_nan (nan, sign, mode)
*** 5625,5633 ****
  }
  
! /* Convert an SFmode target `float' value to a REAL_VALUE_TYPE.
!    This is the inverse of the function `etarsingle' invoked by
     REAL_VALUE_TO_TARGET_SINGLE.  */
  
  REAL_VALUE_TYPE
  ereal_from_float (f)
       HOST_WIDE_INT f;
--- 5625,5699 ----
  }
  
! /* This is the inverse of the function `etarsingle' invoked by
     REAL_VALUE_TO_TARGET_SINGLE.  */
  
  REAL_VALUE_TYPE
+ ereal_unto_float (f)
+      long f;
+ {
+   REAL_VALUE_TYPE r;
+   unsigned EMUSHORT s[2];
+   unsigned EMUSHORT e[NE];
+ 
+   /* Convert 32 bit integer to array of 16 bit pieces in target machine order.
+    This is the inverse operation to what the function `endian' does.  */
+   if (REAL_WORDS_BIG_ENDIAN)
+     {
+       s[0] = (unsigned EMUSHORT) (f >> 16);
+       s[1] = (unsigned EMUSHORT) f;
+     }
+   else
+     {
+       s[0] = (unsigned EMUSHORT) f;
+       s[1] = (unsigned EMUSHORT) (f >> 16);
+     }
+   /* Convert and promote the target float to E-type. */
+   e24toe (s, e);
+   /* Output E-type to REAL_VALUE_TYPE. */
+   PUT_REAL (e, &r);
+   return r;
+ }
+ 
+ 
+ /* This is the inverse of the function `etardouble' invoked by
+    REAL_VALUE_TO_TARGET_DOUBLE.  */
+ 
+ REAL_VALUE_TYPE
+ ereal_unto_double (d)
+      long d[];
+ {
+   REAL_VALUE_TYPE r;
+   unsigned EMUSHORT s[4];
+   unsigned EMUSHORT e[NE];
+ 
+   /* Convert array of HOST_WIDE_INT to equivalent array of 16-bit pieces.  */
+   if (REAL_WORDS_BIG_ENDIAN)
+     {
+       s[0] = (unsigned EMUSHORT) (d[0] >> 16);
+       s[1] = (unsigned EMUSHORT) d[0];
+       s[2] = (unsigned EMUSHORT) (d[1] >> 16);
+       s[3] = (unsigned EMUSHORT) d[1];
+     }
+   else
+     {
+       /* Target float words are little-endian.  */
+       s[0] = (unsigned EMUSHORT) d[0];
+       s[1] = (unsigned EMUSHORT) (d[0] >> 16);
+       s[2] = (unsigned EMUSHORT) d[1];
+       s[3] = (unsigned EMUSHORT) (d[1] >> 16);
+     }
+   /* Convert target double to E-type. */
+   e53toe (s, e);
+   /* Output E-type to REAL_VALUE_TYPE. */
+   PUT_REAL (e, &r);
+   return r;
+ }
+ 
+ 
+ /* Convert an SFmode target `float' value to a REAL_VALUE_TYPE.
+    This is somewhat like ereal_unto_float, but the input types
+    for these are different.  */
+ 
+ REAL_VALUE_TYPE
  ereal_from_float (f)
       HOST_WIDE_INT f;
*************** ereal_from_float (f)
*** 5658,5663 ****
  
  /* Convert a DFmode target `double' value to a REAL_VALUE_TYPE.
!    This is the inverse of the function `etardouble' invoked by
!    REAL_VALUE_TO_TARGET_DOUBLE.
  
     The DFmode is stored as an array of HOST_WIDE_INT in the target's
--- 5724,5729 ----
  
  /* Convert a DFmode target `double' value to a REAL_VALUE_TYPE.
!    This is somewhat like ereal_unto_double, but the input types
!    for these are different.
  
     The DFmode is stored as an array of HOST_WIDE_INT in the target's
diff -rcp2N gcc-2.7.2.3/real.h gcc-2.7.2.3.f.2/real.h
*** gcc-2.7.2.3/real.h	Thu Jun 15 11:57:56 1995
--- gcc-2.7.2.3.f.2/real.h	Tue Sep  9 07:01:39 1997
*************** extern void ereal_to_decimal	PROTO((REAL
*** 152,155 ****
--- 152,157 ----
  extern int ereal_cmp		PROTO((REAL_VALUE_TYPE, REAL_VALUE_TYPE));
  extern int ereal_isneg		PROTO((REAL_VALUE_TYPE));
+ extern REAL_VALUE_TYPE ereal_unto_float PROTO((long));
+ extern REAL_VALUE_TYPE ereal_unto_double PROTO((long *));
  extern REAL_VALUE_TYPE ereal_from_float PROTO((HOST_WIDE_INT));
  extern REAL_VALUE_TYPE ereal_from_double PROTO((HOST_WIDE_INT *));
*************** extern REAL_VALUE_TYPE real_value_trunca
*** 197,200 ****
--- 199,208 ----
  /* IN is a REAL_VALUE_TYPE.  OUT is a long. */
  #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) ((OUT) = etarsingle ((IN)))
+ 
+ /* Inverse of REAL_VALUE_TO_TARGET_DOUBLE. */
+ #define REAL_VALUE_UNTO_TARGET_DOUBLE(d)  (ereal_unto_double (d))
+ 
+ /* Inverse of REAL_VALUE_TO_TARGET_SINGLE. */
+ #define REAL_VALUE_UNTO_TARGET_SINGLE(f)  (ereal_unto_float (f))
  
  /* d is an array of HOST_WIDE_INT that holds a double precision
diff -rcp2N gcc-2.7.2.3/recog.c gcc-2.7.2.3.f.2/recog.c
*** gcc-2.7.2.3/recog.c	Sat Jul  1 10:52:35 1995
--- gcc-2.7.2.3.f.2/recog.c	Tue Sep  9 07:01:40 1997
*************** register_operand (op, mode)
*** 872,876 ****
  				REGNO (SUBREG_REG (op)))
  	  && (GET_MODE_SIZE (mode)
! 	      != GET_MODE_SIZE (GET_MODE (SUBREG_REG (op)))))
  	return 0;
  #endif
--- 872,878 ----
  				REGNO (SUBREG_REG (op)))
  	  && (GET_MODE_SIZE (mode)
! 	      != GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
! 	  && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_INT
! 	  && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) != MODE_COMPLEX_FLOAT)
  	return 0;
  #endif
diff -rcp2N gcc-2.7.2.3/reg-stack.c gcc-2.7.2.3.f.2/reg-stack.c
*** gcc-2.7.2.3/reg-stack.c	Thu Jun 15 21:36:05 1995
--- gcc-2.7.2.3.f.2/reg-stack.c	Sun Mar  1 05:16:06 1998
*************** extern rtx emit_label_after ();
*** 241,245 ****
  
  static void find_blocks ();
- static uses_reg_or_mem ();
  static void stack_reg_life_analysis ();
  static void record_reg_life_pat ();
--- 241,244 ----
*************** find_blocks (first)
*** 1326,1353 ****
  	  rtx x;
  
! 	  if (GET_CODE (pat) == PARALLEL)
! 	    {
! 	      int len = XVECLEN (pat, 0);
! 	      int has_use_labelref = 0;
! 	      int i;
! 
! 	      for (i = len - 1; i >= 0; i--)
! 		if (GET_CODE (XVECEXP (pat, 0, i)) == USE
! 		    && GET_CODE (XEXP (XVECEXP (pat, 0, i), 0)) == LABEL_REF)
! 		  has_use_labelref = 1;
! 
! 	      if (! has_use_labelref)
! 		for (i = len - 1; i >= 0; i--)
! 		  if (GET_CODE (XVECEXP (pat, 0, i)) == SET
! 		      && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
! 		      && uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
! 		    computed_jump = 1;
! 	    }
! 	  else if (GET_CODE (pat) == SET
! 		   && SET_DEST (pat) == pc_rtx
! 		   && uses_reg_or_mem (SET_SRC (pat)))
! 	    computed_jump = 1;
! 		    
! 	  if (computed_jump)
  	    {
  	      for (x = label_value_list; x; x = XEXP (x, 1))
--- 1325,1329 ----
  	  rtx x;
  
! 	  if (computed_jump_p (insn))
  	    {
  	      for (x = label_value_list; x; x = XEXP (x, 1))
*************** find_blocks (first)
*** 1367,1402 ****
  }
  
- /* Return 1 if X contain a REG or MEM that is not in the constant pool.  */
- 
- static int
- uses_reg_or_mem (x)
-      rtx x;
- {
-   enum rtx_code code = GET_CODE (x);
-   int i, j;
-   char *fmt;
- 
-   if (code == REG
-       || (code == MEM
- 	  && ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
- 		&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))))
-     return 1;
- 
-   fmt = GET_RTX_FORMAT (code);
-   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-     {
-       if (fmt[i] == 'e'
- 	  && uses_reg_or_mem (XEXP (x, i)))
- 	return 1;
- 
-       if (fmt[i] == 'E')
- 	for (j = 0; j < XVECLEN (x, i); j++)
- 	  if (uses_reg_or_mem (XVECEXP (x, i, j)))
- 	    return 1;
-     }
- 
-   return 0;
- }
- 
  /* If current function returns its result in an fp stack register,
     return the REG.  Otherwise, return 0.  */
--- 1343,1346 ----
*************** stack_reg_life_analysis (first, stackent
*** 1547,1550 ****
--- 1491,1495 ----
  		  block = jump_block;
  		  must_restart = 1;
+ 		  break;
  
  		win:
diff -rcp2N gcc-2.7.2.3/reload.c gcc-2.7.2.3.f.2/reload.c
*** gcc-2.7.2.3/reload.c	Sat Nov 11 13:23:54 1995
--- gcc-2.7.2.3.f.2/reload.c	Tue Sep  9 07:01:41 1997
***************
*** 1,4 ****
  /* Search an insn for pseudo regs that must be in hard regs and are not.
!    Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
  
  This file is part of GNU CC.
--- 1,4 ----
  /* Search an insn for pseudo regs that must be in hard regs and are not.
!    Copyright (C) 1987, 88, 89, 92-5, 1996 Free Software Foundation, Inc.
  
  This file is part of GNU CC.
*************** static int push_secondary_reload PROTO((
*** 292,295 ****
--- 292,296 ----
  					enum machine_mode, enum reload_type,
  					enum insn_code *));
+ static enum reg_class find_valid_class PROTO((enum machine_mode, int));
  static int push_reload		PROTO((rtx, rtx, rtx *, rtx *, enum reg_class,
  				       enum machine_mode, enum machine_mode,
*************** static struct decomposition decompose PR
*** 305,312 ****
  static int immune_p		PROTO((rtx, rtx, struct decomposition));
  static int alternative_allows_memconst PROTO((char *, int));
! static rtx find_reloads_toplev	PROTO((rtx, int, enum reload_type, int, int));
  static rtx make_memloc		PROTO((rtx, int));
  static int find_reloads_address	PROTO((enum machine_mode, rtx *, rtx, rtx *,
! 				       int, enum reload_type, int));
  static rtx subst_reg_equivs	PROTO((rtx));
  static rtx subst_indexed_address PROTO((rtx));
--- 306,313 ----
  static int immune_p		PROTO((rtx, rtx, struct decomposition));
  static int alternative_allows_memconst PROTO((char *, int));
! static rtx find_reloads_toplev	PROTO((rtx, int, enum reload_type, int, int, short *));
  static rtx make_memloc		PROTO((rtx, int));
  static int find_reloads_address	PROTO((enum machine_mode, rtx *, rtx, rtx *,
! 				       int, enum reload_type, int, short *));
  static rtx subst_reg_equivs	PROTO((rtx));
  static rtx subst_indexed_address PROTO((rtx));
*************** push_secondary_reload (in_p, x, opnum, o
*** 590,599 ****
  
        if (in_p && icode == CODE_FOR_nothing
! 	  && SECONDARY_MEMORY_NEEDED (class, reload_class, reload_mode))
! 	get_secondary_mem (x, reload_mode, opnum, type);
  
        if (! in_p && icode == CODE_FOR_nothing
! 	  && SECONDARY_MEMORY_NEEDED (reload_class, class, reload_mode))
! 	get_secondary_mem (x, reload_mode, opnum, type);
  #endif
      }
--- 591,600 ----
  
        if (in_p && icode == CODE_FOR_nothing
! 	  && SECONDARY_MEMORY_NEEDED (class, reload_class, mode))
! 	get_secondary_mem (x, mode, opnum, type);
  
        if (! in_p && icode == CODE_FOR_nothing
! 	  && SECONDARY_MEMORY_NEEDED (reload_class, class, mode))
! 	get_secondary_mem (x, mode, opnum, type);
  #endif
      }
*************** get_secondary_mem (x, mode, opnum, type)
*** 673,677 ****
  
        find_reloads_address (mode, NULL_PTR, XEXP (loc, 0), &XEXP (loc, 0),
! 			    opnum, type, 0);
      }
  
--- 674,678 ----
  
        find_reloads_address (mode, NULL_PTR, XEXP (loc, 0), &XEXP (loc, 0),
! 			    opnum, type, 0, NULL);
      }
  
*************** clear_secondary_mem ()
*** 689,692 ****
--- 690,725 ----
  #endif /* SECONDARY_MEMORY_NEEDED */
  
+ /* Find the largest class for which every register number plus N is valid in
+    M1 (if in range).  Abort if no such class exists.  */
+ 
+ static enum reg_class
+ find_valid_class (m1, n)
+      enum machine_mode  m1;
+      int n;
+ {
+   int class;
+   int regno;
+   enum reg_class best_class;
+   int best_size = 0;
+ 
+   for (class = 1; class < N_REG_CLASSES; class++)
+     {
+       int bad = 0;
+       for (regno = 0; regno < FIRST_PSEUDO_REGISTER && ! bad; regno++)
+ 	if (TEST_HARD_REG_BIT (reg_class_contents[class], regno)
+ 	    && TEST_HARD_REG_BIT (reg_class_contents[class], regno + n)
+ 	    && ! HARD_REGNO_MODE_OK (regno + n, m1))
+ 	  bad = 1;
+ 
+       if (! bad && reg_class_size[class] > best_size)
+ 	best_class = class, best_size = reg_class_size[class];
+     }
+ 
+   if (best_size == 0)
+     abort ();
+ 
+   return best_class;
+ }
+ 
  /* Record one reload that needs to be performed.
     IN is an rtx saying where the data are to be found before this instruction.
*************** push_reload (in, out, inloc, outloc, cla
*** 894,898 ****
        && GET_CODE (SUBREG_REG (in)) == REG
        && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
!       && (! HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (in)), inmode)
  	  || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
  	      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
--- 927,932 ----
        && GET_CODE (SUBREG_REG (in)) == REG
        && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER
!       && (! HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (in)) + SUBREG_WORD (in),
! 				inmode)
  	  || (GET_MODE_SIZE (inmode) <= UNITS_PER_WORD
  	      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
*************** push_reload (in, out, inloc, outloc, cla
*** 909,913 ****
  	 output before the outer reload.  */
        push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), NULL_PTR,
! 		   GENERAL_REGS, VOIDmode, VOIDmode, 0, 0, opnum, type);
        dont_remove_subreg = 1;
      }
--- 943,948 ----
  	 output before the outer reload.  */
        push_reload (SUBREG_REG (in), NULL_RTX, &SUBREG_REG (in), NULL_PTR,
! 		   find_valid_class (inmode, SUBREG_WORD (in)),
! 		   VOIDmode, VOIDmode, 0, 0, opnum, type);
        dont_remove_subreg = 1;
      }
*************** push_reload (in, out, inloc, outloc, cla
*** 982,986 ****
        && GET_CODE (SUBREG_REG (out)) == REG
        && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
!       && (! HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (out)), outmode)
  	  || (GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
  	      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
--- 1017,1022 ----
        && GET_CODE (SUBREG_REG (out)) == REG
        && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
!       && (! HARD_REGNO_MODE_OK (REGNO (SUBREG_REG (out)) + SUBREG_WORD (out),
! 				outmode)
  	  || (GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
  	      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
*************** push_reload (in, out, inloc, outloc, cla
*** 998,1002 ****
        dont_remove_subreg = 1;
        push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
! 		   &SUBREG_REG (out), ALL_REGS, VOIDmode, VOIDmode, 0, 0,
  		   opnum, RELOAD_OTHER);
      }
--- 1034,1040 ----
        dont_remove_subreg = 1;
        push_reload (SUBREG_REG (out), SUBREG_REG (out), &SUBREG_REG (out),
! 		   &SUBREG_REG (out),
! 		   find_valid_class (outmode, SUBREG_WORD (out)),
! 		   VOIDmode, VOIDmode, 0, 0,
  		   opnum, RELOAD_OTHER);
      }
*************** find_reloads (insn, replace, ind_levels,
*** 2241,2244 ****
--- 2279,2283 ----
    int goal_earlyclobber, this_earlyclobber;
    enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
+   short force_update[MAX_RECOG_OPERANDS];
  
    this_insn = insn;
*************** find_reloads (insn, replace, ind_levels,
*** 2272,2275 ****
--- 2311,2316 ----
  #endif
  
+   bzero ((char *) force_update, sizeof force_update);
+ 
    /* Find what kind of insn this is.  NOPERANDS gets number of operands.
       Make OPERANDS point to a vector of operand values.
*************** find_reloads (insn, replace, ind_levels,
*** 2469,2473 ****
  	  find_reloads_address (VOIDmode, NULL_PTR,
  				recog_operand[i], recog_operand_loc[i],
! 				i, operand_type[i], ind_levels);
  	  substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
  	}
--- 2510,2515 ----
  	  find_reloads_address (VOIDmode, NULL_PTR,
  				recog_operand[i], recog_operand_loc[i],
! 				i, operand_type[i], ind_levels,
! 				&force_update[i]);
  	  substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
  	}
*************** find_reloads (insn, replace, ind_levels,
*** 2478,2482 ****
  				    XEXP (recog_operand[i], 0),
  				    &XEXP (recog_operand[i], 0),
! 				    i, address_type[i], ind_levels))
  	    address_reloaded[i] = 1;
  	  substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
--- 2520,2525 ----
  				    XEXP (recog_operand[i], 0),
  				    &XEXP (recog_operand[i], 0),
! 				    i, address_type[i], ind_levels,
! 				    &force_update[i]))
  	    address_reloaded[i] = 1;
  	  substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
*************** find_reloads (insn, replace, ind_levels,
*** 2487,2491 ****
  				 ind_levels,
  				 set != 0
! 				 && &SET_DEST (set) == recog_operand_loc[i]);
        else if (code == PLUS)
  	/* We can get a PLUS as an "operand" as a result of
--- 2530,2535 ----
  				 ind_levels,
  				 set != 0
! 				 && &SET_DEST (set) == recog_operand_loc[i],
! 				 &force_update[i]);
        else if (code == PLUS)
  	/* We can get a PLUS as an "operand" as a result of
*************** find_reloads (insn, replace, ind_levels,
*** 2493,2497 ****
  	substed_operand[i] = recog_operand[i] = *recog_operand_loc[i]
  	  = find_reloads_toplev (recog_operand[i], i, address_type[i],
! 				 ind_levels, 0);
        else if (code == REG)
  	{
--- 2537,2541 ----
  	substed_operand[i] = recog_operand[i] = *recog_operand_loc[i]
  	  = find_reloads_toplev (recog_operand[i], i, address_type[i],
! 				 ind_levels, 0, &force_update[i]);
        else if (code == REG)
  	{
*************** find_reloads (insn, replace, ind_levels,
*** 2505,2510 ****
  	  if (reg_equiv_constant[regno] != 0
  	      && (set == 0 || &SET_DEST (set) != recog_operand_loc[i]))
! 	    substed_operand[i] = recog_operand[i]
! 	      = reg_equiv_constant[regno];
  #if 0 /* This might screw code in reload1.c to delete prior output-reload
  	 that feeds this insn.  */
--- 2549,2557 ----
  	  if (reg_equiv_constant[regno] != 0
  	      && (set == 0 || &SET_DEST (set) != recog_operand_loc[i]))
! 	    {
! 	      substed_operand[i] = recog_operand[i]
! 		= reg_equiv_constant[regno];
! 	      force_update[i] = 1;
! 	    }
  #if 0 /* This might screw code in reload1.c to delete prior output-reload
  	 that feeds this insn.  */
*************** find_reloads (insn, replace, ind_levels,
*** 2545,2549 ****
  				    XEXP (recog_operand[i], 0),
  				    &XEXP (recog_operand[i], 0),
! 				    i, address_type[i], ind_levels);
  	      substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
  	    }
--- 2592,2597 ----
  				    XEXP (recog_operand[i], 0),
  				    &XEXP (recog_operand[i], 0),
! 				    i, address_type[i], ind_levels,
! 				    &force_update[i]);
  	      substed_operand[i] = recog_operand[i] = *recog_operand_loc[i];
  	    }
*************** find_reloads (insn, replace, ind_levels,
*** 3415,3419 ****
  	  = find_reloads_toplev (force_const_mem (operand_mode[i],
  						  recog_operand[i]),
! 				 i, address_type[i], ind_levels, 0);
  	if (alternative_allows_memconst (constraints1[i],
  					 goal_alternative_number))
--- 3463,3467 ----
  	  = find_reloads_toplev (force_const_mem (operand_mode[i],
  						  recog_operand[i]),
! 				 i, address_type[i], ind_levels, 0, NULL);
  	if (alternative_allows_memconst (constraints1[i],
  					 goal_alternative_number))
*************** find_reloads (insn, replace, ind_levels,
*** 3595,3604 ****
       Don't do this if we aren't making replacements because we might be
       propagating things allocated by frame pointer elimination into places
!      it doesn't expect.  */
  
!   if (insn_code_number >= 0 && replace)
      for (i = insn_n_dups[insn_code_number] - 1; i >= 0; i--)
        {
  	int opno = recog_dup_num[i];
  	*recog_dup_loc[i] = *recog_operand_loc[opno];
  	if (operand_reloadnum[opno] >= 0)
--- 3643,3657 ----
       Don't do this if we aren't making replacements because we might be
       propagating things allocated by frame pointer elimination into places
!      it doesn't expect.  However, always do it for replaces of pseudos
!      by constants.  */
  
!   if (insn_code_number >= 0)
      for (i = insn_n_dups[insn_code_number] - 1; i >= 0; i--)
        {
  	int opno = recog_dup_num[i];
+ 
+ 	if (! replace && ! force_update[opno])
+ 	  continue;
+ 
  	*recog_dup_loc[i] = *recog_operand_loc[opno];
  	if (operand_reloadnum[opno] >= 0)
*************** find_reloads (insn, replace, ind_levels,
*** 3829,3832 ****
--- 3882,3886 ----
        register RTX_CODE code = GET_CODE (recog_operand[i]);
        int is_set_dest = GET_CODE (body) == SET && (i == 0);
+       short ign;
  
        if (insn_code_number >= 0)
*************** find_reloads (insn, replace, ind_levels,
*** 3834,3838 ****
  	  find_reloads_address (VOIDmode, NULL_PTR,
  				recog_operand[i], recog_operand_loc[i],
! 				i, RELOAD_FOR_INPUT, ind_levels);
  
        /* In these cases, we can't tell if the operand is an input
--- 3888,3892 ----
  	  find_reloads_address (VOIDmode, NULL_PTR,
  				recog_operand[i], recog_operand_loc[i],
! 				i, RELOAD_FOR_INPUT, ind_levels, &ign);
  
        /* In these cases, we can't tell if the operand is an input
*************** find_reloads (insn, replace, ind_levels,
*** 3845,3853 ****
  			      XEXP (recog_operand[i], 0),
  			      &XEXP (recog_operand[i], 0),
! 			      i, RELOAD_OTHER, ind_levels);
        if (code == SUBREG)
  	recog_operand[i] = *recog_operand_loc[i]
  	  = find_reloads_toplev (recog_operand[i], i, RELOAD_OTHER,
! 				 ind_levels, is_set_dest);
        if (code == REG)
  	{
--- 3899,3907 ----
  			      XEXP (recog_operand[i], 0),
  			      &XEXP (recog_operand[i], 0),
! 			      i, RELOAD_OTHER, ind_levels, &ign);
        if (code == SUBREG)
  	recog_operand[i] = *recog_operand_loc[i]
  	  = find_reloads_toplev (recog_operand[i], i, RELOAD_OTHER,
! 				 ind_levels, is_set_dest, &ign);
        if (code == REG)
  	{
*************** alternative_allows_memconst (constraint,
*** 3908,3915 ****
  
     IS_SET_DEST is true if X is the destination of a SET, which is not
!    appropriate to be replaced by a constant.  */
  
  static rtx
! find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest)
       rtx x;
       int opnum;
--- 3962,3972 ----
  
     IS_SET_DEST is true if X is the destination of a SET, which is not
!    appropriate to be replaced by a constant.
! 
!    FORCE_UPDATE, if non-NULL, is the address of a SHORT that is set to
!    1 if X is replaced with something based on reg_equiv_constant.  */
  
  static rtx
! find_reloads_toplev (x, opnum, type, ind_levels, is_set_dest, force_update)
       rtx x;
       int opnum;
*************** find_reloads_toplev (x, opnum, type, ind
*** 3917,3920 ****
--- 3974,3978 ----
       int ind_levels;
       int is_set_dest;
+      short *force_update;
  {
    register RTX_CODE code = GET_CODE (x);
*************** find_reloads_toplev (x, opnum, type, ind
*** 3928,3932 ****
        register int regno = REGNO (x);
        if (reg_equiv_constant[regno] != 0 && !is_set_dest)
! 	x = reg_equiv_constant[regno];
  #if 0
  /*  This creates (subreg (mem...)) which would cause an unnecessary
--- 3986,3996 ----
        register int regno = REGNO (x);
        if (reg_equiv_constant[regno] != 0 && !is_set_dest)
! 	{
! 	  x = reg_equiv_constant[regno];
! 	  if (force_update)
! 	    *force_update = 1;
! 	  else
! 	    abort ();	/* Learn why this happens. */
! 	}
  #if 0
  /*  This creates (subreg (mem...)) which would cause an unnecessary
*************** find_reloads_toplev (x, opnum, type, ind
*** 3951,3955 ****
  	  find_reloads_address (GET_MODE (x), NULL_PTR,
  				XEXP (x, 0),
! 				&XEXP (x, 0), opnum, type, ind_levels);
  	}
        return x;
--- 4015,4020 ----
  	  find_reloads_address (GET_MODE (x), NULL_PTR,
  				XEXP (x, 0),
! 				&XEXP (x, 0), opnum, type, ind_levels,
! 				force_update);
  	}
        return x;
*************** find_reloads_toplev (x, opnum, type, ind
*** 3959,3963 ****
        rtx tem = x;
        find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
! 			    opnum, type, ind_levels);
        return tem;
      }
--- 4024,4028 ----
        rtx tem = x;
        find_reloads_address (GET_MODE (x), &tem, XEXP (x, 0), &XEXP (x, 0),
! 			    opnum, type, ind_levels, force_update);
        return tem;
      }
*************** find_reloads_toplev (x, opnum, type, ind
*** 3982,3986 ****
  	  && (tem = gen_lowpart_common (GET_MODE (x),
  					reg_equiv_constant[regno])) != 0)
! 	return tem;
  
        if (GET_MODE_BITSIZE (GET_MODE (x)) == BITS_PER_WORD
--- 4047,4057 ----
  	  && (tem = gen_lowpart_common (GET_MODE (x),
  					reg_equiv_constant[regno])) != 0)
! 	{
! 	  if (force_update)
! 	    *force_update = 1;
! 	  else
! 	    abort ();	/* Learn why this happens. */
! 	  return tem;
! 	}
  
        if (GET_MODE_BITSIZE (GET_MODE (x)) == BITS_PER_WORD
*************** find_reloads_toplev (x, opnum, type, ind
*** 3990,3994 ****
  				     SUBREG_WORD (x), 0,
  				     GET_MODE (SUBREG_REG (x)))) != 0)
! 	return tem;
  
        if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
--- 4061,4071 ----
  				     SUBREG_WORD (x), 0,
  				     GET_MODE (SUBREG_REG (x)))) != 0)
! 	{
! 	  if (force_update)
! 	    *force_update = 1;
! 	  else
! 	    abort ();	/* Learn why this happens. */
! 	  return tem;
! 	}
  
        if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] < 0
*************** find_reloads_toplev (x, opnum, type, ind
*** 4040,4044 ****
  	  find_reloads_address (GET_MODE (x), NULL_PTR,
  				XEXP (x, 0),
! 				&XEXP (x, 0), opnum, type, ind_levels);
  	}
  
--- 4117,4122 ----
  	  find_reloads_address (GET_MODE (x), NULL_PTR,
  				XEXP (x, 0),
! 				&XEXP (x, 0), opnum, type, ind_levels,
! 				force_update);
  	}
  
*************** find_reloads_toplev (x, opnum, type, ind
*** 4049,4053 ****
        if (fmt[i] == 'e')
  	XEXP (x, i) = find_reloads_toplev (XEXP (x, i), opnum, type,
! 					   ind_levels, is_set_dest);
      }
    return x;
--- 4127,4131 ----
        if (fmt[i] == 'e')
  	XEXP (x, i) = find_reloads_toplev (XEXP (x, i), opnum, type,
! 					   ind_levels, is_set_dest, NULL);
      }
    return x;
*************** make_memloc (ad, regno)
*** 4110,4114 ****
  
  static int
! find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels)
       enum machine_mode mode;
       rtx *memrefloc;
--- 4188,4193 ----
  
  static int
! find_reloads_address (mode, memrefloc, ad, loc, opnum, type, ind_levels,
! 		      force_update)
       enum machine_mode mode;
       rtx *memrefloc;
*************** find_reloads_address (mode, memrefloc, a
*** 4118,4121 ****
--- 4197,4201 ----
       enum reload_type type;
       int ind_levels;
+      short *force_update;
  {
    register int regno;
*************** find_reloads_address (mode, memrefloc, a
*** 4134,4137 ****
--- 4214,4221 ----
  	{
  	  *loc = ad = reg_equiv_constant[regno];
+ 	  if (force_update)
+ 	    *force_update = 1;
+ 	  else
+ 	    abort ();	/* Learn why this happens. */
  	  return 1;
  	}
*************** find_reloads_address (mode, memrefloc, a
*** 4141,4145 ****
  	  tem = make_memloc (ad, regno);
  	  find_reloads_address (GET_MODE (tem), NULL_PTR, XEXP (tem, 0),
! 				&XEXP (tem, 0), opnum, type, ind_levels);
  	  push_reload (tem, NULL_RTX, loc, NULL_PTR, BASE_REG_CLASS,
  		       GET_MODE (ad), VOIDmode, 0, 0,
--- 4225,4229 ----
  	  tem = make_memloc (ad, regno);
  	  find_reloads_address (GET_MODE (tem), NULL_PTR, XEXP (tem, 0),
! 				&XEXP (tem, 0), opnum, type, ind_levels, NULL);
  	  push_reload (tem, NULL_RTX, loc, NULL_PTR, BASE_REG_CLASS,
  		       GET_MODE (ad), VOIDmode, 0, 0,
*************** find_reloads_address (mode, memrefloc, a
*** 4214,4218 ****
        tem = ad;
        find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
! 			    opnum, type, ind_levels == 0 ? 0 : ind_levels - 1);
  
        /* If tem was changed, then we must create a new memory reference to
--- 4298,4303 ----
        tem = ad;
        find_reloads_address (GET_MODE (ad), &tem, XEXP (ad, 0), &XEXP (ad, 0),
! 			    opnum, type, ind_levels == 0 ? 0 : ind_levels - 1,
! 			    NULL);
  
        /* If tem was changed, then we must create a new memory reference to
*************** find_reloads_address_1 (x, context, loc,
*** 4722,4726 ****
  	      /* First reload the memory location's address.  */
  	      find_reloads_address (GET_MODE (tem), 0, XEXP (tem, 0),
! 				    &XEXP (tem, 0), opnum, type, ind_levels);
  	      /* Put this inside a new increment-expression.  */
  	      x = gen_rtx (GET_CODE (x), GET_MODE (x), tem);
--- 4807,4812 ----
  	      /* First reload the memory location's address.  */
  	      find_reloads_address (GET_MODE (tem), 0, XEXP (tem, 0),
! 				    &XEXP (tem, 0), opnum, type, ind_levels,
! 				    NULL);
  	      /* Put this inside a new increment-expression.  */
  	      x = gen_rtx (GET_CODE (x), GET_MODE (x), tem);
*************** find_reloads_address_1 (x, context, loc,
*** 4788,4792 ****
  	  find_reloads_address (GET_MODE (x), &XEXP (x, 0),
  				XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
! 				opnum, type, ind_levels);
  
  	  reloadnum = push_reload (x, NULL_RTX, loc, NULL_PTR,
--- 4874,4878 ----
  	  find_reloads_address (GET_MODE (x), &XEXP (x, 0),
  				XEXP (XEXP (x, 0), 0), &XEXP (XEXP (x, 0), 0),
! 				opnum, type, ind_levels, NULL);
  
  	  reloadnum = push_reload (x, NULL_RTX, loc, NULL_PTR,
*************** find_reloads_address_1 (x, context, loc,
*** 4818,4822 ****
  
        find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
! 			    opnum, type, ind_levels);
        push_reload (*loc, NULL_RTX, loc, NULL_PTR,
  		   context ? INDEX_REG_CLASS : BASE_REG_CLASS,
--- 4904,4908 ----
  
        find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0),
! 			    opnum, type, ind_levels, NULL);
        push_reload (*loc, NULL_RTX, loc, NULL_PTR,
  		   context ? INDEX_REG_CLASS : BASE_REG_CLASS,
*************** find_reloads_address_1 (x, context, loc,
*** 4852,4856 ****
  	    x = make_memloc (x, regno);
  	    find_reloads_address (GET_MODE (x), 0, XEXP (x, 0), &XEXP (x, 0),
! 				  opnum, type, ind_levels);
  	  }
  
--- 4938,4942 ----
  	    x = make_memloc (x, regno);
  	    find_reloads_address (GET_MODE (x), 0, XEXP (x, 0), &XEXP (x, 0),
! 				  opnum, type, ind_levels, NULL);
  	  }
  
*************** find_reloads_address_part (x, loc, class
*** 4965,4969 ****
        rtx tem = x = force_const_mem (mode, x);
        find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
! 			    opnum, type, ind_levels);
      }
  
--- 5051,5055 ----
        rtx tem = x = force_const_mem (mode, x);
        find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
! 			    opnum, type, ind_levels, NULL);
      }
  
*************** find_reloads_address_part (x, loc, class
*** 4977,4981 ****
        x = gen_rtx (PLUS, GET_MODE (x), XEXP (x, 0), tem);
        find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
! 			    opnum, type, ind_levels);
      }
  
--- 5063,5067 ----
        x = gen_rtx (PLUS, GET_MODE (x), XEXP (x, 0), tem);
        find_reloads_address (mode, &tem, XEXP (tem, 0), &XEXP (tem, 0),
! 			    opnum, type, ind_levels, NULL);
      }
  
*************** find_equiv_reg (goal, insn, class, other
*** 5518,5522 ****
       and is also a register that appears in the address of GOAL.  */
  
!   if (goal_mem && value == SET_DEST (PATTERN (where))
        && refers_to_regno_for_reload_p (valueno,
  				       (valueno
--- 5604,5608 ----
       and is also a register that appears in the address of GOAL.  */
  
!   if (goal_mem && value == SET_DEST (single_set (where))
        && refers_to_regno_for_reload_p (valueno,
  				       (valueno
*************** debug_reload()
*** 5900,5904 ****
  
        if (reload_nocombine[r])
! 	fprintf (stderr, ", can combine", reload_nocombine[r]);
  
        if (reload_secondary_p[r])
--- 5986,5990 ----
  
        if (reload_nocombine[r])
! 	fprintf (stderr, ", can't combine %d", reload_nocombine[r]);
  
        if (reload_secondary_p[r])
diff -rcp2N gcc-2.7.2.3/reload1.c gcc-2.7.2.3.f.2/reload1.c
*** gcc-2.7.2.3/reload1.c	Sun Nov  5 16:22:22 1995
--- gcc-2.7.2.3.f.2/reload1.c	Tue Sep  9 07:01:42 1997
*************** reload (first, global, dumpfile)
*** 542,546 ****
       Also find all paradoxical subregs and find largest such for each pseudo.
       On machines with small register classes, record hard registers that
!      are used for user variables.  These can never be used for spills.  */
  
    for (insn = first; insn; insn = NEXT_INSN (insn))
--- 542,548 ----
       Also find all paradoxical subregs and find largest such for each pseudo.
       On machines with small register classes, record hard registers that
!      are used for user variables.  These can never be used for spills. 
!      Also look for a "constant" NOTE_INSN_SETJMP.  This means that all
!      caller-saved registers must be marked live.  */
  
    for (insn = first; insn; insn = NEXT_INSN (insn))
*************** reload (first, global, dumpfile)
*** 548,551 ****
--- 550,559 ----
        rtx set = single_set (insn);
  
+       if (GET_CODE (insn) == NOTE && CONST_CALL_P (insn)
+ 	  && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
+ 	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ 	  if (! call_used_regs[i])
+ 	    regs_ever_live[i] = 1;
+ 
        if (set != 0 && GET_CODE (SET_DEST (set)) == REG)
  	{
*************** reload (first, global, dumpfile)
*** 564,568 ****
  		  if (GET_CODE (x) == MEM)
  		    reg_equiv_memory_loc[i] = x;
! 		  else if (CONSTANT_P (x))
  		    {
  		      if (LEGITIMATE_CONSTANT_P (x))
--- 572,578 ----
  		  if (GET_CODE (x) == MEM)
  		    reg_equiv_memory_loc[i] = x;
! 		  else if (CONSTANT_P (x)
! 			   && ! (GET_CODE (x) == CONST
! 				 && GET_CODE (XEXP (x, 0)) == MINUS))
  		    {
  		      if (LEGITIMATE_CONSTANT_P (x))
*************** reload (first, global, dumpfile)
*** 2013,2016 ****
--- 2023,2040 ----
  #endif
  
+   /* If we are doing stack checking, give a warning if this function's
+      frame size is larger than we expect.  */
+   if (flag_stack_check && ! STACK_CHECK_BUILTIN)
+     {
+       HOST_WIDE_INT size = get_frame_size () + STACK_CHECK_FIXED_FRAME_SIZE;
+ 
+       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ 	if (regs_ever_live[i] && ! fixed_regs[i] && call_used_regs[i])
+ 	  size += UNITS_PER_WORD;
+ 
+       if (size > STACK_CHECK_MAX_FRAME_SIZE)
+ 	warning ("frame size too large for reliable stack checking");
+     }
+ 	
    /* Indicate that we no longer have known memory locations or constants.  */
    reg_equiv_constant = 0;
*************** eliminate_regs (x, mem_mode, insn)
*** 2886,2890 ****
  
        /* Fall through to generic unary operation case.  */
-     case USE:
      case STRICT_LOW_PART:
      case NEG:          case NOT:
--- 2910,2913 ----
*************** eliminate_regs (x, mem_mode, insn)
*** 2975,2978 ****
--- 2998,3014 ----
        return x;
  
+     case USE:
+       /* If using a register that is the source of an eliminate we still
+ 	 think can be performed, note it cannot be performed since we don't
+ 	 know how this register is used.  */
+       for (ep = reg_eliminate; ep < &reg_eliminate[NUM_ELIMINABLE_REGS]; ep++)
+ 	if (ep->from_rtx == XEXP (x, 0))
+ 	  ep->can_eliminate = 0;
+ 
+       new = eliminate_regs (XEXP (x, 0), mem_mode, insn);
+       if (new != XEXP (x, 0))
+ 	return gen_rtx (code, GET_MODE (x), new);
+       return x;
+ 
      case CLOBBER:
        /* If clobbering a register that is the replacement register for an
*************** gen_reload (out, in, opnum, type)
*** 6736,6741 ****
--- 6772,6779 ----
    if (GET_CODE (in) == PLUS
        && (GET_CODE (XEXP (in, 0)) == REG
+ 	  || GET_CODE (XEXP (in, 0)) == SUBREG
  	  || GET_CODE (XEXP (in, 0)) == MEM)
        && (GET_CODE (XEXP (in, 1)) == REG
+ 	  || GET_CODE (XEXP (in, 1)) == SUBREG
  	  || CONSTANT_P (XEXP (in, 1))
  	  || GET_CODE (XEXP (in, 1)) == MEM))
*************** gen_reload (out, in, opnum, type)
*** 6798,6807 ****
  	 we emit below.  */
  
!       if (CONSTANT_P (op1) || GET_CODE (op1) == MEM
  	  || (GET_CODE (op1) == REG
  	      && REGNO (op1) >= FIRST_PSEUDO_REGISTER))
  	tem = op0, op0 = op1, op1 = tem;
  
!       emit_insn (gen_move_insn (out, op0));
  
        /* If OP0 and OP1 are the same, we can use OUT for OP1.
--- 6836,6845 ----
  	 we emit below.  */
  
!       if (CONSTANT_P (op1) || GET_CODE (op1) == MEM || GET_CODE (op1) == SUBREG
  	  || (GET_CODE (op1) == REG
  	      && REGNO (op1) >= FIRST_PSEUDO_REGISTER))
  	tem = op0, op0 = op1, op1 = tem;
  
!       gen_reload (out, op0, opnum, type);
  
        /* If OP0 and OP1 are the same, we can use OUT for OP1.
*************** gen_reload (out, in, opnum, type)
*** 6831,6835 ****
        delete_insns_since (last);
  
!       emit_insn (gen_move_insn (out, op1));
        emit_insn (gen_add2_insn (out, op0));
      }
--- 6869,6873 ----
        delete_insns_since (last);
  
!       gen_reload (out, op1, opnum, type);
        emit_insn (gen_add2_insn (out, op0));
      }
*************** gen_reload (out, in, opnum, type)
*** 6852,6857 ****
  	in = gen_rtx (REG, GET_MODE (loc), REGNO (in));
  
!       emit_insn (gen_move_insn (loc, in));
!       emit_insn (gen_move_insn (out, loc));
      }
  #endif
--- 6890,6895 ----
  	in = gen_rtx (REG, GET_MODE (loc), REGNO (in));
  
!       gen_reload (loc, in, opnum, type);
!       gen_reload (out, loc, opnum, type);
      }
  #endif
diff -rcp2N gcc-2.7.2.3/reorg.c gcc-2.7.2.3.f.2/reorg.c
*** gcc-2.7.2.3/reorg.c	Fri Sep 15 21:38:55 1995
--- gcc-2.7.2.3.f.2/reorg.c	Tue Sep  9 07:01:43 1997
*************** redundant_insn (insn, target, delay_list
*** 1961,1964 ****
--- 1961,1969 ----
    int i;
  
+   /* If INSN has any REG_UNUSED notes, it can't match anything since we
+      are allowed to not actually assign to such a register.  */
+   if (find_reg_note (insn, REG_UNUSED, NULL_RTX) != 0)
+     return 0;
+ 
    /* Scan backwards looking for a match.  */
    for (trial = PREV_INSN (target); trial; trial = PREV_INSN (trial))
*************** redundant_insn (insn, target, delay_list
*** 1999,2003 ****
  	  for (i = XVECLEN (pat, 0) - 1; i > 0; i--)
  	    if (GET_CODE (XVECEXP (pat, 0, i)) == GET_CODE (insn)
! 		&& rtx_equal_p (PATTERN (XVECEXP (pat, 0, i)), ipat))
  	      break;
  
--- 2004,2009 ----
  	  for (i = XVECLEN (pat, 0) - 1; i > 0; i--)
  	    if (GET_CODE (XVECEXP (pat, 0, i)) == GET_CODE (insn)
! 		&& rtx_equal_p (PATTERN (XVECEXP (pat, 0, i)), ipat)
! 		&& ! find_reg_note (XVECEXP (pat, 0, i), REG_UNUSED, NULL_RTX))
  	      break;
  
*************** redundant_insn (insn, target, delay_list
*** 2007,2011 ****
  	}
  
!       else if (GET_CODE (trial) == GET_CODE (insn) && rtx_equal_p (pat, ipat))
  	break;
      }
--- 2013,2018 ----
  	}
  
!       else if (GET_CODE (trial) == GET_CODE (insn) && rtx_equal_p (pat, ipat)
! 	       && ! find_reg_note (trial, REG_UNUSED, NULL_RTX))
  	break;
      }
diff -rcp2N gcc-2.7.2.3/rtl.c gcc-2.7.2.3.f.2/rtl.c
*** gcc-2.7.2.3/rtl.c	Thu Jun 15 12:02:59 1995
--- gcc-2.7.2.3.f.2/rtl.c	Tue Sep  9 07:01:43 1997
*************** char *reg_note_name[] = { "", "REG_DEAD"
*** 179,183 ****
  			  "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
  			  "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
! 			  "REG_DEP_ANTI", "REG_DEP_OUTPUT" };
  
  /* Allocate an rtx vector of N elements.
--- 179,183 ----
  			  "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
  			  "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
! 			  "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_NOALIAS" };
  
  /* Allocate an rtx vector of N elements.
diff -rcp2N gcc-2.7.2.3/rtl.h gcc-2.7.2.3.f.2/rtl.h
*** gcc-2.7.2.3/rtl.h	Thu Jun 15 12:03:16 1995
--- gcc-2.7.2.3.f.2/rtl.h	Sun Mar  1 04:13:08 1998
*************** enum reg_note { REG_DEAD = 1, REG_INC = 
*** 349,353 ****
  		REG_NONNEG = 8, REG_NO_CONFLICT = 9, REG_UNUSED = 10,
  		REG_CC_SETTER = 11, REG_CC_USER = 12, REG_LABEL = 13,
! 		REG_DEP_ANTI = 14, REG_DEP_OUTPUT = 15 };
  
  /* Define macros to extract and insert the reg-note kind in an EXPR_LIST.  */
--- 349,353 ----
  		REG_NONNEG = 8, REG_NO_CONFLICT = 9, REG_UNUSED = 10,
  		REG_CC_SETTER = 11, REG_CC_USER = 12, REG_LABEL = 13,
! 		REG_DEP_ANTI = 14, REG_DEP_OUTPUT = 15, REG_NOALIAS = 16 };
  
  /* Define macros to extract and insert the reg-note kind in an EXPR_LIST.  */
*************** extern char *reg_note_name[];
*** 432,436 ****
  #define NOTE_INSN_FUNCTION_BEG -13
  
- 
  #if 0 /* These are not used, and I don't know what they were for. --rms.  */
  #define NOTE_DECL_NAME(INSN) ((INSN)->fld[3].rtstr)
--- 432,435 ----
*************** extern char *note_insn_name[];
*** 576,579 ****
--- 575,579 ----
  /* For a TRAP_IF rtx, TRAP_CONDITION is an expression.  */
  #define TRAP_CONDITION(RTX) ((RTX)->fld[0].rtx)
+ #define TRAP_CODE(RTX) ((RTX)->fld[1].rtint)
  
  /* 1 in a SYMBOL_REF if it addresses this function's constants pool.  */
*************** extern rtx eliminate_constant_term	PROTO
*** 817,820 ****
--- 817,831 ----
  extern rtx expand_complex_abs		PROTO((enum machine_mode, rtx, rtx, int));
  extern enum machine_mode choose_hard_reg_mode PROTO((int, int));
+ extern int rtx_varies_p		PROTO((rtx));
+ extern int may_trap_p		PROTO((rtx));
+ extern int side_effects_p	PROTO((rtx));
+ extern int volatile_refs_p	PROTO((rtx));
+ extern int volatile_insn_p	PROTO((rtx));
+ extern void remove_note		PROTO((rtx, rtx));
+ extern void note_stores		PROTO((rtx, void (*)()));
+ extern int refers_to_regno_p	PROTO((int, int, rtx, rtx *));
+ extern int reg_overlap_mentioned_p PROTO((rtx, rtx));
+ extern int computed_jump_p		PROTO((rtx));
+ 
  
  /* Maximum number of parallel sets and clobbers in any insn in this fn.
*************** extern rtx *regno_reg_rtx;
*** 967,968 ****
--- 978,988 ----
  
  extern int rtx_to_tree_code	PROTO((enum rtx_code));
+ 
+ extern int true_dependence	PROTO((rtx, enum machine_mode, rtx, int (*)()));
+ extern int read_dependence	PROTO((rtx, rtx));
+ extern int anti_dependence	PROTO((rtx, rtx));
+ extern int output_dependence	PROTO((rtx, rtx));
+ extern void init_alias_analysis	PROTO((void));
+ extern void end_alias_analysis	PROTO((void));
+ extern void mark_user_reg	PROTO((rtx));
+ extern void mark_reg_pointer	PROTO((rtx));
diff -rcp2N gcc-2.7.2.3/rtlanal.c gcc-2.7.2.3.f.2/rtlanal.c
*** gcc-2.7.2.3/rtlanal.c	Fri Oct  6 17:13:57 1995
--- gcc-2.7.2.3.f.2/rtlanal.c	Sun Mar  1 04:15:29 1998
*************** void note_stores ();
*** 26,29 ****
--- 26,32 ----
  int reg_set_p ();
  
+ /* Forward declarations */
+ static int jmp_uses_reg_or_mem		PROTO((rtx));
+ 
  /* Bit flags that specify the machine subtype we are compiling for.
     Bits are tested using macros TARGET_... defined in the tm.h file
*************** replace_regs (x, reg_map, nregs, replace
*** 1838,1840 ****
--- 1841,1936 ----
      }
    return x;
+ }
+ 
+ /* Return 1 if X, the SRC_SRC of  SET of (pc) contain a REG or MEM that is
+    not in the constant pool and not in the condition of an IF_THEN_ELSE.  */
+ 
+ static int
+ jmp_uses_reg_or_mem (x)
+      rtx x;
+ {
+   enum rtx_code code = GET_CODE (x);
+   int i, j;
+   char *fmt;
+ 
+   switch (code)
+     {
+     case CONST:
+     case LABEL_REF:
+     case PC:
+       return 0;
+ 
+     case REG:
+       return 1;
+ 
+     case MEM:
+       return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
+ 		&& CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
+ 
+     case IF_THEN_ELSE:
+       return (jmp_uses_reg_or_mem (XEXP (x, 1))
+ 	      || jmp_uses_reg_or_mem (XEXP (x, 2)));
+ 
+     case PLUS:  case MINUS:  case MULT:
+       return (jmp_uses_reg_or_mem (XEXP (x, 0))
+ 	      || jmp_uses_reg_or_mem (XEXP (x, 1)));
+ 
+     default:
+       break;
+     }
+ 
+   fmt = GET_RTX_FORMAT (code);
+   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+     {
+       if (fmt[i] == 'e'
+ 	  && jmp_uses_reg_or_mem (XEXP (x, i)))
+ 	return 1;
+ 
+       if (fmt[i] == 'E')
+ 	for (j = 0; j < XVECLEN (x, i); j++)
+ 	  if (jmp_uses_reg_or_mem (XVECEXP (x, i, j)))
+ 	    return 1;
+     }
+ 
+   return 0;
+ }
+ 
+ /* Return nonzero if INSN is an indirect jump (aka computed jump).
+ 
+    Tablejumps and casesi insns are not considered indirect jumps;
+    we can recognize them by a (use (lael_ref)).  */
+ 
+ int
+ computed_jump_p (insn)
+      rtx insn;
+ {
+   int i;
+   if (GET_CODE (insn) == JUMP_INSN)
+     {
+       rtx pat = PATTERN (insn);
+ 
+       if (GET_CODE (pat) == PARALLEL)
+ 	{
+ 	  int len = XVECLEN (pat, 0);
+ 	  int has_use_labelref = 0;
+ 
+ 	  for (i = len - 1; i >= 0; i--)
+ 	    if (GET_CODE (XVECEXP (pat, 0, i)) == USE
+ 		&& (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
+ 		    == LABEL_REF))
+ 	      has_use_labelref = 1;
+ 
+ 	  if (! has_use_labelref)
+ 	    for (i = len - 1; i >= 0; i--)
+ 	      if (GET_CODE (XVECEXP (pat, 0, i)) == SET
+ 		  && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
+ 		  && jmp_uses_reg_or_mem (SET_SRC (XVECEXP (pat, 0, i))))
+ 		return 1;
+ 	}
+       else if (GET_CODE (pat) == SET
+ 	       && SET_DEST (pat) == pc_rtx
+ 	       && jmp_uses_reg_or_mem (SET_SRC (pat)))
+ 	return 1;
+     }
+   return 0;
  }
diff -rcp2N gcc-2.7.2.3/sched.c gcc-2.7.2.3.f.2/sched.c
*** gcc-2.7.2.3/sched.c	Thu Jun 15 12:06:39 1995
--- gcc-2.7.2.3.f.2/sched.c	Tue Sep  9 07:01:44 1997
*************** Boston, MA 02111-1307, USA.  */
*** 126,129 ****
--- 126,132 ----
  #include "insn-attr.h"
  
+ extern char *reg_known_equiv_p;
+ extern rtx *reg_known_value;
+ 
  #ifdef INSN_SCHEDULING
  /* Arrays set up by scheduling for the same respective purposes as
*************** static int *sched_reg_live_length;
*** 143,146 ****
--- 146,150 ----
     by splitting insns.  */
  static rtx *reg_last_uses;
+ static int reg_last_uses_size;
  static rtx *reg_last_sets;
  static regset reg_pending_sets;
*************** struct sometimes
*** 294,302 ****
  
  /* Forward declarations.  */
- static rtx canon_rtx			PROTO((rtx));
- static int rtx_equal_for_memref_p	PROTO((rtx, rtx));
- static rtx find_symbolic_term		PROTO((rtx));
- static int memrefs_conflict_p		PROTO((int, rtx, int, rtx,
- 					       HOST_WIDE_INT));
  static void add_dependence		PROTO((rtx, rtx, enum reg_note));
  static void remove_dependence		PROTO((rtx, rtx));
--- 298,301 ----
*************** static int priority			PROTO((rtx));
*** 314,318 ****
  static void free_pending_lists		PROTO((void));
  static void add_insn_mem_dependence	PROTO((rtx *, rtx *, rtx, rtx));
! static void flush_pending_lists		PROTO((rtx));
  static void sched_analyze_1		PROTO((rtx, rtx));
  static void sched_analyze_2		PROTO((rtx, rtx));
--- 313,317 ----
  static void free_pending_lists		PROTO((void));
  static void add_insn_mem_dependence	PROTO((rtx *, rtx *, rtx, rtx));
! static void flush_pending_lists		PROTO((rtx, int));
  static void sched_analyze_1		PROTO((rtx, rtx));
  static void sched_analyze_2		PROTO((rtx, rtx));
*************** void schedule_insns	PROTO((FILE *));
*** 346,885 ****
  #endif /* INSN_SCHEDULING */
  
- #define SIZE_FOR_MODE(X) (GET_MODE_SIZE (GET_MODE (X)))
- 
- /* Vector indexed by N giving the initial (unchanging) value known
-    for pseudo-register N.  */
- static rtx *reg_known_value;
- 
- /* Vector recording for each reg_known_value whether it is due to a
-    REG_EQUIV note.  Future passes (viz., reload) may replace the
-    pseudo with the equivalent expression and so we account for the
-    dependences that would be introduced if that happens. */
- /* ??? This is a problem only on the Convex.  The REG_EQUIV notes created in
-    assign_parms mention the arg pointer, and there are explicit insns in the
-    RTL that modify the arg pointer.  Thus we must ensure that such insns don't
-    get scheduled across each other because that would invalidate the REG_EQUIV
-    notes.  One could argue that the REG_EQUIV notes are wrong, but solving
-    the problem in the scheduler will likely give better code, so we do it
-    here.  */
- static char *reg_known_equiv_p;
- 
- /* Indicates number of valid entries in reg_known_value.  */
- static int reg_known_value_size;
- 
- static rtx
- canon_rtx (x)
-      rtx x;
- {
-   if (GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER
-       && REGNO (x) <= reg_known_value_size)
-     return reg_known_value[REGNO (x)];
-   else if (GET_CODE (x) == PLUS)
-     {
-       rtx x0 = canon_rtx (XEXP (x, 0));
-       rtx x1 = canon_rtx (XEXP (x, 1));
- 
-       if (x0 != XEXP (x, 0) || x1 != XEXP (x, 1))
- 	{
- 	  /* We can tolerate LO_SUMs being offset here; these
- 	     rtl are used for nothing other than comparisons.  */
- 	  if (GET_CODE (x0) == CONST_INT)
- 	    return plus_constant_for_output (x1, INTVAL (x0));
- 	  else if (GET_CODE (x1) == CONST_INT)
- 	    return plus_constant_for_output (x0, INTVAL (x1));
- 	  return gen_rtx (PLUS, GET_MODE (x), x0, x1);
- 	}
-     }
-   return x;
- }
- 
- /* Set up all info needed to perform alias analysis on memory references.  */
- 
- void
- init_alias_analysis ()
- {
-   int maxreg = max_reg_num ();
-   rtx insn;
-   rtx note;
-   rtx set;
- 
-   reg_known_value_size = maxreg;
- 
-   reg_known_value
-     = (rtx *) oballoc ((maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx))
-       - FIRST_PSEUDO_REGISTER;
-   bzero ((char *) (reg_known_value + FIRST_PSEUDO_REGISTER),
- 	 (maxreg-FIRST_PSEUDO_REGISTER) * sizeof (rtx));
- 
-   reg_known_equiv_p
-     = (char *) oballoc ((maxreg -FIRST_PSEUDO_REGISTER) * sizeof (char))
-       - FIRST_PSEUDO_REGISTER;
-   bzero (reg_known_equiv_p + FIRST_PSEUDO_REGISTER,
- 	 (maxreg - FIRST_PSEUDO_REGISTER) * sizeof (char));
- 
-   /* Fill in the entries with known constant values.  */
-   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
-     if ((set = single_set (insn)) != 0
- 	&& GET_CODE (SET_DEST (set)) == REG
- 	&& REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER
- 	&& (((note = find_reg_note (insn, REG_EQUAL, 0)) != 0
- 	     && reg_n_sets[REGNO (SET_DEST (set))] == 1)
- 	    || (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != 0)
- 	&& GET_CODE (XEXP (note, 0)) != EXPR_LIST)
-       {
- 	int regno = REGNO (SET_DEST (set));
- 	reg_known_value[regno] = XEXP (note, 0);
- 	reg_known_equiv_p[regno] = REG_NOTE_KIND (note) == REG_EQUIV;
-       }
- 
-   /* Fill in the remaining entries.  */
-   while (--maxreg >= FIRST_PSEUDO_REGISTER)
-     if (reg_known_value[maxreg] == 0)
-       reg_known_value[maxreg] = regno_reg_rtx[maxreg];
- }
- 
- /* Return 1 if X and Y are identical-looking rtx's.
- 
-    We use the data in reg_known_value above to see if two registers with
-    different numbers are, in fact, equivalent.  */
- 
- static int
- rtx_equal_for_memref_p (x, y)
-      rtx x, y;
- {
-   register int i;
-   register int j;
-   register enum rtx_code code;
-   register char *fmt;
- 
-   if (x == 0 && y == 0)
-     return 1;
-   if (x == 0 || y == 0)
-     return 0;
-   x = canon_rtx (x);
-   y = canon_rtx (y);
- 
-   if (x == y)
-     return 1;
- 
-   code = GET_CODE (x);
-   /* Rtx's of different codes cannot be equal.  */
-   if (code != GET_CODE (y))
-     return 0;
- 
-   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
-      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
- 
-   if (GET_MODE (x) != GET_MODE (y))
-     return 0;
- 
-   /* REG, LABEL_REF, and SYMBOL_REF can be compared nonrecursively.  */
- 
-   if (code == REG)
-     return REGNO (x) == REGNO (y);
-   if (code == LABEL_REF)
-     return XEXP (x, 0) == XEXP (y, 0);
-   if (code == SYMBOL_REF)
-     return XSTR (x, 0) == XSTR (y, 0);
- 
-   /* For commutative operations, the RTX match if the operand match in any
-      order.  Also handle the simple binary and unary cases without a loop.  */
-   if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c')
-     return ((rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
- 	     && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)))
- 	    || (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 1))
- 		&& rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 0))));
-   else if (GET_RTX_CLASS (code) == '<' || GET_RTX_CLASS (code) == '2')
-     return (rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0))
- 	    && rtx_equal_for_memref_p (XEXP (x, 1), XEXP (y, 1)));
-   else if (GET_RTX_CLASS (code) == '1')
-     return rtx_equal_for_memref_p (XEXP (x, 0), XEXP (y, 0));
- 
-   /* Compare the elements.  If any pair of corresponding elements
-      fail to match, return 0 for the whole things.  */
- 
-   fmt = GET_RTX_FORMAT (code);
-   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-     {
-       switch (fmt[i])
- 	{
- 	case 'w':
- 	  if (XWINT (x, i) != XWINT (y, i))
- 	    return 0;
- 	  break;
- 
- 	case 'n':
- 	case 'i':
- 	  if (XINT (x, i) != XINT (y, i))
- 	    return 0;
- 	  break;
- 
- 	case 'V':
- 	case 'E':
- 	  /* Two vectors must have the same length.  */
- 	  if (XVECLEN (x, i) != XVECLEN (y, i))
- 	    return 0;
- 
- 	  /* And the corresponding elements must match.  */
- 	  for (j = 0; j < XVECLEN (x, i); j++)
- 	    if (rtx_equal_for_memref_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
- 	      return 0;
- 	  break;
- 
- 	case 'e':
- 	  if (rtx_equal_for_memref_p (XEXP (x, i), XEXP (y, i)) == 0)
- 	    return 0;
- 	  break;
- 
- 	case 'S':
- 	case 's':
- 	  if (strcmp (XSTR (x, i), XSTR (y, i)))
- 	    return 0;
- 	  break;
- 
- 	case 'u':
- 	  /* These are just backpointers, so they don't matter.  */
- 	  break;
- 
- 	case '0':
- 	  break;
- 
- 	  /* It is believed that rtx's at this level will never
- 	     contain anything but integers and other rtx's,
- 	     except for within LABEL_REFs and SYMBOL_REFs.  */
- 	default:
- 	  abort ();
- 	}
-     }
-   return 1;
- }
- 
- /* Given an rtx X, find a SYMBOL_REF or LABEL_REF within
-    X and return it, or return 0 if none found.  */
- 
- static rtx
- find_symbolic_term (x)
-      rtx x;
- {
-   register int i;
-   register enum rtx_code code;
-   register char *fmt;
- 
-   code = GET_CODE (x);
-   if (code == SYMBOL_REF || code == LABEL_REF)
-     return x;
-   if (GET_RTX_CLASS (code) == 'o')
-     return 0;
- 
-   fmt = GET_RTX_FORMAT (code);
-   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-     {
-       rtx t;
- 
-       if (fmt[i] == 'e')
- 	{
- 	  t = find_symbolic_term (XEXP (x, i));
- 	  if (t != 0)
- 	    return t;
- 	}
-       else if (fmt[i] == 'E')
- 	break;
-     }
-   return 0;
- }
- 
- /* Return nonzero if X and Y (memory addresses) could reference the
-    same location in memory.  C is an offset accumulator.  When
-    C is nonzero, we are testing aliases between X and Y + C.
-    XSIZE is the size in bytes of the X reference,
-    similarly YSIZE is the size in bytes for Y.
- 
-    If XSIZE or YSIZE is zero, we do not know the amount of memory being
-    referenced (the reference was BLKmode), so make the most pessimistic
-    assumptions.
- 
-    We recognize the following cases of non-conflicting memory:
- 
- 	(1) addresses involving the frame pointer cannot conflict
- 	    with addresses involving static variables.
- 	(2) static variables with different addresses cannot conflict.
- 
-    Nice to notice that varying addresses cannot conflict with fp if no
-    local variables had their addresses taken, but that's too hard now.  */
- 
- /* ??? In Fortran, references to a array parameter can never conflict with
-    another array parameter.  */
- 
- static int
- memrefs_conflict_p (xsize, x, ysize, y, c)
-      rtx x, y;
-      int xsize, ysize;
-      HOST_WIDE_INT c;
- {
-   if (GET_CODE (x) == HIGH)
-     x = XEXP (x, 0);
-   else if (GET_CODE (x) == LO_SUM)
-     x = XEXP (x, 1);
-   else
-     x = canon_rtx (x);
-   if (GET_CODE (y) == HIGH)
-     y = XEXP (y, 0);
-   else if (GET_CODE (y) == LO_SUM)
-     y = XEXP (y, 1);
-   else
-     y = canon_rtx (y);
- 
-   if (rtx_equal_for_memref_p (x, y))
-     return (xsize == 0 || ysize == 0 ||
- 	    (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
- 
-   if (y == frame_pointer_rtx || y == hard_frame_pointer_rtx
-       || y == stack_pointer_rtx)
-     {
-       rtx t = y;
-       int tsize = ysize;
-       y = x; ysize = xsize;
-       x = t; xsize = tsize;
-     }
- 
-   if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
-       || x == stack_pointer_rtx)
-     {
-       rtx y1;
- 
-       if (CONSTANT_P (y))
- 	return 0;
- 
-       if (GET_CODE (y) == PLUS
- 	  && canon_rtx (XEXP (y, 0)) == x
- 	  && (y1 = canon_rtx (XEXP (y, 1)))
- 	  && GET_CODE (y1) == CONST_INT)
- 	{
- 	  c += INTVAL (y1);
- 	  return (xsize == 0 || ysize == 0
- 		  || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
- 	}
- 
-       if (GET_CODE (y) == PLUS
- 	  && (y1 = canon_rtx (XEXP (y, 0)))
- 	  && CONSTANT_P (y1))
- 	return 0;
- 
-       return 1;
-     }
- 
-   if (GET_CODE (x) == PLUS)
-     {
-       /* The fact that X is canonicalized means that this
- 	 PLUS rtx is canonicalized.  */
-       rtx x0 = XEXP (x, 0);
-       rtx x1 = XEXP (x, 1);
- 
-       if (GET_CODE (y) == PLUS)
- 	{
- 	  /* The fact that Y is canonicalized means that this
- 	     PLUS rtx is canonicalized.  */
- 	  rtx y0 = XEXP (y, 0);
- 	  rtx y1 = XEXP (y, 1);
- 
- 	  if (rtx_equal_for_memref_p (x1, y1))
- 	    return memrefs_conflict_p (xsize, x0, ysize, y0, c);
- 	  if (rtx_equal_for_memref_p (x0, y0))
- 	    return memrefs_conflict_p (xsize, x1, ysize, y1, c);
- 	  if (GET_CODE (x1) == CONST_INT)
- 	    if (GET_CODE (y1) == CONST_INT)
- 	      return memrefs_conflict_p (xsize, x0, ysize, y0,
- 					 c - INTVAL (x1) + INTVAL (y1));
- 	    else
- 	      return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
- 	  else if (GET_CODE (y1) == CONST_INT)
- 	    return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
- 
- 	  /* Handle case where we cannot understand iteration operators,
- 	     but we notice that the base addresses are distinct objects.  */
- 	  x = find_symbolic_term (x);
- 	  if (x == 0)
- 	    return 1;
- 	  y = find_symbolic_term (y);
- 	  if (y == 0)
- 	    return 1;
- 	  return rtx_equal_for_memref_p (x, y);
- 	}
-       else if (GET_CODE (x1) == CONST_INT)
- 	return memrefs_conflict_p (xsize, x0, ysize, y, c - INTVAL (x1));
-     }
-   else if (GET_CODE (y) == PLUS)
-     {
-       /* The fact that Y is canonicalized means that this
- 	 PLUS rtx is canonicalized.  */
-       rtx y0 = XEXP (y, 0);
-       rtx y1 = XEXP (y, 1);
- 
-       if (GET_CODE (y1) == CONST_INT)
- 	return memrefs_conflict_p (xsize, x, ysize, y0, c + INTVAL (y1));
-       else
- 	return 1;
-     }
- 
-   if (GET_CODE (x) == GET_CODE (y))
-     switch (GET_CODE (x))
-       {
-       case MULT:
- 	{
- 	  /* Handle cases where we expect the second operands to be the
- 	     same, and check only whether the first operand would conflict
- 	     or not.  */
- 	  rtx x0, y0;
- 	  rtx x1 = canon_rtx (XEXP (x, 1));
- 	  rtx y1 = canon_rtx (XEXP (y, 1));
- 	  if (! rtx_equal_for_memref_p (x1, y1))
- 	    return 1;
- 	  x0 = canon_rtx (XEXP (x, 0));
- 	  y0 = canon_rtx (XEXP (y, 0));
- 	  if (rtx_equal_for_memref_p (x0, y0))
- 	    return (xsize == 0 || ysize == 0
- 		    || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
- 
- 	  /* Can't properly adjust our sizes.  */
- 	  if (GET_CODE (x1) != CONST_INT)
- 	    return 1;
- 	  xsize /= INTVAL (x1);
- 	  ysize /= INTVAL (x1);
- 	  c /= INTVAL (x1);
- 	  return memrefs_conflict_p (xsize, x0, ysize, y0, c);
- 	}
-       }
- 
-   if (CONSTANT_P (x))
-     {
-       if (GET_CODE (x) == CONST_INT && GET_CODE (y) == CONST_INT)
- 	{
- 	  c += (INTVAL (y) - INTVAL (x));
- 	  return (xsize == 0 || ysize == 0
- 		  || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
- 	}
- 
-       if (GET_CODE (x) == CONST)
- 	{
- 	  if (GET_CODE (y) == CONST)
- 	    return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
- 				       ysize, canon_rtx (XEXP (y, 0)), c);
- 	  else
- 	    return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)),
- 				       ysize, y, c);
- 	}
-       if (GET_CODE (y) == CONST)
- 	return memrefs_conflict_p (xsize, x, ysize,
- 				   canon_rtx (XEXP (y, 0)), c);
- 
-       if (CONSTANT_P (y))
- 	return (rtx_equal_for_memref_p (x, y)
- 		&& (xsize == 0 || ysize == 0
- 		    || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0)));
- 
-       return 1;
-     }
-   return 1;
- }
- 
- /* Functions to compute memory dependencies.
- 
-    Since we process the insns in execution order, we can build tables
-    to keep track of what registers are fixed (and not aliased), what registers
-    are varying in known ways, and what registers are varying in unknown
-    ways.
- 
-    If both memory references are volatile, then there must always be a
-    dependence between the two references, since their order can not be
-    changed.  A volatile and non-volatile reference can be interchanged
-    though. 
- 
-    A MEM_IN_STRUCT reference at a non-QImode varying address can never
-    conflict with a non-MEM_IN_STRUCT reference at a fixed address.   We must
-    allow QImode aliasing because the ANSI C standard allows character
-    pointers to alias anything.  We are assuming that characters are
-    always QImode here.  */
- 
- /* Read dependence: X is read after read in MEM takes place.  There can
-    only be a dependence here if both reads are volatile.  */
- 
- int
- read_dependence (mem, x)
-      rtx mem;
-      rtx x;
- {
-   return MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem);
- }
- 
- /* True dependence: X is read after store in MEM takes place.  */
- 
- int
- true_dependence (mem, x)
-      rtx mem;
-      rtx x;
- {
-   /* If X is an unchanging read, then it can't possibly conflict with any
-      non-unchanging store.  It may conflict with an unchanging write though,
-      because there may be a single store to this address to initialize it.
-      Just fall through to the code below to resolve the case where we have
-      both an unchanging read and an unchanging write.  This won't handle all
-      cases optimally, but the possible performance loss should be
-      negligible.  */
-   if (RTX_UNCHANGING_P (x) && ! RTX_UNCHANGING_P (mem))
-     return 0;
- 
-   return ((MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
- 	  || (memrefs_conflict_p (SIZE_FOR_MODE (mem), XEXP (mem, 0),
- 				  SIZE_FOR_MODE (x), XEXP (x, 0), 0)
- 	      && ! (MEM_IN_STRUCT_P (mem) && rtx_addr_varies_p (mem)
- 		    && GET_MODE (mem) != QImode
- 		    && ! MEM_IN_STRUCT_P (x) && ! rtx_addr_varies_p (x))
- 	      && ! (MEM_IN_STRUCT_P (x) && rtx_addr_varies_p (x)
- 		    && GET_MODE (x) != QImode
- 		    && ! MEM_IN_STRUCT_P (mem) && ! rtx_addr_varies_p (mem))));
- }
- 
- /* Anti dependence: X is written after read in MEM takes place.  */
- 
- int
- anti_dependence (mem, x)
-      rtx mem;
-      rtx x;
- {
-   /* If MEM is an unchanging read, then it can't possibly conflict with
-      the store to X, because there is at most one store to MEM, and it must
-      have occurred somewhere before MEM.  */
-   if (RTX_UNCHANGING_P (mem))
-     return 0;
- 
-   return ((MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
- 	  || (memrefs_conflict_p (SIZE_FOR_MODE (mem), XEXP (mem, 0),
- 				  SIZE_FOR_MODE (x), XEXP (x, 0), 0)
- 	      && ! (MEM_IN_STRUCT_P (mem) && rtx_addr_varies_p (mem)
- 		    && GET_MODE (mem) != QImode
- 		    && ! MEM_IN_STRUCT_P (x) && ! rtx_addr_varies_p (x))
- 	      && ! (MEM_IN_STRUCT_P (x) && rtx_addr_varies_p (x)
- 		    && GET_MODE (x) != QImode
- 		    && ! MEM_IN_STRUCT_P (mem) && ! rtx_addr_varies_p (mem))));
- }
- 
- /* Output dependence: X is written after store in MEM takes place.  */
- 
- int
- output_dependence (mem, x)
-      rtx mem;
-      rtx x;
- {
-   return ((MEM_VOLATILE_P (x) && MEM_VOLATILE_P (mem))
- 	  || (memrefs_conflict_p (SIZE_FOR_MODE (mem), XEXP (mem, 0),
- 				  SIZE_FOR_MODE (x), XEXP (x, 0), 0)
- 	      && ! (MEM_IN_STRUCT_P (mem) && rtx_addr_varies_p (mem)
- 		    && GET_MODE (mem) != QImode
- 		    && ! MEM_IN_STRUCT_P (x) && ! rtx_addr_varies_p (x))
- 	      && ! (MEM_IN_STRUCT_P (x) && rtx_addr_varies_p (x)
- 		    && GET_MODE (x) != QImode
- 		    && ! MEM_IN_STRUCT_P (mem) && ! rtx_addr_varies_p (mem))));
- }
- 
  /* Helper functions for instruction scheduling.  */
  
--- 345,348 ----
*************** add_insn_mem_dependence (insn_list, mem_
*** 1609,1621 ****
  
  /* Make a dependency between every memory reference on the pending lists
!    and INSN, thus flushing the pending lists.  */
  
  static void
! flush_pending_lists (insn)
       rtx insn;
  {
    rtx link;
  
!   while (pending_read_insns)
      {
        add_dependence (insn, XEXP (pending_read_insns, 0), REG_DEP_ANTI);
--- 1072,1086 ----
  
  /* Make a dependency between every memory reference on the pending lists
!    and INSN, thus flushing the pending lists.  If ONLY_WRITE, don't flush
!    the read list.  */
  
  static void
! flush_pending_lists (insn, only_write)
       rtx insn;
+      int only_write;
  {
    rtx link;
  
!   while (pending_read_insns && ! only_write)
      {
        add_dependence (insn, XEXP (pending_read_insns, 0), REG_DEP_ANTI);
*************** sched_analyze_1 (x, insn)
*** 1746,1750 ****
  	     this flush occurs 8 times for sparc, and 10 times for m88k using
  	     the number 32.  */
! 	  flush_pending_lists (insn);
  	}
        else
--- 1211,1215 ----
  	     this flush occurs 8 times for sparc, and 10 times for m88k using
  	     the number 32.  */
! 	  flush_pending_lists (insn, 0);
  	}
        else
*************** sched_analyze_2 (x, insn)
*** 1922,1926 ****
  	    /* If a dependency already exists, don't create a new one.  */
  	    if (! find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
! 	      if (true_dependence (XEXP (pending_mem, 0), x))
  		add_dependence (insn, XEXP (pending, 0), 0);
  
--- 1387,1392 ----
  	    /* If a dependency already exists, don't create a new one.  */
  	    if (! find_insn_list (XEXP (pending, 0), LOG_LINKS (insn)))
! 	      if (true_dependence (XEXP (pending_mem, 0), VOIDmode,
! 				   x, rtx_varies_p))
  		add_dependence (insn, XEXP (pending, 0), 0);
  
*************** sched_analyze_2 (x, insn)
*** 1968,1972 ****
  	    reg_pending_sets_all = 1;
  
! 	    flush_pending_lists (insn);
  	  }
  
--- 1434,1438 ----
  	    reg_pending_sets_all = 1;
  
! 	    flush_pending_lists (insn, 0);
  	  }
  
*************** sched_analyze_insn (x, insn, loop_notes)
*** 2021,2025 ****
    register RTX_CODE code = GET_CODE (x);
    rtx link;
!   int maxreg = max_reg_num ();
    int i;
  
--- 1487,1491 ----
    register RTX_CODE code = GET_CODE (x);
    rtx link;
!   int maxreg = reg_last_uses_size;
    int i;
  
*************** sched_analyze_insn (x, insn, loop_notes)
*** 2058,2062 ****
    if (loop_notes)
      {
!       int max_reg = max_reg_num ();
        rtx link;
  
--- 1524,1528 ----
    if (loop_notes)
      {
!       int max_reg = reg_last_uses_size;
        rtx link;
  
*************** sched_analyze_insn (x, insn, loop_notes)
*** 2072,2076 ****
        reg_pending_sets_all = 1;
  
!       flush_pending_lists (insn);
  
        link = loop_notes;
--- 1538,1542 ----
        reg_pending_sets_all = 1;
  
!       flush_pending_lists (insn, 0);
  
        link = loop_notes;
*************** sched_analyze (head, tail)
*** 2202,2207 ****
  	      && NOTE_LINE_NUMBER (NEXT_INSN (insn)) == NOTE_INSN_SETJMP)
  	    {
! 	      int max_reg = max_reg_num ();
! 	      for (i = 0; i < max_reg; i++)
  		{
  		  for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
--- 1668,1672 ----
  	      && NOTE_LINE_NUMBER (NEXT_INSN (insn)) == NOTE_INSN_SETJMP)
  	    {
! 	      for (i = 0; i < reg_last_uses_size; i++)
  		{
  		  for (u = reg_last_uses[i]; u; u = XEXP (u, 1))
*************** sched_analyze (head, tail)
*** 2247,2259 ****
  	  loop_notes = 0;
  
! 	  /* We don't need to flush memory for a function call which does
! 	     not involve memory.  */
! 	  if (! CONST_CALL_P (insn))
! 	    {
! 	      /* In the absence of interprocedural alias analysis,
! 		 we must flush all pending reads and writes, and
! 		 start new dependencies starting from here.  */
! 	      flush_pending_lists (insn);
! 	    }
  
  	  /* Depend this function call (actually, the user of this
--- 1712,1720 ----
  	  loop_notes = 0;
  
! 	  /* In the absence of interprocedural alias analysis, we must flush
! 	     all pending reads and writes, and start new dependencies starting
! 	     from here.  But only flush writes for constant calls (which may
! 	     be passed a pointer to something we haven't written yet).  */
! 	  flush_pending_lists (insn, CONST_CALL_P (insn));
  
  	  /* Depend this function call (actually, the user of this
*************** sched_analyze (head, tail)
*** 2264,2270 ****
        else if (GET_CODE (insn) == NOTE
  	       && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
! 		   || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END))
! 	loop_notes = gen_rtx (EXPR_LIST, REG_DEAD,
! 			      GEN_INT (NOTE_LINE_NUMBER (insn)), loop_notes);
  
        if (insn == tail)
--- 1725,1736 ----
        else if (GET_CODE (insn) == NOTE
  	       && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
! 		   || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END
! 		   || (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP
! 		       && GET_CODE (PREV_INSN (insn)) != CALL_INSN)))
! 	{
! 	  loop_notes = gen_rtx (EXPR_LIST, REG_DEAD,
! 				GEN_INT (NOTE_LINE_NUMBER (insn)), loop_notes);
! 	  CONST_CALL_P (loop_notes) = CONST_CALL_P (insn);
! 	}
  
        if (insn == tail)
*************** sched_note_set (b, x, death)
*** 2372,2380 ****
  
  #define SCHED_SORT(READY, NEW_READY, OLD_READY) \
!   do { if ((NEW_READY) - (OLD_READY) == 1)				\
! 	 swap_sort (READY, NEW_READY);					\
!        else if ((NEW_READY) - (OLD_READY) > 1)				\
! 	 qsort (READY, NEW_READY, sizeof (rtx), rank_for_schedule); }	\
!   while (0)
  
  /* Returns a positive value if y is preferred; returns a negative value if
--- 1838,1845 ----
  
  #define SCHED_SORT(READY, NEW_READY, OLD_READY) \
!   if ((NEW_READY) - (OLD_READY) == 1)					\
!     swap_sort (READY, NEW_READY);					\
!   else if ((NEW_READY) - (OLD_READY) > 1)				\
!     qsort (READY, NEW_READY, sizeof (rtx), rank_for_schedule); else	\
  
  /* Returns a positive value if y is preferred; returns a negative value if
*************** reemit_notes (insn, last)
*** 3128,3132 ****
  	{
  	  if (INTVAL (XEXP (note, 0)) == NOTE_INSN_SETJMP)
! 	    emit_note_after (INTVAL (XEXP (note, 0)), insn);
  	  else
  	    last = emit_note_before (INTVAL (XEXP (note, 0)), last);
--- 2593,2598 ----
  	{
  	  if (INTVAL (XEXP (note, 0)) == NOTE_INSN_SETJMP)
! 	    CONST_CALL_P (emit_note_after (INTVAL (XEXP (note, 0)), insn))
! 	      = CONST_CALL_P (note);
  	  else
  	    last = emit_note_before (INTVAL (XEXP (note, 0)), last);
*************** schedule_block (b, file)
*** 3174,3178 ****
  	     b, INSN_UID (basic_block_head[b]), INSN_UID (basic_block_end[b]));
  
!   i = max_reg_num ();
    reg_last_uses = (rtx *) alloca (i * sizeof (rtx));
    bzero ((char *) reg_last_uses, i * sizeof (rtx));
--- 2640,2644 ----
  	     b, INSN_UID (basic_block_head[b]), INSN_UID (basic_block_end[b]));
  
!   reg_last_uses_size = i = max_reg_num ();
    reg_last_uses = (rtx *) alloca (i * sizeof (rtx));
    bzero ((char *) reg_last_uses, i * sizeof (rtx));
*************** schedule_block (b, file)
*** 3800,3804 ****
  		     made live again later.  */
  		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
! 		    if (call_used_regs[i] || global_regs[i])
  		      {
  			register int offset = i / REGSET_ELT_BITS;
--- 3266,3271 ----
  		     made live again later.  */
  		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
! 		    if ((call_used_regs[i] && ! fixed_regs[i])
! 			|| global_regs[i])
  		      {
  			register int offset = i / REGSET_ELT_BITS;
*************** schedule_insns (dump_file)
*** 4717,4721 ****
        bcopy ((char *) reg_n_deaths, (char *) sched_reg_n_deaths,
  	     max_regno * sizeof (short));
-       init_alias_analysis ();
      }
    else
--- 4184,4187 ----
*************** schedule_insns (dump_file)
*** 4726,4732 ****
        bb_dead_regs = 0;
        bb_live_regs = 0;
-       if (! flag_schedule_insns)
- 	init_alias_analysis ();
      }
  
    if (write_symbols != NO_DEBUG)
--- 4192,4213 ----
        bb_dead_regs = 0;
        bb_live_regs = 0;
      }
+   init_alias_analysis ();
+ #if 0
+   if (dump_file)
+     {
+       extern rtx *reg_base_value;
+       extern int reg_base_value_size;
+       int i;
+       for (i = 0; i < reg_base_value_size; i++)
+ 	if (reg_base_value[i])
+ 	  {
+ 	    fprintf (dump_file, ";; reg_base_value[%d] = ", i);
+ 	    print_rtl (dump_file, reg_base_value[i]);
+ 	    fputc ('\n', dump_file);
+ 	  }
+     }
+ #endif
+ 
  
    if (write_symbols != NO_DEBUG)
diff -rcp2N gcc-2.7.2.3/sdbout.c gcc-2.7.2.3.f.2/sdbout.c
*** gcc-2.7.2.3/sdbout.c	Thu Jun 15 12:07:11 1995
--- gcc-2.7.2.3.f.2/sdbout.c	Tue Sep  9 07:01:44 1997
*************** plain_type_1 (type, level)
*** 539,543 ****
  	  sdb_dims[sdb_n_dims++]
  	    = (TYPE_DOMAIN (type)
! 	       ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
  	       : 0);
  	return PUSH_DERIVED_LEVEL (DT_ARY, m);
--- 539,546 ----
  	  sdb_dims[sdb_n_dims++]
  	    = (TYPE_DOMAIN (type)
! 	       && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
! 	       && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) == INTEGER_CST
! 	       ? (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
! 		  - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1)
  	       : 0);
  	return PUSH_DERIVED_LEVEL (DT_ARY, m);
diff -rcp2N gcc-2.7.2.3/stmt.c gcc-2.7.2.3.f.2/stmt.c
*** gcc-2.7.2.3/stmt.c	Tue Sep 12 23:01:54 1995
--- gcc-2.7.2.3.f.2/stmt.c	Tue Dec 23 19:52:10 1997
*************** fixup_gotos (thisblock, stack_level, cle
*** 1244,1249 ****
  	      poplevel (1, 0, 0);
  	      end_sequence ();
! 	      f->before_jump
! 		= emit_insns_after (cleanup_insns, f->before_jump);
  
  	      f->cleanup_list_list = TREE_CHAIN (lists);
--- 1244,1250 ----
  	      poplevel (1, 0, 0);
  	      end_sequence ();
! 	      if (cleanup_insns != 0)
! 		f->before_jump
! 		  = emit_insns_after (cleanup_insns, f->before_jump);
  
  	      f->cleanup_list_list = TREE_CHAIN (lists);
*************** expand_expr_stmt (exp)
*** 1721,1725 ****
  
    last_expr_type = TREE_TYPE (exp);
!   if (! flag_syntax_only)
      last_expr_value = expand_expr (exp,
  				   (expr_stmts_for_value
--- 1722,1726 ----
  
    last_expr_type = TREE_TYPE (exp);
!   if (! flag_syntax_only || expr_stmts_for_value)
      last_expr_value = expand_expr (exp,
  				   (expr_stmts_for_value
*************** expand_end_bindings (vars, mark_ends, do
*** 3160,3163 ****
--- 3161,3169 ----
  #endif
  
+ #ifdef HAVE_nonlocal_goto_receiver
+       if (HAVE_nonlocal_goto_receiver)
+ 	emit_insn (gen_nonlocal_goto_receiver ());
+ #endif
+ 
        /* The handler expects the desired label address in the static chain
  	 register.  It tests the address and does an appropriate jump
*************** expand_decl (decl)
*** 3369,3395 ****
  	= promote_mode (type, DECL_MODE (decl), &unsignedp, 0);
  
!       if (TREE_CODE (type) == COMPLEX_TYPE)
! 	{
! 	  rtx realpart, imagpart;
! 	  enum machine_mode partmode = TYPE_MODE (TREE_TYPE (type));
  
! 	  /* For a complex type variable, make a CONCAT of two pseudos
! 	     so that the real and imaginary parts
! 	     can be allocated separately.  */
! 	  realpart = gen_reg_rtx (partmode);
! 	  REG_USERVAR_P (realpart) = 1;
! 	  imagpart = gen_reg_rtx (partmode);
! 	  REG_USERVAR_P (imagpart) = 1;
! 	  DECL_RTL (decl) = gen_rtx (CONCAT, reg_mode, realpart, imagpart);
! 	}
!       else
! 	{
! 	  DECL_RTL (decl) = gen_reg_rtx (reg_mode);
! 	  if (TREE_CODE (type) == POINTER_TYPE)
! 	    mark_reg_pointer (DECL_RTL (decl));
! 	  REG_USERVAR_P (DECL_RTL (decl)) = 1;
! 	}
      }
!   else if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
      {
        /* Variable of fixed size that goes on the stack.  */
--- 3375,3389 ----
  	= promote_mode (type, DECL_MODE (decl), &unsignedp, 0);
  
!       DECL_RTL (decl) = gen_reg_rtx (reg_mode);
!       mark_user_reg (DECL_RTL (decl));
  
!       if (TREE_CODE (type) == POINTER_TYPE)
! 	mark_reg_pointer (DECL_RTL (decl));
      }
!   else if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST
! 	   && ! (flag_stack_check && ! STACK_CHECK_BUILTIN
! 		 && (TREE_INT_CST_HIGH (DECL_SIZE (decl)) != 0
! 		     || (TREE_INT_CST_LOW (DECL_SIZE (decl))
! 			 > STACK_CHECK_MAX_VAR_SIZE * BITS_PER_UNIT))))
      {
        /* Variable of fixed size that goes on the stack.  */
*************** expand_decl (decl)
*** 3462,3468 ****
        free_temp_slots ();
  
!       /* Allocate space on the stack for the variable.  */
        address = allocate_dynamic_stack_space (size, NULL_RTX,
! 					      DECL_ALIGN (decl));
  
        /* Reference the variable indirect through that rtx.  */
--- 3456,3465 ----
        free_temp_slots ();
  
!       /* Allocate space on the stack for the variable.  Note that
! 	 DECL_ALIGN says how the variable is to be aligned and we 
! 	 cannot use it to conclude anything about the alignment of
! 	 the size.  */
        address = allocate_dynamic_stack_space (size, NULL_RTX,
! 					      TYPE_ALIGN (TREE_TYPE (decl)));
  
        /* Reference the variable indirect through that rtx.  */
*************** pushcase (value, converter, label, dupli
*** 4133,4141 ****
  }
  
! /* Like pushcase but this case applies to all values
!    between VALUE1 and VALUE2 (inclusive).
!    The return value is the same as that of pushcase
!    but there is one additional error code:
!    4 means the specified range was empty.  */
  
  int
--- 4130,4141 ----
  }
  
! /* Like pushcase but this case applies to all values between VALUE1 and
!    VALUE2 (inclusive).  If VALUE1 is NULL, the range starts at the lowest
!    value of the index type and ends at VALUE2.  If VALUE2 is NULL, the range
!    starts at VALUE1 and ends at the highest value of the index type.
!    If both are NULL, this case applies to all values.
! 
!    The return value is the same as that of pushcase but there is one
!    additional error code: 4 means the specified range was empty.  */
  
  int
*************** pushcase_range (value1, value2, converte
*** 4187,4209 ****
    case_stack->data.case_stmt.seenlabel = 1;
  
!   /* Convert VALUEs to type in which the comparisons are nominally done.  */
!   if (value1 == 0)  /* Negative infinity. */
!     value1 = TYPE_MIN_VALUE(index_type);
!   value1 = (*converter) (nominal_type, value1);
  
!   if (value2 == 0)  /* Positive infinity. */
!     value2 = TYPE_MAX_VALUE(index_type);
    value2 = (*converter) (nominal_type, value2);
  
    /* Fail if these values are out of range.  */
!   if (! int_fits_type_p (value1, index_type))
      return 3;
  
!   if (! int_fits_type_p (value2, index_type))
      return 3;
- 
-   /* Fail if the range is empty.  */
-   if (tree_int_cst_lt (value2, value1))
-     return 4;
  
    /* If the bounds are equal, turn this into the one-value case.  */
--- 4187,4213 ----
    case_stack->data.case_stmt.seenlabel = 1;
  
!   /* Convert VALUEs to type in which the comparisons are nominally done
!      and replace any unspecified value with the corresponding bound.  */
!   if (value1 == 0)
!     value1 = TYPE_MIN_VALUE (index_type);
!   if (value2 == 0)
!     value2 = TYPE_MAX_VALUE (index_type);
! 
!   /* Fail if the range is empty.  Do this before any conversion since
!      we want to allow out-of-range empty ranges.  */
!   if (tree_int_cst_lt (value2, value1))
!     return 4;
  
!   value1 = (*converter) (nominal_type, value1);
    value2 = (*converter) (nominal_type, value2);
  
    /* Fail if these values are out of range.  */
!   if (TREE_CONSTANT_OVERFLOW (value1)
!       || ! int_fits_type_p (value1, index_type))
      return 3;
  
!   if (TREE_CONSTANT_OVERFLOW (value2)
!       || ! int_fits_type_p (value2, index_type))
      return 3;
  
    /* If the bounds are equal, turn this into the one-value case.  */
diff -rcp2N gcc-2.7.2.3/stor-layout.c gcc-2.7.2.3.f.2/stor-layout.c
*** gcc-2.7.2.3/stor-layout.c	Sat Jun 29 16:26:51 1996
--- gcc-2.7.2.3.f.2/stor-layout.c	Tue Sep  9 07:01:46 1997
*************** layout_decl (decl, known_align)
*** 255,259 ****
        if (maximum_field_alignment != 0)
  	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
!       else if (flag_pack_struct)
  	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
      }
--- 255,259 ----
        if (maximum_field_alignment != 0)
  	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
!       else if (DECL_PACKED (decl))
  	DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
      }
*************** layout_decl (decl, known_align)
*** 261,265 ****
    if (DECL_BIT_FIELD (decl)
        && TYPE_SIZE (type) != 0
!       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
      {
        register enum machine_mode xmode
--- 261,266 ----
    if (DECL_BIT_FIELD (decl)
        && TYPE_SIZE (type) != 0
!       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
!       && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
      {
        register enum machine_mode xmode
*************** layout_decl (decl, known_align)
*** 278,281 ****
--- 279,291 ----
      }
  
+   /* Turn off DECL_BIT_FIELD if we won't need it set.  */
+   if (DECL_BIT_FIELD (decl) && TYPE_MODE (type) == BLKmode
+       && known_align % TYPE_ALIGN (type) == 0
+       && DECL_SIZE (decl) != 0
+       && (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST
+ 	  || (TREE_INT_CST_LOW (DECL_SIZE (decl)) % BITS_PER_UNIT) == 0)
+       && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
+     DECL_BIT_FIELD (decl) = 0;
+ 
    /* Evaluate nonconstant size only once, either now or as soon as safe.  */
    if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
*************** layout_record (rec)
*** 380,384 ****
  	      if (maximum_field_alignment != 0)
  		type_align = MIN (type_align, maximum_field_alignment);
! 	      else if (flag_pack_struct)
  		type_align = MIN (type_align, BITS_PER_UNIT);
  
--- 390,394 ----
  	      if (maximum_field_alignment != 0)
  		type_align = MIN (type_align, maximum_field_alignment);
! 	      else if (TYPE_PACKED (rec))
  		type_align = MIN (type_align, BITS_PER_UNIT);
  
*************** layout_record (rec)
*** 422,428 ****
  	  && DECL_BIT_FIELD_TYPE (field)
  	  && !DECL_PACKED (field)
- 	  /* If #pragma pack is in effect, turn off this feature.  */
  	  && maximum_field_alignment == 0
- 	  && !flag_pack_struct
  	  && !integer_zerop (DECL_SIZE (field)))
  	{
--- 432,436 ----
*************** layout_record (rec)
*** 459,463 ****
  	  if (maximum_field_alignment != 0)
  	    type_align = MIN (type_align, maximum_field_alignment);
! 	  else if (flag_pack_struct)
  	    type_align = MIN (type_align, BITS_PER_UNIT);
  
--- 467,471 ----
  	  if (maximum_field_alignment != 0)
  	    type_align = MIN (type_align, maximum_field_alignment);
! 	  else if (TYPE_PACKED (rec))
  	    type_align = MIN (type_align, BITS_PER_UNIT);
  
*************** layout_record (rec)
*** 500,505 ****
  	  /* Do nothing.  */;
  	else if (TREE_CODE (dsize) == INTEGER_CST
  		 && TREE_INT_CST_HIGH (dsize) == 0
! 		 && TREE_INT_CST_LOW (dsize) + const_size > const_size)
  	  /* Use const_size if there's no overflow.  */
  	  const_size += TREE_INT_CST_LOW (dsize);
--- 508,514 ----
  	  /* Do nothing.  */;
  	else if (TREE_CODE (dsize) == INTEGER_CST
+ 		 && ! TREE_CONSTANT_OVERFLOW (dsize)
  		 && TREE_INT_CST_HIGH (dsize) == 0
! 		 && TREE_INT_CST_LOW (dsize) + const_size >= const_size)
  	  /* Use const_size if there's no overflow.  */
  	  const_size += TREE_INT_CST_LOW (dsize);
*************** get_best_mode (bitsize, bitpos, align, l
*** 1172,1175 ****
--- 1181,1192 ----
    enum machine_mode mode;
    int unit;
+ 
+   if (bitpos < 0)
+     {
+       /* For correct calculations and convenience, bias negative bitpos
+ 	 to become a non-negative value that is [1,bitsize], such that
+ 	 the relative bit offset to a multiple of bitsize is preserved.  */
+       bitpos = bitsize - ((-bitpos) % bitsize);
+     }
  
    /* Find the narrowest integer mode that contains the bit field.  */
diff -rcp2N gcc-2.7.2.3/stupid.c gcc-2.7.2.3.f.2/stupid.c
*** gcc-2.7.2.3/stupid.c	Sun Oct 29 12:45:22 1995
--- gcc-2.7.2.3.f.2/stupid.c	Sun Mar  1 03:40:50 1998
*************** static int *uid_suid;
*** 66,69 ****
--- 66,74 ----
  static int last_call_suid;
  
+ /* Record the suid of the last NOTE_INSN_SETJMP
+    so we can tell whether a pseudo reg crosses any setjmp.  */
+ 
+ static int last_setjmp_suid;
+ 
  /* Element N is suid of insn where life span of pseudo reg N ends.
     Element is  0 if register N has not been seen yet on backward scan.  */
*************** static char *regs_live;
*** 89,92 ****
--- 94,101 ----
  static char *regs_change_size;
  
+ /* Indexed by reg number, nonzero if reg crosses a setjmp.  */
+ 
+ static char *regs_crosses_setjmp;
+ 
  /* Indexed by insn's suid, the set of hard regs live after that insn.  */
  
*************** stupid_life_analysis (f, nregs, file)
*** 121,124 ****
--- 130,135 ----
    int max_uid, max_suid;
  
+   current_function_has_computed_jump = 0;
+ 
    bzero (regs_ever_live, sizeof regs_ever_live);
  
*************** stupid_life_analysis (f, nregs, file)
*** 149,152 ****
--- 160,164 ----
  
    last_call_suid = i + 1;
+   last_setjmp_suid = i + 1;
    max_suid = i + 1;
  
*************** stupid_life_analysis (f, nregs, file)
*** 167,170 ****
--- 179,185 ----
    bzero ((char *) regs_change_size, nregs * sizeof (char));
  
+   regs_crosses_setjmp = (char *) alloca (nregs * sizeof (char));
+   bzero ((char *) regs_crosses_setjmp, nregs * sizeof (char));
+ 
    reg_renumber = (short *) oballoc (nregs * sizeof (short));
    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
*************** stupid_life_analysis (f, nregs, file)
*** 216,219 ****
--- 231,238 ----
  	stupid_mark_refs (PATTERN (insn), insn);
  
+       if (GET_CODE (insn) == NOTE
+ 	  && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
+ 	last_setjmp_suid = INSN_SUID (insn);
+ 
        /* Mark all call-clobbered regs as live after each call insn
  	 so that a pseudo whose life span includes this insn
*************** stupid_life_analysis (f, nregs, file)
*** 237,240 ****
--- 256,263 ----
  	  stupid_mark_refs (CALL_INSN_FUNCTION_USAGE (insn), insn);
  	}
+ #ifdef STACK_REGS
+       if (GET_CODE (insn) == JUMP_INSN && computed_jump_p (insn))
+ 	current_function_has_computed_jump = 1;
+ #endif
      }
  
*************** stupid_life_analysis (f, nregs, file)
*** 254,259 ****
        register int r = reg_order[i];
  
!       /* Some regnos disappear from the rtl.  Ignore them to avoid crash.  */
!       if (regno_reg_rtx[r] == 0)
  	continue;
  
--- 277,283 ----
        register int r = reg_order[i];
  
!       /* Some regnos disappear from the rtl.  Ignore them to avoid crash. 
! 	 Also don't allocate registers that cross a setjmp.  */
!       if (regno_reg_rtx[r] == 0 || regs_crosses_setjmp[r])
  	continue;
  
*************** stupid_reg_compare (r1p, r2p)
*** 309,314 ****
     that can hold a value of machine-mode MODE
       (but actually we test only the first of the block for holding MODE)
!    currently free from after insn whose suid is BIRTH
!    through the insn whose suid is DEATH,
     and return the number of the first of them.
     Return -1 if such a block cannot be found.
--- 333,338 ----
     that can hold a value of machine-mode MODE
       (but actually we test only the first of the block for holding MODE)
!    currently free from after insn whose suid is BORN_INSN
!    through the insn whose suid is DEAD_INSN,
     and return the number of the first of them.
     Return -1 if such a block cannot be found.
*************** stupid_find_reg (call_preserved, class, 
*** 338,341 ****
--- 362,372 ----
  #endif
  
+   /* If this register's life is more than 5,000 insns, we probably
+      can't allocate it, so don't waste the time trying.  This avoid
+      quadratic behavior on programs that have regularly-occurring
+      SAVE_EXPRs.  */
+   if (dead_insn > born_insn + 5000)
+     return -1;
+ 
    COPY_HARD_REG_SET (used,
  		     call_preserved ? call_used_reg_set : fixed_reg_set);
*************** stupid_find_reg (call_preserved, class, 
*** 354,357 ****
--- 385,394 ----
      IOR_HARD_REG_SET (used, after_insn_hard_regs[ins]);
  
+ #ifdef STACK_REGS
+   if (current_function_has_computed_jump)
+     for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
+       SET_HARD_REG_BIT (used, i);
+ #endif
+   
    IOR_COMPL_HARD_REG_SET (used, reg_class_contents[(int) class]);
  
*************** stupid_mark_refs (x, insn)
*** 488,491 ****
--- 525,531 ----
  	      if (last_call_suid < reg_where_dead[regno])
  		reg_n_calls_crossed[regno] += 1;
+ 
+ 	      if (last_setjmp_suid < reg_where_dead[regno])
+ 		regs_crosses_setjmp[regno] = 1;
  	    }
  	}
diff -rcp2N gcc-2.7.2.3/texinfo.tex gcc-2.7.2.3.f.2/texinfo.tex
*** gcc-2.7.2.3/texinfo.tex	Sun Nov 26 19:57:26 1995
--- gcc-2.7.2.3.f.2/texinfo.tex	Wed Dec 24 01:36:39 1997
***************
*** 1,5 ****
! %% TeX macros to handle texinfo files
  
! %   Copyright (C) 1985, 86, 88, 90, 91, 92, 93, 1994 Free Software Foundation, Inc.
  
  %This texinfo.tex file is free software; you can redistribute it and/or
--- 1,7 ----
! %% TeX macros to handle Texinfo files.
! %% $Id: texinfo.tex,v 2.220 1997/12/23 16:33:04 karl Exp $
  
! %  Copyright (C) 1985, 86, 88, 90, 91, 92, 93,
! %                94, 95, 96, 97 Free Software Foundation, Inc.
  
  %This texinfo.tex file is free software; you can redistribute it and/or
***************
*** 15,20 ****
  %You should have received a copy of the GNU General Public License
  %along with this texinfo.tex file; see the file COPYING.  If not, write
! %to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
! %USA.
  
  
--- 17,22 ----
  %You should have received a copy of the GNU General Public License
  %along with this texinfo.tex file; see the file COPYING.  If not, write
! %to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
! %Boston, MA 02111-1307, USA.
  
  
***************
*** 35,39 ****
  % This automatically updates the version number based on RCS.
  \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}}
! \deftexinfoversion$Revision: 2.150 $
  \message{Loading texinfo package [Version \texinfoversion]:}
  
--- 37,41 ----
  % This automatically updates the version number based on RCS.
  \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}}
! \deftexinfoversion$Revision: 2.220 $
  \message{Loading texinfo package [Version \texinfoversion]:}
  
***************
*** 46,63 ****
  % Save some parts of plain tex whose names we will redefine.
  
- \let\ptextilde=\~
- \let\ptexlbrace=\{
- \let\ptexrbrace=\}
- \let\ptexdots=\dots
- \let\ptexdot=\.
- \let\ptexstar=\*
- \let\ptexend=\end
- \let\ptexbullet=\bullet
  \let\ptexb=\b
  \let\ptexc=\c
  \let\ptexi=\i
  \let\ptext=\t
- \let\ptexl=\l
- \let\ptexL=\L
  
  % Be sure we're in horizontal mode when doing a tie, since we make space
--- 48,64 ----
  % Save some parts of plain tex whose names we will redefine.
  
  \let\ptexb=\b
+ \let\ptexbullet=\bullet
  \let\ptexc=\c
+ \let\ptexcomma=\,
+ \let\ptexdot=\.
+ \let\ptexdots=\dots
+ \let\ptexend=\end
+ \let\ptexequiv = \equiv
  \let\ptexi=\i
+ \let\ptexlbrace=\{
+ \let\ptexrbrace=\}
+ \let\ptexstar=\*
  \let\ptext=\t
  
  % Be sure we're in horizontal mode when doing a tie, since we make space
***************
*** 70,76 ****
   % if the definition is written into an index file.
   \global\let\tiepenalty = \@M
!  \gdef\tie{\lvvmode\penalty\tiepenalty\ }
  }
! \let\~ = \tie                  % And make it available as @~.
  
  \message{Basics,}
--- 71,77 ----
   % if the definition is written into an index file.
   \global\let\tiepenalty = \@M
!  \gdef\tie{\leavevmode\penalty\tiepenalty\ }
  }
! 
  
  \message{Basics,}
***************
*** 101,110 ****
  \hyphenation{mini-buf-fer mini-buf-fers}
  \hyphenation{eshell}
  
  % Margin to add to right of even pages, to left of odd pages.
! \newdimen \bindingoffset  \bindingoffset=0pt
! \newdimen \normaloffset   \normaloffset=\hoffset
  \newdimen\pagewidth \newdimen\pageheight
- \pagewidth=\hsize \pageheight=\vsize
  
  % Sometimes it is convenient to have everything in the transcript file
--- 102,111 ----
  \hyphenation{mini-buf-fer mini-buf-fers}
  \hyphenation{eshell}
+ \hyphenation{white-space}
  
  % Margin to add to right of even pages, to left of odd pages.
! \newdimen \bindingoffset
! \newdimen \normaloffset
  \newdimen\pagewidth \newdimen\pageheight
  
  % Sometimes it is convenient to have everything in the transcript file
***************
*** 119,131 ****
  }%
  
! %---------------------Begin change-----------------------
  %
! %%%% For @cropmarks command.
! % Dimensions to add cropmarks at corners Added by P. A. MacKay, 12 Nov. 1986
  %
  \newdimen\cornerlong \newdimen\cornerthick
! \newdimen \topandbottommargin
! \newdimen \outerhsize \newdimen \outervsize
! \cornerlong=1pc\cornerthick=.3pt	% These set size of cropmarks
  \outerhsize=7in
  %\outervsize=9.5in
--- 120,136 ----
  }%
  
! % For @cropmarks command.
! % Do @cropmarks to get crop marks.
! % 
! \newif\ifcropmarks
! \let\cropmarks = \cropmarkstrue
  %
! % Dimensions to add cropmarks at corners.
! % Added by P. A. MacKay, 12 Nov. 1986
  %
  \newdimen\cornerlong \newdimen\cornerthick
! \newdimen\topandbottommargin
! \newdimen\outerhsize \newdimen\outervsize
! \cornerlong=1pc\cornerthick=.3pt        % These set size of cropmarks
  \outerhsize=7in
  %\outervsize=9.5in
***************
*** 133,187 ****
  \outervsize=9.25in
  \topandbottommargin=.75in
! %
! %---------------------End change-----------------------
  
  % \onepageout takes a vbox as an argument.  Note that \pagecontents
! % does insertions itself, but you have to call it yourself.
! \chardef\PAGE=255  \output={\onepageout{\pagecontents\PAGE}}
! \def\onepageout#1{\hoffset=\normaloffset
! \ifodd\pageno  \advance\hoffset by \bindingoffset
! \else \advance\hoffset by -\bindingoffset\fi
! {\escapechar=`\\\relax % makes sure backslash is used in output files.
! \shipout\vbox{{\let\hsize=\pagewidth \makeheadline} \pagebody{#1}%
! {\let\hsize=\pagewidth \makefootline}}}%
! \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi}
! 
! %%%% For @cropmarks command %%%%
! 
! % Here is a modification of the main output routine for Near East Publications
! % This provides right-angle cropmarks at all four corners.
! % The contents of the page are centerlined into the cropmarks,
! % and any desired binding offset is added as an \hskip on either
! % site of the centerlined box.  (P. A. MacKay, 12 November, 1986)
! %
! \def\croppageout#1{\hoffset=0pt % make sure this doesn't mess things up
! {\escapechar=`\\\relax % makes sure backslash is used in output files.
! 		 \shipout
! 		 \vbox to \outervsize{\hsize=\outerhsize
!                  \vbox{\line{\ewtop\hfill\ewtop}}
!                  \nointerlineskip
!                  \line{\vbox{\moveleft\cornerthick\nstop}
!                        \hfill
!                        \vbox{\moveright\cornerthick\nstop}}
!                  \vskip \topandbottommargin
!                  \centerline{\ifodd\pageno\hskip\bindingoffset\fi
! 			\vbox{
! 			{\let\hsize=\pagewidth \makeheadline}
! 			\pagebody{#1}
! 			{\let\hsize=\pagewidth \makefootline}}
! 			\ifodd\pageno\else\hskip\bindingoffset\fi}
! 		 \vskip \topandbottommargin plus1fill minus1fill
!                  \boxmaxdepth\cornerthick
!                  \line{\vbox{\moveleft\cornerthick\nsbot}
!                        \hfill
!                        \vbox{\moveright\cornerthick\nsbot}}
!                  \nointerlineskip
!                  \vbox{\line{\ewbot\hfill\ewbot}}
! 	}}
    \advancepageno
!   \ifnum\outputpenalty>-20000 \else\dosupereject\fi}
! %
! % Do @cropmarks to get crop marks
! \def\cropmarks{\let\onepageout=\croppageout }
  
  \newinsert\margin \dimen\margin=\maxdimen
--- 138,217 ----
  \outervsize=9.25in
  \topandbottommargin=.75in
! 
! % Main output routine.
! \chardef\PAGE = 255
! \output = {\onepageout{\pagecontents\PAGE}}
! 
! \newbox\headlinebox
! \newbox\footlinebox
  
  % \onepageout takes a vbox as an argument.  Note that \pagecontents
! % does insertions, but you have to call it yourself.
! \def\onepageout#1{%
!   \ifcropmarks \hoffset=0pt \else \hoffset=\normaloffset \fi
!   %
!   \ifodd\pageno  \advance\hoffset by \bindingoffset
!   \else \advance\hoffset by -\bindingoffset\fi
!   %
!   % Do this outside of the \shipout so @code etc. will be expanded in
!   % the headline as they should be, not taken literally (outputting ''code).
!   \setbox\headlinebox = \vbox{\let\hsize=\pagewidth \makeheadline}%
!   \setbox\footlinebox = \vbox{\let\hsize=\pagewidth \makefootline}%
!   %
!   {%
!     % Have to do this stuff outside the \shipout because we want it to
!     % take effect in \write's, yet the group defined by the \vbox ends
!     % before the \shipout runs.
!     %
!     \escapechar = `\\     % use backslash in output files.
!     \indexdummies         % don't expand commands in the output.
!     \normalturnoffactive  % \ in index entries must not stay \, e.g., if
!                    % the page break happens to be in the middle of an example.
!     \shipout\vbox{%
!       \ifcropmarks \vbox to \outervsize\bgroup
!         \hsize = \outerhsize
!         \line{\ewtop\hfil\ewtop}%
!         \nointerlineskip
!         \line{%
!           \vbox{\moveleft\cornerthick\nstop}%
!           \hfill
!           \vbox{\moveright\cornerthick\nstop}%
!         }%
!         \vskip\topandbottommargin
!         \line\bgroup
!           \hfil % center the page within the outer (page) hsize.
!           \ifodd\pageno\hskip\bindingoffset\fi
!           \vbox\bgroup
!       \fi
!       %
!       \unvbox\headlinebox
!       \pagebody{#1}%
!       \ifdim\ht\footlinebox > 0pt
!         % Only leave this space if the footline is nonempty.
!         % (We lessened \vsize for it in \oddfootingxxx.)
!         % The \baselineskip=24pt in plain's \makefootline has no effect.
!         \vskip 2\baselineskip
!         \unvbox\footlinebox
!       \fi
!       %
!       \ifcropmarks
!           \egroup % end of \vbox\bgroup
!         \hfil\egroup % end of (centering) \line\bgroup
!         \vskip\topandbottommargin plus1fill minus1fill
!         \boxmaxdepth = \cornerthick
!         \line{%
!           \vbox{\moveleft\cornerthick\nsbot}%
!           \hfill
!           \vbox{\moveright\cornerthick\nsbot}%
!         }%
!         \nointerlineskip
!         \line{\ewbot\hfil\ewbot}%
!       \egroup % \vbox from first cropmarks clause
!       \fi
!     }% end of \shipout\vbox
!   }% end of group with \turnoffactive
    \advancepageno
!   \ifnum\outputpenalty>-20000 \else\dosupereject\fi
! }
  
  \newinsert\margin \dimen\margin=\maxdimen
***************
*** 198,202 ****
  }
  
- %
  % Here are the rules for the cropmarks.  Note that they are
  % offset so that the space between them is truly \outerhsize or \outervsize
--- 228,231 ----
***************
*** 366,374 ****
  
  % Used to generate quoted braces.
- 
  \def\mylbrace {{\tt \char '173}}
  \def\myrbrace {{\tt \char '175}}
  \let\{=\mylbrace
  \let\}=\myrbrace
  
  % @: forces normal size whitespace following.
--- 395,435 ----
  
  % Used to generate quoted braces.
  \def\mylbrace {{\tt \char '173}}
  \def\myrbrace {{\tt \char '175}}
  \let\{=\mylbrace
  \let\}=\myrbrace
+ \begingroup
+   % Definitions to produce actual \{ & \} command in an index.
+   \catcode`\{ = 12 \catcode`\} = 12
+   \catcode`\[ = 1 \catcode`\] = 2
+   \catcode`\@ = 0 \catcode`\\ = 12
+   @gdef@lbracecmd[\{]%
+   @gdef@rbracecmd[\}]%
+ @endgroup
+ 
+ % Accents: @, @dotaccent @ringaccent @ubaraccent @udotaccent
+ % Others are defined by plain TeX: @` @' @" @^ @~ @= @v @H.
+ \let\, = \c
+ \let\dotaccent = \.
+ \def\ringaccent#1{{\accent23 #1}}
+ \let\tieaccent = \t
+ \let\ubaraccent = \b
+ \let\udotaccent = \d
+ 
+ % Other special characters: @questiondown @exclamdown
+ % Plain TeX defines: @AA @AE @O @OE @L (and lowercase versions) @ss.
+ \def\questiondown{?`}
+ \def\exclamdown{!`}
+ 
+ % Dotless i and dotless j, used for accents.
+ \def\imacro{i}
+ \def\jmacro{j}
+ \def\dotless#1{%
+   \def\temp{#1}%
+   \ifx\temp\imacro \ptexi
+   \else\ifx\temp\jmacro \j
+   \else \errmessage{@dotless can be used only with i or j}%
+   \fi\fi
+ }
  
  % @: forces normal size whitespace following.
*************** where each line of input produces a line
*** 537,551 ****
  \leftline{\hskip\leftskip{\rm#1}}}}
  
  %\hbox{{\rm#1}}\hfil\break}}
  
  % @include file    insert text of that file as input.
! 
! \def\include{\parsearg\includezzz}
! %Use \input\thisfile to avoid blank after \input, which may be an active
! %char (in which case the blank would become the \input argument).
! %The grouping keeps the value of \thisfile correct even when @include
! %is nested.
! \def\includezzz #1{\begingroup
! \def\thisfile{#1}\input\thisfile
  \endgroup}
  
--- 598,629 ----
  \leftline{\hskip\leftskip{\rm#1}}}}
  
+ % @inmargin{TEXT} puts TEXT in the margin next to the current paragraph.
+ 
+ \def\inmargin#1{%
+ \strut\vadjust{\nobreak\kern-\strutdepth
+   \vtop to \strutdepth{\baselineskip\strutdepth\vss
+   \llap{\rightskip=\inmarginspacing \vbox{\noindent #1}}\null}}}
+ \newskip\inmarginspacing \inmarginspacing=1cm
+ \def\strutdepth{\dp\strutbox}
+ 
  %\hbox{{\rm#1}}\hfil\break}}
  
  % @include file    insert text of that file as input.
! % Allow normal characters that  we make active in the argument (a file name).
! \def\include{\begingroup
!   \catcode`\\=12
!   \catcode`~=12
!   \catcode`^=12
!   \catcode`_=12
!   \catcode`|=12
!   \catcode`<=12
!   \catcode`>=12
!   \catcode`+=12
!   \parsearg\includezzz}
! % Restore active chars for included file.
! \def\includezzz#1{\endgroup\begingroup
!   % Read the included file in a group so nested @include's work.
!   \def\thisfile{#1}%
!   \input\thisfile
  \endgroup}
  
*************** where each line of input produces a line
*** 562,566 ****
  
  \def\sp{\parsearg\spxxx}
! \def\spxxx #1{\par \vskip #1\baselineskip}
  
  % @comment ...line which is ignored...
--- 640,644 ----
  
  \def\sp{\parsearg\spxxx}
! \def\spxxx #1{\vskip #1\baselineskip}
  
  % @comment ...line which is ignored...
*************** where each line of input produces a line
*** 575,578 ****
--- 653,659 ----
  \let\c=\comment
  
+ % @paragraphindent  is defined for the Info formatting commands only.
+ \let\paragraphindent=\comment
+ 
  % Prevent errors for section commands.
  % Used in @ignore and in failing conditionals.
*************** where each line of input produces a line
*** 609,612 ****
--- 690,694 ----
  %
  \def\ignoremorecommands{%
+   \let\defcodeindex = \relax
    \let\defcv = \relax
    \let\deffn = \relax
*************** where each line of input produces a line
*** 632,635 ****
--- 714,726 ----
    \let\pxref = \relax
    \let\settitle = \relax
+   \let\setchapternewpage = \relax
+   \let\setchapterstyle = \relax
+   \let\everyheading = \relax
+   \let\evenheading = \relax
+   \let\oddheading = \relax
+   \let\everyfooting = \relax
+   \let\evenfooting = \relax
+   \let\oddfooting = \relax
+   \let\headings = \relax
    \let\include = \relax
    \let\lowersections = \relax
*************** where each line of input produces a line
*** 640,644 ****
    \let\clear = \relax
    \let\item = \relax
-   \let\message = \relax
  }
  
--- 731,734 ----
*************** where each line of input produces a line
*** 647,658 ****
  \def\ignore{\doignore{ignore}}
  
! % Also ignore @ifinfo, @ifhtml, @html, @menu, and @direntry text.
  %
  \def\ifinfo{\doignore{ifinfo}}
  \def\ifhtml{\doignore{ifhtml}}
  \def\html{\doignore{html}}
  \def\menu{\doignore{menu}}
  \def\direntry{\doignore{direntry}}
  
  % Ignore text until a line `@end #1'.
  %
--- 737,759 ----
  \def\ignore{\doignore{ignore}}
  
! % Ignore @ifinfo, @ifhtml, @ifnottex, @html, @menu, and @direntry text.
  %
  \def\ifinfo{\doignore{ifinfo}}
  \def\ifhtml{\doignore{ifhtml}}
+ \def\ifnottex{\doignore{ifnottex}}
  \def\html{\doignore{html}}
  \def\menu{\doignore{menu}}
  \def\direntry{\doignore{direntry}}
  
+ % Also ignore @macro ... @end macro.  The user must run texi2dvi,
+ % which runs makeinfo to do macro expansion.  Ignore @unmacro, too.
+ \def\macro{\doignore{macro}}
+ \let\unmacro = \comment
+ 
+ 
+ % @dircategory CATEGORY  -- specify a category of the dir file
+ % which this file should belong to.  Ignore this in TeX.
+ \let\dircategory = \comment
+ 
  % Ignore text until a line `@end #1'.
  %
*************** where each line of input produces a line
*** 667,670 ****
--- 768,775 ----
    \catcode32 = 10
    %
+   % Ignore braces, too, so mismatched braces don't cause trouble.
+   \catcode`\{ = 9
+   \catcode`\} = 9
+   %
    % And now expand that command.
    \doignoretext
*************** where each line of input produces a line
*** 686,694 ****
      \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.}
      \immediate\write16{  Then upgrade your TeX installation if you can.}
      \immediate\write16{If you are stuck with version 3.0, run the}
      \immediate\write16{  script ``tex3patch'' from the Texinfo distribution}
      \immediate\write16{  to use a workaround.}
      \immediate\write16{}
!     \warnedobstrue
      \fi
  }
--- 791,800 ----
      \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.}
      \immediate\write16{  Then upgrade your TeX installation if you can.}
+     \immediate\write16{  (See ftp://ftp.gnu.ai.mit.edu/pub/gnu/TeX.README.)}
      \immediate\write16{If you are stuck with version 3.0, run the}
      \immediate\write16{  script ``tex3patch'' from the Texinfo distribution}
      \immediate\write16{  to use a workaround.}
      \immediate\write16{}
!     \global\warnedobstrue
      \fi
  }
*************** where each line of input produces a line
*** 757,761 ****
      %
      % Do not execute instructions in @tex
!     \def\tex{\doignore{tex}}
  }
  
--- 863,867 ----
      %
      % Do not execute instructions in @tex
!     \def\tex{\doignore{tex}}%
  }
  
*************** where each line of input produces a line
*** 766,772 ****
  % empty), we can't just use \parsearg; we have to insert a space of our
  % own to delimit the rest of the line, and then take it out again if we
! % didn't need it.
  %
! \def\set{\parsearg\setxxx}
  \def\setxxx#1{\setyyy#1 \endsetyyy}
  \def\setyyy#1 #2\endsetyyy{%
--- 872,881 ----
  % empty), we can't just use \parsearg; we have to insert a space of our
  % own to delimit the rest of the line, and then take it out again if we
! % didn't need it.  Make sure the catcode of space is correct to avoid
! % losing inside @example, for instance.
  %
! \def\set{\begingroup\catcode` =10
!   \catcode`\-=12 \catcode`\_=12 % Allow - and _ in VAR.
!   \parsearg\setxxx}
  \def\setxxx#1{\setyyy#1 \endsetyyy}
  \def\setyyy#1 #2\endsetyyy{%
*************** where each line of input produces a line
*** 775,778 ****
--- 884,888 ----
    \else \setzzz{#1}#2\endsetzzz % Remove the trailing space \setxxx inserted.
    \fi
+   \endgroup
  }
  % Can't use \xdef to pre-expand #2 and save some time, since \temp or
*************** where each line of input produces a line
*** 788,795 ****
  % @value{foo} gets the text saved in variable foo.
  %
! \def\value#1{\expandafter
! 		\ifx\csname SET#1\endcsname\relax
! 			{\{No value for ``#1''\}}
! 		\else \csname SET#1\endcsname \fi}
  
  % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined
--- 898,911 ----
  % @value{foo} gets the text saved in variable foo.
  %
! \def\value{\begingroup
!   \catcode`\-=12 \catcode`\_=12 % Allow - and _ in VAR.
!   \valuexxx}
! \def\valuexxx#1{%
!   \expandafter\ifx\csname SET#1\endcsname\relax
!     {\{No value for ``#1''\}}%
!   \else
!     \csname SET#1\endcsname
!   \fi
! \endgroup}
  
  % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined
*************** where each line of input produces a line
*** 823,831 ****
  \defineunmatchedend{ifclear}
  
! % @iftex always succeeds; we read the text following, through @end
! % iftex).  But `@end iftex' should be valid only after an @iftex.
  %
  \def\iftex{\conditionalsucceed{iftex}}
  \defineunmatchedend{iftex}
  
  % We can't just want to start a group at @iftex (for example) and end it
--- 939,952 ----
  \defineunmatchedend{ifclear}
  
! % @iftex, @ifnothtml, @ifnotinfo always succeed; we read the text
! % following, through the first @end iftex (etc.).  Make `@end iftex'
! % (etc.) valid only after an @iftex.
  %
  \def\iftex{\conditionalsucceed{iftex}}
+ \def\ifnothtml{\conditionalsucceed{ifnothtml}}
+ \def\ifnotinfo{\conditionalsucceed{ifnotinfo}}
  \defineunmatchedend{iftex}
+ \defineunmatchedend{ifnothtml}
+ \defineunmatchedend{ifnotinfo}
  
  % We can't just want to start a group at @iftex (for example) and end it
*************** where each line of input produces a line
*** 891,894 ****
--- 1012,1016 ----
  \global\let\lastnode=\relax}
  
+ % @refill is a no-op.
  \let\refill=\relax
  
*************** where each line of input produces a line
*** 902,913 ****
     \fixbackslash  % Turn off hack to swallow `\input texinfo'.
     \global\let\setfilename=\comment % Ignore extra @setfilename cmds.
     \comment % Ignore the actual filename.
  }
  
  \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend}
  
! \def\inforef #1{\inforefzzz #1,,,,**}
! \def\inforefzzz #1,#2,#3,#4**{\putwordSee{} \putwordInfo{} \putwordfile{} \file{\ignorespaces #3{}},
!   node \samp{\ignorespaces#1{}}}
  
  \message{fonts,}
--- 1024,1057 ----
     \fixbackslash  % Turn off hack to swallow `\input texinfo'.
     \global\let\setfilename=\comment % Ignore extra @setfilename cmds.
+    %
+    % If texinfo.cnf is present on the system, read it.
+    % Useful for site-wide @afourpaper, etc.
+    % Just to be on the safe side, close the input stream before the \input.
+    \openin 1 texinfo.cnf
+    \ifeof1 \let\temp=\relax \else \def\temp{\input texinfo.cnf }\fi
+    \closein1
+    \temp
+    %
     \comment % Ignore the actual filename.
  }
  
+ % @bye.
  \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend}
  
! % \def\macro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\macroxxx}
! % \def\macroxxx#1#2 \end macro{%
! % \expandafter\gdef\macrotemp#1{#2}%
! % \endgroup}
! 
! %\def\linemacro#1{\begingroup\ignoresections\catcode`\#=6\def\macrotemp{#1}\parsearg\linemacroxxx}
! %\def\linemacroxxx#1#2 \end linemacro{%
! %\let\parsearg=\relax
! %\edef\macrotempx{\csname M\butfirst\expandafter\string\macrotemp\endcsname}%
! %\expandafter\xdef\macrotemp{\parsearg\macrotempx}%
! %\expandafter\gdef\macrotempx#1{#2}%
! %\endgroup}
! 
! %\def\butfirst#1{}
! 
  
  \message{fonts,}
*************** where each line of input produces a line
*** 921,930 ****
  \let\li = \sf % Sometimes we call it \li, not \sf.
  
! %% Try out Computer Modern fonts at \magstephalf
! \let\mainmagstep=\magstephalf
  
  % Set the font macro #1 to the font named #2, adding on the
  % specified font prefix (normally `cm').
! \def\setfont#1#2{\font#1=\fontprefix#2}
  
  % Use cm as the default font prefix.
--- 1065,1079 ----
  \let\li = \sf % Sometimes we call it \li, not \sf.
  
! % We don't need math for this one.
! \def\ttsl{\tenttsl}
! 
! % Use Computer Modern fonts at \magstephalf (11pt).
! \newcount\mainmagstep
! \mainmagstep=\magstephalf
  
  % Set the font macro #1 to the font named #2, adding on the
  % specified font prefix (normally `cm').
! % #3 is the font's design size, #4 is a scale factor
! \def\setfont#1#2#3#4{\font#1=\fontprefix#2#3 scaled #4}
  
  % Use cm as the default font prefix.
*************** where each line of input produces a line
*** 934,1029 ****
  \def\fontprefix{cm}
  \fi
  
  \ifx\bigger\relax
  \let\mainmagstep=\magstep1
! \setfont\textrm{r12}
! \setfont\texttt{tt12}
  \else
! \setfont\textrm{r10 scaled \mainmagstep}
! \setfont\texttt{tt10 scaled \mainmagstep}
  \fi
  % Instead of cmb10, you many want to use cmbx10.
  % cmbx10 is a prettier font on its own, but cmb10
  % looks better when embedded in a line with cmr10.
! \setfont\textbf{b10 scaled \mainmagstep}
! \setfont\textit{ti10 scaled \mainmagstep}
! \setfont\textsl{sl10 scaled \mainmagstep}
! \setfont\textsf{ss10 scaled \mainmagstep}
! \setfont\textsc{csc10 scaled \mainmagstep}
  \font\texti=cmmi10 scaled \mainmagstep
  \font\textsy=cmsy10 scaled \mainmagstep
  
  % A few fonts for @defun, etc.
! \setfont\defbf{bx10 scaled \magstep1} %was 1314
! \setfont\deftt{tt10 scaled \magstep1}
  \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf}
  
! % Fonts for indices and small examples.
  % We actually use the slanted font rather than the italic,
  % because texinfo normally uses the slanted fonts for that.
  % Do not make many font distinctions in general in the index, since they
  % aren't very useful.
! \setfont\ninett{tt9}
! \setfont\indrm{r9}
! \setfont\indit{sl9}
  \let\indsl=\indit
  \let\indtt=\ninett
  \let\indsf=\indrm
  \let\indbf=\indrm
! \setfont\indsc{csc10 at 9pt}
  \font\indi=cmmi9
  \font\indsy=cmsy9
  
! % Fonts for headings
! \setfont\chaprm{bx12 scaled \magstep2}
! \setfont\chapit{ti12 scaled \magstep2}
! \setfont\chapsl{sl12 scaled \magstep2}
! \setfont\chaptt{tt12 scaled \magstep2}
! \setfont\chapsf{ss12 scaled \magstep2}
  \let\chapbf=\chaprm
! \setfont\chapsc{csc10 scaled\magstep3}
  \font\chapi=cmmi12 scaled \magstep2
  \font\chapsy=cmsy10 scaled \magstep3
  
! \setfont\secrm{bx12 scaled \magstep1}
! \setfont\secit{ti12 scaled \magstep1}
! \setfont\secsl{sl12 scaled \magstep1}
! \setfont\sectt{tt12 scaled \magstep1}
! \setfont\secsf{ss12 scaled \magstep1}
! \setfont\secbf{bx12 scaled \magstep1}
! \setfont\secsc{csc10 scaled\magstep2}
  \font\seci=cmmi12 scaled \magstep1
  \font\secsy=cmsy10 scaled \magstep2
  
! % \setfont\ssecrm{bx10 scaled \magstep1}    % This size an font looked bad.
! % \setfont\ssecit{cmti10 scaled \magstep1}    % The letters were too crowded.
! % \setfont\ssecsl{sl10 scaled \magstep1}
! % \setfont\ssectt{tt10 scaled \magstep1}
! % \setfont\ssecsf{ss10 scaled \magstep1}
! 
! %\setfont\ssecrm{b10 scaled 1315}	% Note the use of cmb rather than cmbx.
! %\setfont\ssecit{ti10 scaled 1315}	% Also, the size is a little larger than
! %\setfont\ssecsl{sl10 scaled 1315}	% being scaled magstep1.
! %\setfont\ssectt{tt10 scaled 1315}
! %\setfont\ssecsf{ss10 scaled 1315}
  
  %\let\ssecbf=\ssecrm
  
! \setfont\ssecrm{bx12 scaled \magstephalf}
! \setfont\ssecit{ti12 scaled \magstephalf}
! \setfont\ssecsl{sl12 scaled \magstephalf}
! \setfont\ssectt{tt12 scaled \magstephalf}
! \setfont\ssecsf{ss12 scaled \magstephalf}
! \setfont\ssecbf{bx12 scaled \magstephalf}
! \setfont\ssecsc{csc10 scaled \magstep1}
  \font\sseci=cmmi12 scaled \magstephalf
! \font\ssecsy=cmsy10 scaled \magstep1
  % The smallcaps and symbol fonts should actually be scaled \magstep1.5,
  % but that is not a standard magnification.
  
- % Fonts for title page:
- \setfont\titlerm{bx12 scaled \magstep3}
- \let\authorrm = \secrm
- 
  % In order for the font changes to affect most math symbols and letters,
  % we have to define the \textfont of the standard families.  Since
--- 1083,1210 ----
  \def\fontprefix{cm}
  \fi
+ % Support font families that don't use the same naming scheme as CM.
+ \def\rmshape{r}
+ \def\rmbshape{bx}               %where the normal face is bold
+ \def\bfshape{b}
+ \def\bxshape{bx}
+ \def\ttshape{tt}
+ \def\ttbshape{tt}
+ \def\ttslshape{sltt}
+ \def\itshape{ti}
+ \def\itbshape{bxti}
+ \def\slshape{sl}
+ \def\slbshape{bxsl}
+ \def\sfshape{ss}
+ \def\sfbshape{ss}
+ \def\scshape{csc}
+ \def\scbshape{csc}
  
  \ifx\bigger\relax
  \let\mainmagstep=\magstep1
! \setfont\textrm\rmshape{12}{1000}
! \setfont\texttt\ttshape{12}{1000}
  \else
! \setfont\textrm\rmshape{10}{\mainmagstep}
! \setfont\texttt\ttshape{10}{\mainmagstep}
  \fi
  % Instead of cmb10, you many want to use cmbx10.
  % cmbx10 is a prettier font on its own, but cmb10
  % looks better when embedded in a line with cmr10.
! \setfont\textbf\bfshape{10}{\mainmagstep}
! \setfont\textit\itshape{10}{\mainmagstep}
! \setfont\textsl\slshape{10}{\mainmagstep}
! \setfont\textsf\sfshape{10}{\mainmagstep}
! \setfont\textsc\scshape{10}{\mainmagstep}
! \setfont\textttsl\ttslshape{10}{\mainmagstep}
  \font\texti=cmmi10 scaled \mainmagstep
  \font\textsy=cmsy10 scaled \mainmagstep
  
  % A few fonts for @defun, etc.
! \setfont\defbf\bxshape{10}{\magstep1} %was 1314
! \setfont\deftt\ttshape{10}{\magstep1}
  \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf}
  
! % Fonts for indices and small examples (9pt).
  % We actually use the slanted font rather than the italic,
  % because texinfo normally uses the slanted fonts for that.
  % Do not make many font distinctions in general in the index, since they
  % aren't very useful.
! \setfont\ninett\ttshape{9}{1000}
! \setfont\indrm\rmshape{9}{1000}
! \setfont\indit\slshape{9}{1000}
  \let\indsl=\indit
  \let\indtt=\ninett
+ \let\indttsl=\ninett
  \let\indsf=\indrm
  \let\indbf=\indrm
! \setfont\indsc\scshape{10}{900}
  \font\indi=cmmi9
  \font\indsy=cmsy9
  
! % Fonts for title page:
! \setfont\titlerm\rmbshape{12}{\magstep3}
! \setfont\titleit\itbshape{10}{\magstep4}
! \setfont\titlesl\slbshape{10}{\magstep4}
! \setfont\titlett\ttbshape{12}{\magstep3}
! \setfont\titlettsl\ttslshape{10}{\magstep4}
! \setfont\titlesf\sfbshape{17}{\magstep1}
! \let\titlebf=\titlerm
! \setfont\titlesc\scbshape{10}{\magstep4}
! \font\titlei=cmmi12 scaled \magstep3
! \font\titlesy=cmsy10 scaled \magstep4
! \def\authorrm{\secrm}
! 
! % Chapter (and unnumbered) fonts (17.28pt).
! \setfont\chaprm\rmbshape{12}{\magstep2}
! \setfont\chapit\itbshape{10}{\magstep3}
! \setfont\chapsl\slbshape{10}{\magstep3}
! \setfont\chaptt\ttbshape{12}{\magstep2}
! \setfont\chapttsl\ttslshape{10}{\magstep3}
! \setfont\chapsf\sfbshape{17}{1000}
  \let\chapbf=\chaprm
! \setfont\chapsc\scbshape{10}{\magstep3}
  \font\chapi=cmmi12 scaled \magstep2
  \font\chapsy=cmsy10 scaled \magstep3
  
! % Section fonts (14.4pt).
! \setfont\secrm\rmbshape{12}{\magstep1}
! \setfont\secit\itbshape{10}{\magstep2}
! \setfont\secsl\slbshape{10}{\magstep2}
! \setfont\sectt\ttbshape{12}{\magstep1}
! \setfont\secttsl\ttslshape{10}{\magstep2}
! \setfont\secsf\sfbshape{12}{\magstep1}
! \let\secbf\secrm
! \setfont\secsc\scbshape{10}{\magstep2}
  \font\seci=cmmi12 scaled \magstep1
  \font\secsy=cmsy10 scaled \magstep2
  
! % \setfont\ssecrm\bxshape{10}{\magstep1}    % This size an font looked bad.
! % \setfont\ssecit\itshape{10}{\magstep1}    % The letters were too crowded.
! % \setfont\ssecsl\slshape{10}{\magstep1}
! % \setfont\ssectt\ttshape{10}{\magstep1}
! % \setfont\ssecsf\sfshape{10}{\magstep1}
! 
! %\setfont\ssecrm\bfshape{10}{1315}      % Note the use of cmb rather than cmbx.
! %\setfont\ssecit\itshape{10}{1315}      % Also, the size is a little larger than
! %\setfont\ssecsl\slshape{10}{1315}      % being scaled magstep1.
! %\setfont\ssectt\ttshape{10}{1315}
! %\setfont\ssecsf\sfshape{10}{1315}
  
  %\let\ssecbf=\ssecrm
  
! % Subsection fonts (13.15pt).
! \setfont\ssecrm\rmbshape{12}{\magstephalf}
! \setfont\ssecit\itbshape{10}{1315}
! \setfont\ssecsl\slbshape{10}{1315}
! \setfont\ssectt\ttbshape{12}{\magstephalf}
! \setfont\ssecttsl\ttslshape{10}{1315}
! \setfont\ssecsf\sfbshape{12}{\magstephalf}
! \let\ssecbf\ssecrm
! \setfont\ssecsc\scbshape{10}{\magstep1}
  \font\sseci=cmmi12 scaled \magstephalf
! \font\ssecsy=cmsy10 scaled 1315
  % The smallcaps and symbol fonts should actually be scaled \magstep1.5,
  % but that is not a standard magnification.
  
  % In order for the font changes to affect most math symbols and letters,
  % we have to define the \textfont of the standard families.  Since
*************** where each line of input produces a line
*** 1042,1073 ****
  % of just \STYLE.  We do this so that font changes will continue to work
  % in math mode, where it is the current \fam that is relevant in most
! % cases, not the current.  Plain TeX does, for example,
! % \def\bf{\fam=\bffam \tenbf}  By redefining \tenbf, we obviate the need
! % to redefine \bf itself.
  \def\textfonts{%
    \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl
    \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc
!   \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy
    \resetmathfonts}
  \def\chapfonts{%
    \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl
    \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc
!   \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy
!   \resetmathfonts}
  \def\secfonts{%
    \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl
    \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc
!   \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy
!   \resetmathfonts}
  \def\subsecfonts{%
    \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl
    \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc
!   \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy
!   \resetmathfonts}
  \def\indexfonts{%
    \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl
    \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc
!   \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy
!   \resetmathfonts}
  
  % Set up the default fonts, so we can use them for creating boxes.
--- 1223,1262 ----
  % of just \STYLE.  We do this so that font changes will continue to work
  % in math mode, where it is the current \fam that is relevant in most
! % cases, not the current font.  Plain TeX does \def\bf{\fam=\bffam
! % \tenbf}, for example.  By redefining \tenbf, we obviate the need to
! % redefine \bf itself.
  \def\textfonts{%
    \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl
    \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc
!   \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy \let\tenttsl=\textttsl
    \resetmathfonts}
+ \def\titlefonts{%
+   \let\tenrm=\titlerm \let\tenit=\titleit \let\tensl=\titlesl
+   \let\tenbf=\titlebf \let\tentt=\titlett \let\smallcaps=\titlesc
+   \let\tensf=\titlesf \let\teni=\titlei \let\tensy=\titlesy
+   \let\tenttsl=\titlettsl
+   \resetmathfonts \setleading{25pt}}
+ \def\titlefont#1{{\titlefonts\rm #1}}
  \def\chapfonts{%
    \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl
    \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc
!   \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy \let\tenttsl=\chapttsl
!   \resetmathfonts \setleading{19pt}}
  \def\secfonts{%
    \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl
    \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc
!   \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy \let\tenttsl=\secttsl
!   \resetmathfonts \setleading{16pt}}
  \def\subsecfonts{%
    \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl
    \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc
!   \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy \let\tenttsl=\ssecttsl
!   \resetmathfonts \setleading{15pt}}
! \let\subsubsecfonts = \subsecfonts % Maybe make sssec fonts scaled magstephalf?
  \def\indexfonts{%
    \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl
    \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc
!   \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy \let\tenttsl=\indttsl
!   \resetmathfonts \setleading{12pt}}
  
  % Set up the default fonts, so we can use them for creating boxes.
*************** where each line of input produces a line
*** 1079,1085 ****
  
  % Fonts for short table of contents.
! \setfont\shortcontrm{r12}
! \setfont\shortcontbf{bx12}
! \setfont\shortcontsl{sl12}
  
  %% Add scribe-like font environments, plus @l for inline lisp (usually sans
--- 1268,1274 ----
  
  % Fonts for short table of contents.
! \setfont\shortcontrm\rmshape{12}{1000}
! \setfont\shortcontbf\bxshape{12}{1000}
! \setfont\shortcontsl\slshape{12}{1000}
  
  %% Add scribe-like font environments, plus @l for inline lisp (usually sans
*************** where each line of input produces a line
*** 1113,1117 ****
  \let\ttfont=\t
  \def\samp #1{`\tclose{#1}'\null}
! \def\key #1{{\tt \nohyphenation \uppercase{#1}}\null}
  \def\ctrl #1{{\tt \rawbackslash \hat}#1}
  
--- 1302,1315 ----
  \let\ttfont=\t
  \def\samp #1{`\tclose{#1}'\null}
! \setfont\smallrm\rmshape{8}{1000}
! \font\smallsy=cmsy9
! \def\key#1{{\smallrm\textfont2=\smallsy \leavevmode\hbox{%
!   \raise0.4pt\hbox{$\langle$}\kern-.08em\vtop{%
!     \vbox{\hrule\kern-0.4pt
!      \hbox{\raise0.4pt\hbox{\vphantom{$\langle$}}#1}}%
!     \kern-0.4pt\hrule}%
!   \kern-.06em\raise0.4pt\hbox{$\rangle$}}}}
! % The old definition, with no lozenge:
! %\def\key #1{{\ttsl \nohyphenation \uppercase{#1}}\null}
  \def\ctrl #1{{\tt \rawbackslash \hat}#1}
  
*************** where each line of input produces a line
*** 1142,1146 ****
  
  % We *must* turn on hyphenation at `-' and `_' in \code.
! % Otherwise, it is too hard to avoid overful hboxes
  % in the Emacs manual, the Library manual, etc.
  
--- 1340,1344 ----
  
  % We *must* turn on hyphenation at `-' and `_' in \code.
! % Otherwise, it is too hard to avoid overfull hboxes
  % in the Emacs manual, the Library manual, etc.
  
*************** where each line of input produces a line
*** 1148,1156 ****
  % both hyphenation at - and hyphenation within words.
  % We must therefore turn them both off (\tclose does that)
! % and arrange explicitly to hyphenate an a dash.
  %  -- rms.
  {
  \catcode`\-=\active
  \catcode`\_=\active
  \global\def\code{\begingroup \catcode`\-=\active \let-\codedash \catcode`\_=\active \let_\codeunder \codex}
  % The following is used by \doprintindex to insure that long function names
--- 1346,1355 ----
  % both hyphenation at - and hyphenation within words.
  % We must therefore turn them both off (\tclose does that)
! % and arrange explicitly to hyphenate at a dash.
  %  -- rms.
  {
  \catcode`\-=\active
  \catcode`\_=\active
+ \catcode`\|=\active
  \global\def\code{\begingroup \catcode`\-=\active \let-\codedash \catcode`\_=\active \let_\codeunder \codex}
  % The following is used by \doprintindex to insure that long function names
*************** where each line of input produces a line
*** 1158,1168 ****
  % read from the file, as \entry parses the arguments long before \code is
  % ever called.  -- mycroft
! \global\def\indexbreaks{\catcode`\-=\active \let-\realdash \catcode`\_=\active \let_\realunder}
  }
  
  \def\realdash{-}
- \def\realunder{_}
  \def\codedash{-\discretionary{}{}{}}
! \def\codeunder{\normalunderscore\discretionary{}{}{}}
  \def\codex #1{\tclose{#1}\endgroup}
  
--- 1357,1371 ----
  % read from the file, as \entry parses the arguments long before \code is
  % ever called.  -- mycroft
! % _ is always active; and it shouldn't be \let = to an _ that is a
! % subscript character anyway. Then, @cindex @samp{_} (for example)
! % fails.  --karl
! \global\def\indexbreaks{%
!   \catcode`\-=\active \let-\realdash
! }
  }
  
  \def\realdash{-}
  \def\codedash{-\discretionary{}{}{}}
! \def\codeunder{\ifusingtt{\normalunderscore\discretionary{}{}{}}{\_}}
  \def\codex #1{\tclose{#1}\endgroup}
  
*************** where each line of input produces a line
*** 1172,1180 ****
  % then @kbd has no effect.
  
  \def\xkey{\key}
  \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}%
  \ifx\one\xkey\ifx\threex\three \key{#2}%
! \else\tclose{\look}\fi
! \else\tclose{\look}\fi}
  
  % Typeset a dimension, e.g., `in' or `pt'.  The only reason for the
--- 1375,1434 ----
  % then @kbd has no effect.
  
+ % @kbdinputstyle -- arg is `distinct' (@kbd uses slanted tty font always),
+ %   `example' (@kbd uses ttsl only inside of @example and friends),
+ %   or `code' (@kbd uses normal tty font always).
+ \def\kbdinputstyle{\parsearg\kbdinputstylexxx}
+ \def\kbdinputstylexxx#1{%
+   \def\arg{#1}%
+   \ifx\arg\worddistinct
+     \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\ttsl}%
+   \else\ifx\arg\wordexample
+     \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\tt}%
+   \else\ifx\arg\wordcode
+     \gdef\kbdexamplefont{\tt}\gdef\kbdfont{\tt}%
+   \fi\fi\fi
+ }
+ \def\worddistinct{distinct}
+ \def\wordexample{example}
+ \def\wordcode{code}
+ 
+ % Default is kbdinputdistinct.  (Too much of a hassle to call the macro,
+ % the catcodes are wrong for parsearg to work.)
+ \gdef\kbdexamplefont{\ttsl}\gdef\kbdfont{\ttsl}
+ 
  \def\xkey{\key}
  \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}%
  \ifx\one\xkey\ifx\threex\three \key{#2}%
! \else{\tclose{\kbdfont\look}}\fi
! \else{\tclose{\kbdfont\look}}\fi}
! 
! % @url.  Quotes do not seem necessary, so use \code.
! \let\url=\code
! 
! % @uref (abbreviation for `urlref') takes an optional second argument
! % specifying the text to display.  First (mandatory) arg is the url.
! % Perhaps eventually put in a hypertex \special here.
! % 
! \def\uref#1{\urefxxx #1,,\finish}
! \def\urefxxx#1,#2,#3\finish{%
!   \setbox0 = \hbox{\ignorespaces #2}%
!   \ifdim\wd0 > 0pt
!     \unhbox0\ (\code{#1})%
!   \else
!     \code{#1}%
!   \fi
! }
! 
! % rms does not like the angle brackets --karl, 17may97.
! % So now @email is just like @uref.
! %\def\email#1{$\langle${\tt #1}$\rangle$}
! \let\email=\uref
! 
! % Check if we are currently using a typewriter font.  Since all the
! % Computer Modern typewriter fonts have zero interword stretch (and
! % shrink), and it is reasonable to expect all typewriter fonts to have
! % this property, we can check that font parameter.
! %
! \def\ifmonospace{\ifdim\fontdimen3\font=0pt }
  
  % Typeset a dimension, e.g., `in' or `pt'.  The only reason for the
*************** where each line of input produces a line
*** 1186,1195 ****
  \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par}
  
! \def\l#1{{\li #1}\null}		%
  
! \def\r#1{{\rm #1}}		% roman font
  % Use of \lowercase was suggested.
! \def\sc#1{{\smallcaps#1}}	% smallcaps font
! \def\ii#1{{\it #1}}		% italic font
  
  \message{page headings,}
--- 1440,1456 ----
  \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par}
  
! % @l was never documented to mean ``switch to the Lisp font'',
! % and it is not used as such in any manual I can find.  We need it for
! % Polish suppressed-l.  --karl, 22sep96.
! %\def\l#1{{\li #1}\null}
  
! \def\r#1{{\rm #1}}              % roman font
  % Use of \lowercase was suggested.
! \def\sc#1{{\smallcaps#1}}       % smallcaps font
! \def\ii#1{{\it #1}}             % italic font
! 
! % @pounds{} is a sterling sign.
! \def\pounds{{\it\$}}
! 
  
  \message{page headings,}
*************** where each line of input produces a line
*** 1199,1204 ****
  
  % First the title page.  Must do @settitle before @titlepage.
- \def\titlefont#1{{\titlerm #1}}
- 
  \newif\ifseenauthor
  \newif\iffinishedtitlepage
--- 1460,1463 ----
*************** where each line of input produces a line
*** 1206,1210 ****
  \def\shorttitlepage{\parsearg\shorttitlepagezzz}
  \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}%
! 	\endgroup\page\hbox{}\page}
  
  \def\titlepage{\begingroup \parindent=0pt \textfonts
--- 1465,1469 ----
  \def\shorttitlepage{\parsearg\shorttitlepagezzz}
  \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}%
!         \endgroup\page\hbox{}\page}
  
  \def\titlepage{\begingroup \parindent=0pt \textfonts
*************** where each line of input produces a line
*** 1222,1229 ****
     % Now you can print the title using @title.
     \def\title{\parsearg\titlezzz}%
!    \def\titlezzz##1{\leftline{\titlefont{##1}}
! 		    % print a rule at the page bottom also.
! 		    \finishedtitlepagefalse
! 		    \vskip4pt \hrule height 4pt width \hsize \vskip4pt}%
     % No rule at page bottom unless we print one at the top with @title.
     \finishedtitlepagetrue
--- 1481,1488 ----
     % Now you can print the title using @title.
     \def\title{\parsearg\titlezzz}%
!    \def\titlezzz##1{\leftline{\titlefonts\rm ##1}
!                     % print a rule at the page bottom also.
!                     \finishedtitlepagefalse
!                     \vskip4pt \hrule height 4pt width \hsize \vskip4pt}%
     % No rule at page bottom unless we print one at the top with @title.
     \finishedtitlepagetrue
*************** where each line of input produces a line
*** 1243,1247 ****
     \def\page{%
        \iffinishedtitlepage\else
! 	 \finishtitlepage
        \fi
        \oldpage
--- 1502,1506 ----
     \def\page{%
        \iffinishedtitlepage\else
!          \finishtitlepage
        \fi
        \oldpage
*************** where each line of input produces a line
*** 1311,1318 ****
  \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}}
  
! \gdef\everyheadingxxx #1{\everyheadingyyy #1@|@|@|@|\finish}
! \gdef\everyheadingyyy #1@|#2@|#3@|#4\finish{%
! \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}
! \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}}
  
  \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish}
--- 1570,1574 ----
  \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}}
  
! \gdef\everyheadingxxx#1{\oddheadingxxx{#1}\evenheadingxxx{#1}}%
  
  \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish}
*************** where each line of input produces a line
*** 1322,1342 ****
  \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish}
  \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{%
! \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}}
  
! \gdef\everyfootingxxx #1{\everyfootingyyy #1@|@|@|@|\finish}
! \gdef\everyfootingyyy #1@|#2@|#3@|#4\finish{%
! \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}
! \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}}
  %
  }% unbind the catcode of @.
  
! % @headings double	turns headings on for double-sided printing.
! % @headings single	turns headings on for single-sided printing.
! % @headings off		turns them off.
! % @headings on		same as @headings double, retained for compatibility.
! % @headings after	turns on double-sided headings after this page.
! % @headings doubleafter	turns on double-sided headings after this page.
  % @headings singleafter turns on single-sided headings after this page.
! % By default, they are off.
  
  \def\headings #1 {\csname HEADINGS#1\endcsname}
--- 1578,1602 ----
  \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish}
  \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{%
!   \global\oddfootline = {\rlap{\centerline{#2}}\line{#1\hfil#3}}%
!   %
!   % Leave some space for the footline.  Hopefully ok to assume
!   % @evenfooting will not be used by itself.
!   \global\advance\pageheight by -\baselineskip
!   \global\advance\vsize by -\baselineskip
! }
  
! \gdef\everyfootingxxx#1{\oddfootingxxx{#1}\evenfootingxxx{#1}}
  %
  }% unbind the catcode of @.
  
! % @headings double      turns headings on for double-sided printing.
! % @headings single      turns headings on for single-sided printing.
! % @headings off         turns them off.
! % @headings on          same as @headings double, retained for compatibility.
! % @headings after       turns on double-sided headings after this page.
! % @headings doubleafter turns on double-sided headings after this page.
  % @headings singleafter turns on single-sided headings after this page.
! % By default, they are off at the start of a document,
! % and turned `on' after @end titlepage.
  
  \def\headings #1 {\csname HEADINGS#1\endcsname}
*************** where each line of input produces a line
*** 1352,1356 ****
  % edge of all pages.
  \def\HEADINGSdouble{
- %\pagealignmacro
  \global\pageno=1
  \global\evenfootline={\hfil}
--- 1612,1615 ----
*************** where each line of input produces a line
*** 1358,1366 ****
  \global\evenheadline={\line{\folio\hfil\thistitle}}
  \global\oddheadline={\line{\thischapter\hfil\folio}}
  }
  % For single-sided printing, chapter title goes across top left of page,
  % page number on top right.
  \def\HEADINGSsingle{
- %\pagealignmacro
  \global\pageno=1
  \global\evenfootline={\hfil}
--- 1617,1627 ----
  \global\evenheadline={\line{\folio\hfil\thistitle}}
  \global\oddheadline={\line{\thischapter\hfil\folio}}
+ \global\let\contentsalignmacro = \chapoddpage
  }
+ \let\contentsalignmacro = \chappager
+ 
  % For single-sided printing, chapter title goes across top left of page,
  % page number on top right.
  \def\HEADINGSsingle{
  \global\pageno=1
  \global\evenfootline={\hfil}
*************** where each line of input produces a line
*** 1368,1371 ****
--- 1629,1633 ----
  \global\evenheadline={\line{\thischapter\hfil\folio}}
  \global\oddheadline={\line{\thischapter\hfil\folio}}
+ \global\let\contentsalignmacro = \chappager
  }
  \def\HEADINGSon{\HEADINGSdouble}
*************** where each line of input produces a line
*** 1378,1381 ****
--- 1640,1644 ----
  \global\evenheadline={\line{\folio\hfil\thistitle}}
  \global\oddheadline={\line{\thischapter\hfil\folio}}
+ \global\let\contentsalignmacro = \chapoddpage
  }
  
*************** where each line of input produces a line
*** 1386,1389 ****
--- 1649,1653 ----
  \global\evenheadline={\line{\thischapter\hfil\folio}}
  \global\oddheadline={\line{\thischapter\hfil\folio}}
+ \global\let\contentsalignmacro = \chappager
  }
  
*************** July\or August\or September\or October\o
*** 1409,1412 ****
--- 1673,1677 ----
  \def\settitlezzz #1{\gdef\thistitle{#1}}
  
+ 
  \message{tables,}
  
*************** July\or August\or September\or October\o
*** 1441,1445 ****
  \newif\ifitemxneedsnegativevskip
  
! \def\itemxpar{\par\ifitemxneedsnegativevskip\vskip-\parskip\nobreak\fi}
  
  \def\internalBitem{\smallbreak \parsearg\itemzzz}
--- 1706,1710 ----
  \newif\ifitemxneedsnegativevskip
  
! \def\itemxpar{\par\ifitemxneedsnegativevskip\nobreak\vskip-\parskip\nobreak\fi}
  
  \def\internalBitem{\smallbreak \parsearg\itemzzz}
*************** July\or August\or September\or October\o
*** 1705,1709 ****
  \advance\itemno by 1
  {\let\par=\endgraf \smallbreak}%
! \ifhmode \errmessage{\in hmode at itemizeitem}\fi
  {\parskip=0in \hskip 0pt
  \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}%
--- 1970,1974 ----
  \advance\itemno by 1
  {\let\par=\endgraf \smallbreak}%
! \ifhmode \errmessage{In hmode at itemizeitem}\fi
  {\parskip=0in \hskip 0pt
  \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}%
*************** July\or August\or September\or October\o
*** 1712,1719 ****
  
  % @multitable macros
! % Amy Hendrickson, 8/18/94
  %
! % @multitable ... @endmultitable will make as many columns as desired.
! % Contents of each column will wrap at width given in preamble. Width
  % can be specified either with sample text given in a template line,
  % or in percent of \hsize, the current width of text on page.
--- 1977,1984 ----
  
  % @multitable macros
! % Amy Hendrickson, 8/18/94, 3/6/96
  %
! % @multitable ... @end multitable will make as many columns as desired.
! % Contents of each column will wrap at width given in preamble.  Width
  % can be specified either with sample text given in a template line,
  % or in percent of \hsize, the current width of text on page.
*************** July\or August\or September\or October\o
*** 1723,1746 ****
  % To make preamble:
  %
! % Either define widths of columns in terms of percent of \hsize: 
! %   @multitable @percentofhsize .2 .3 .5
  %   @item ...
  %
! %   Numbers following @percentofhsize are the percent of the total
  %   current hsize to be used for each column. You may use as many
  %   columns as desired.
  
  % Or use a template:
  %   @multitable {Column 1 template} {Column 2 template} {Column 3 template}
  %   @item ...
  %   using the widest term desired in each column.
  
! 
! % Each new table line starts with @item, each subsequent new column 
  % starts with @tab. Empty columns may be produced by supplying @tab's
  % with nothing between them for as many times as empty columns are needed,
  % ie, @tab@tab@tab will produce two empty columns.
  
! % @item, @tab, @multicolumn or @endmulticolumn do not need to be on their
  % own lines, but it will not hurt if they are.
  
--- 1988,2021 ----
  % To make preamble:
  %
! % Either define widths of columns in terms of percent of \hsize:
! %   @multitable @columnfractions .25 .3 .45
  %   @item ...
  %
! %   Numbers following @columnfractions are the percent of the total
  %   current hsize to be used for each column. You may use as many
  %   columns as desired.
  
+ 
  % Or use a template:
  %   @multitable {Column 1 template} {Column 2 template} {Column 3 template}
  %   @item ...
  %   using the widest term desired in each column.
+ %
+ % For those who want to use more than one line's worth of words in
+ % the preamble, break the line within one argument and it
+ % will parse correctly, i.e.,
+ %
+ %     @multitable {Column 1 template} {Column 2 template} {Column 3
+ %      template}
+ % Not:
+ %     @multitable {Column 1 template} {Column 2 template}
+ %      {Column 3 template}
  
! % Each new table line starts with @item, each subsequent new column
  % starts with @tab. Empty columns may be produced by supplying @tab's
  % with nothing between them for as many times as empty columns are needed,
  % ie, @tab@tab@tab will produce two empty columns.
  
! % @item, @tab, @multitable or @end multitable do not need to be on their
  % own lines, but it will not hurt if they are.
  
*************** July\or August\or September\or October\o
*** 1749,1782 ****
  %   @multitable {Column 1 template} {Column 2 template} {Column 3 template}
  %   @item first col stuff @tab second col stuff @tab third col
! %   @item 
! %   first col stuff 
! %   @tab 
! %   second col stuff 
! %   @tab 
! %   third col 
! %   @item first col stuff @tab second col stuff 
  %   @tab Many paragraphs of text may be used in any column.
! %     
  %         They will wrap at the width determined by the template.
  %   @item@tab@tab This will be in third column.
! %   @endmultitable
  
  % Default dimensions may be reset by user.
! % @intableparskip will set vertical space between paragraphs in table.
! % @intableparindent will set paragraph indent in table.
! % @spacebetweencols will set horizontal space to be left between columns.
! % @spacebetweenlines will set vertical space to be left between lines.
  
  %%%%
! % Dimensions 
  
! \newdimen\intableparskip
! \newdimen\intableparindent
! \newdimen\spacebetweencols
! \newdimen\spacebetweenlines
! \intableparskip=0pt
! \intableparindent=6pt
! \spacebetweencols=12pt
! \spacebetweenlines=12pt
  
  %%%%
--- 2024,2059 ----
  %   @multitable {Column 1 template} {Column 2 template} {Column 3 template}
  %   @item first col stuff @tab second col stuff @tab third col
! %   @item
! %   first col stuff
! %   @tab
! %   second col stuff
! %   @tab
! %   third col
! %   @item first col stuff @tab second col stuff
  %   @tab Many paragraphs of text may be used in any column.
! %
  %         They will wrap at the width determined by the template.
  %   @item@tab@tab This will be in third column.
! %   @end multitable
  
  % Default dimensions may be reset by user.
! % @multitableparskip is vertical space between paragraphs in table.
! % @multitableparindent is paragraph indent in table.
! % @multitablecolmargin is horizontal space to be left between columns.
! % @multitablelinespace is space to leave between table items, baseline
! %                                                            to baseline.
! %   0pt means it depends on current normal line spacing.
  
  %%%%
! % Dimensions
  
! \newskip\multitableparskip
! \newskip\multitableparindent
! \newdimen\multitablecolspace
! \newskip\multitablelinespace
! \multitableparskip=0pt
! \multitableparindent=6pt
! \multitablecolspace=12pt
! \multitablelinespace=0pt
  
  %%%%
*************** July\or August\or September\or October\o
*** 1784,1841 ****
  \let\endsetuptable\relax
  \def\xendsetuptable{\endsetuptable}
! \let\percentofhsize\relax
! \def\xpercentofhsize{\percentofhsize}
  \newif\ifsetpercent
  
  \newcount\colcount
  \def\setuptable#1{\def\firstarg{#1}%
  \ifx\firstarg\xendsetuptable\let\go\relax%
  \else
!   \ifx\firstarg\xpercentofhsize\global\setpercenttrue%
    \else
      \ifsetpercent
!        \if#1.\else%
!        \global\advance\colcount by1 %
!        \expandafter\xdef\csname col\the\colcount\endcsname{.#1\hsize}%
!        \fi
      \else
         \global\advance\colcount by1
!        \setbox0=\hbox{#1}%
         \expandafter\xdef\csname col\the\colcount\endcsname{\the\wd0}%
      \fi%
    \fi%
!   \let\go\setuptable%
  \fi\go}
  %%%%
  % multitable syntax
! \def\tab{&}
  
  %%%%
! % @multitable ... @endmultitable definitions:
  
! \def\multitable#1\item{\bgroup
  \let\item\cr
  \tolerance=9500
  \hbadness=9500
! \parskip=\intableparskip
! \parindent=\intableparindent
  \overfullrule=0pt
  \global\colcount=0\relax%
  \def\Emultitable{\global\setpercentfalse\global\everycr{}\cr\egroup\egroup}%
   % To parse everything between @multitable and @item :
! \def\one{#1}\expandafter\setuptable\one\endsetuptable
   % Need to reset this to 0 after \setuptable.
! \global\colcount=0\relax% 
   %
   % This preamble sets up a generic column definition, which will
   % be used as many times as user calls for columns.
!  % \vtop will set a single line and will also let text wrap and 
   % continue for many paragraphs if desired.
  \halign\bgroup&\global\advance\colcount by 1\relax%
! \vtop{\hsize=\expandafter\csname col\the\colcount\endcsname
   % In order to keep entries from bumping into each other
!  % we will add a \leftskip of \spacebetweencols to all columns after
   % the first one.
!  %  If a template has been used, we will add \spacebetweencols 
   % to the width of each template entry.
   %  If user has set preamble in terms of percent of \hsize
--- 2061,2131 ----
  \let\endsetuptable\relax
  \def\xendsetuptable{\endsetuptable}
! \let\columnfractions\relax
! \def\xcolumnfractions{\columnfractions}
  \newif\ifsetpercent
  
+ %% 2/1/96, to allow fractions to be given with more than one digit.
+ \def\pickupwholefraction#1 {\global\advance\colcount by1 %
+ \expandafter\xdef\csname col\the\colcount\endcsname{.#1\hsize}%
+ \setuptable}
+ 
  \newcount\colcount
  \def\setuptable#1{\def\firstarg{#1}%
  \ifx\firstarg\xendsetuptable\let\go\relax%
  \else
!   \ifx\firstarg\xcolumnfractions\global\setpercenttrue%
    \else
      \ifsetpercent
!        \let\go\pickupwholefraction   % In this case arg of setuptable
!                                      % is the decimal point before the
!                                      % number given in percent of hsize.
!                                      % We don't need this so we don't use it.
      \else
         \global\advance\colcount by1
!        \setbox0=\hbox{#1 }% Add a normal word space as a separator;
!                           % typically that is always in the input, anyway.
         \expandafter\xdef\csname col\the\colcount\endcsname{\the\wd0}%
      \fi%
    \fi%
! \ifx\go\pickupwholefraction\else\let\go\setuptable\fi%
  \fi\go}
+ 
  %%%%
  % multitable syntax
! \def\tab{&\hskip1sp\relax} % 2/2/96
!                            % tiny skip here makes sure this column space is
!                            % maintained, even if it is never used.
! 
  
  %%%%
! % @multitable ... @end multitable definitions:
  
! \def\multitable{\parsearg\dotable}
! 
! \def\dotable#1{\bgroup
  \let\item\cr
  \tolerance=9500
  \hbadness=9500
! \setmultitablespacing
! \parskip=\multitableparskip
! \parindent=\multitableparindent
  \overfullrule=0pt
  \global\colcount=0\relax%
  \def\Emultitable{\global\setpercentfalse\global\everycr{}\cr\egroup\egroup}%
   % To parse everything between @multitable and @item :
! \setuptable#1 \endsetuptable
   % Need to reset this to 0 after \setuptable.
! \global\colcount=0\relax%
   %
   % This preamble sets up a generic column definition, which will
   % be used as many times as user calls for columns.
!  % \vtop will set a single line and will also let text wrap and
   % continue for many paragraphs if desired.
  \halign\bgroup&\global\advance\colcount by 1\relax%
! \multistrut\vtop{\hsize=\expandafter\csname col\the\colcount\endcsname
   % In order to keep entries from bumping into each other
!  % we will add a \leftskip of \multitablecolspace to all columns after
   % the first one.
!  %  If a template has been used, we will add \multitablecolspace
   % to the width of each template entry.
   %  If user has set preamble in terms of percent of \hsize
*************** July\or August\or September\or October\o
*** 1849,1866 ****
    \else
     % If user has <not> set preamble in terms of percent of \hsize
!    % we will advance \hsize by \spacebetweencols 
!   \advance\hsize by \spacebetweencols
    \fi
!  % In either case we will make \leftskip=\spacebetweencols:
! \leftskip=\spacebetweencols
  \fi
! \noindent##}\cr%
   % \everycr will reset column counter, \colcount, at the end of
!  % each line. Every column  entry will cause \colcount to advance by one. 
   % The table preamble
   % looks at the current \colcount to find the correct column width.
! \global\everycr{\noalign{\nointerlineskip\vskip\spacebetweenlines
! \filbreak%% keeps underfull box messages off when table breaks over pages.
! \global\colcount=0\relax}}}
  
  \message{indexing,}
--- 2139,2194 ----
    \else
     % If user has <not> set preamble in terms of percent of \hsize
!    % we will advance \hsize by \multitablecolspace
!   \advance\hsize by \multitablecolspace
    \fi
!  % In either case we will make \leftskip=\multitablecolspace:
! \leftskip=\multitablecolspace
  \fi
!  % Ignoring space at the beginning and end avoids an occasional spurious
!  % blank line, when TeX decides to break the line at the space before the
!  % box from the multistrut, so the strut ends up on a line by itself.
!  % For example:
!  % @multitable @columnfractions .11 .89
!  % @item @code{#}
!  % @tab Legal holiday which is valid in major parts of the whole country.
!  % Is automatically provided with highlighting sequences respectively marking
!  % characters.
!  \noindent\ignorespaces##\unskip\multistrut}\cr
   % \everycr will reset column counter, \colcount, at the end of
!  % each line. Every column  entry will cause \colcount to advance by one.
   % The table preamble
   % looks at the current \colcount to find the correct column width.
! \global\everycr{\noalign{%
! % \filbreak%% keeps underfull box messages off when table breaks over pages.
! % Maybe so, but it also creates really weird page breaks when the table
! % breaks over pages Wouldn't \vfil be better?  Wait until the problem
! % manifests itself, so it can be fixed for real --karl.
! \global\colcount=0\relax}}
! }
! 
! \def\setmultitablespacing{% test to see if user has set \multitablelinespace.
! % If so, do nothing. If not, give it an appropriate dimension based on
! % current baselineskip.
! \ifdim\multitablelinespace=0pt
! %% strut to put in table in case some entry doesn't have descenders,
! %% to keep lines equally spaced
! \let\multistrut = \strut
! %% Test to see if parskip is larger than space between lines of
! %% table. If not, do nothing.
! %%        If so, set to same dimension as multitablelinespace.
! \else
! \gdef\multistrut{\vrule height\multitablelinespace depth\dp0
! width0pt\relax} \fi
! \ifdim\multitableparskip>\multitablelinespace
! \global\multitableparskip=\multitablelinespace
! \global\advance\multitableparskip-7pt %% to keep parskip somewhat smaller
!                                       %% than skip between lines in the table.
! \fi%
! \ifdim\multitableparskip=0pt
! \global\multitableparskip=\multitablelinespace
! \global\advance\multitableparskip-7pt %% to keep parskip somewhat smaller
!                                       %% than skip between lines in the table.
! \fi}
! 
  
  \message{indexing,}
*************** July\or August\or September\or October\o
*** 1876,1880 ****
  % \fooindex ...rest of line... puts an entry in the index foo.
  % It also defines \fooindfile to be the number of the output channel for
! % the file that	accumulates this index.  The file's extension is foo.
  % The name of an index should be no more than 2 characters long
  % for the sake of vms.
--- 2204,2208 ----
  % \fooindex ...rest of line... puts an entry in the index foo.
  % It also defines \fooindfile to be the number of the output channel for
! % the file that accumulates this index.  The file's extension is foo.
  % The name of an index should be no more than 2 characters long
  % for the sake of vms.
*************** July\or August\or September\or October\o
*** 1882,1887 ****
  \def\newindex #1{
  \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file
! \openout \csname#1indfile\endcsname \jobname.#1	% Open the file
! \expandafter\xdef\csname#1index\endcsname{%	% Define \xxxindex
  \noexpand\doindex {#1}}
  }
--- 2210,2215 ----
  \def\newindex #1{
  \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file
! \openout \csname#1indfile\endcsname \jobname.#1 % Open the file
! \expandafter\xdef\csname#1index\endcsname{%     % Define \xxxindex
  \noexpand\doindex {#1}}
  }
*************** July\or August\or September\or October\o
*** 1895,1900 ****
  \def\newcodeindex #1{
  \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file
! \openout \csname#1indfile\endcsname \jobname.#1	% Open the file
! \expandafter\xdef\csname#1index\endcsname{%	% Define \xxxindex
  \noexpand\docodeindex {#1}}
  }
--- 2223,2228 ----
  \def\newcodeindex #1{
  \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file
! \openout \csname#1indfile\endcsname \jobname.#1 % Open the file
! \expandafter\xdef\csname#1index\endcsname{%     % Define \xxxindex
  \noexpand\docodeindex {#1}}
  }
*************** July\or August\or September\or October\o
*** 1907,1911 ****
  \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname
  \expandafter\let\csname#1indfile\endcsname=\synindexfoo
! \expandafter\xdef\csname#1index\endcsname{%	% Define \xxxindex
  \noexpand\doindex {#2}}%
  }
--- 2235,2239 ----
  \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname
  \expandafter\let\csname#1indfile\endcsname=\synindexfoo
! \expandafter\xdef\csname#1index\endcsname{%     % Define \xxxindex
  \noexpand\doindex {#2}}%
  }
*************** July\or August\or September\or October\o
*** 1916,1920 ****
  \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname
  \expandafter\let\csname#1indfile\endcsname=\synindexfoo
! \expandafter\xdef\csname#1index\endcsname{%	% Define \xxxindex
  \noexpand\docodeindex {#2}}%
  }
--- 2244,2248 ----
  \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname
  \expandafter\let\csname#1indfile\endcsname=\synindexfoo
! \expandafter\xdef\csname#1index\endcsname{%     % Define \xxxindex
  \noexpand\docodeindex {#2}}%
  }
*************** July\or August\or September\or October\o
*** 1964,1971 ****
  \def\ss{\realbackslash ss}%
  % Take care of texinfo commands likely to appear in an index entry.
  \def\_{{\realbackslash _}}%
  \def\w{\realbackslash w }%
  \def\bf{\realbackslash bf }%
! \def\rm{\realbackslash rm }%
  \def\sl{\realbackslash sl }%
  \def\sf{\realbackslash sf}%
--- 2292,2304 ----
  \def\ss{\realbackslash ss}%
  % Take care of texinfo commands likely to appear in an index entry.
+ % (Must be a way to avoid doing expansion at all, and thus not have to
+ % laboriously list every single command here.)
+ \def\@{@}% will be @@ when we switch to @ as escape char.
+ %\let\{ = \lbracecmd
+ %\let\} = \rbracecmd
  \def\_{{\realbackslash _}}%
  \def\w{\realbackslash w }%
  \def\bf{\realbackslash bf }%
! %\def\rm{\realbackslash rm }%
  \def\sl{\realbackslash sl }%
  \def\sf{\realbackslash sf}%
*************** July\or August\or September\or October\o
*** 1974,1988 ****
  \def\less{\realbackslash less}%
  \def\hat{\realbackslash hat}%
! \def\char{\realbackslash char}%
  \def\TeX{\realbackslash TeX}%
  \def\dots{\realbackslash dots }%
! \def\copyright{\realbackslash copyright }%
  \def\tclose##1{\realbackslash tclose {##1}}%
  \def\code##1{\realbackslash code {##1}}%
  \def\samp##1{\realbackslash samp {##1}}%
! \def\t##1{\realbackslash r {##1}}%
  \def\r##1{\realbackslash r {##1}}%
  \def\i##1{\realbackslash i {##1}}%
  \def\b##1{\realbackslash b {##1}}%
  \def\cite##1{\realbackslash cite {##1}}%
  \def\key##1{\realbackslash key {##1}}%
--- 2307,2330 ----
  \def\less{\realbackslash less}%
  \def\hat{\realbackslash hat}%
! %\def\char{\realbackslash char}%
  \def\TeX{\realbackslash TeX}%
  \def\dots{\realbackslash dots }%
! \def\result{\realbackslash result}%
! \def\equiv{\realbackslash equiv}%
! \def\expansion{\realbackslash expansion}%
! \def\print{\realbackslash print}%
! \def\error{\realbackslash error}%
! \def\point{\realbackslash point}%
! \def\copyright{\realbackslash copyright}%
  \def\tclose##1{\realbackslash tclose {##1}}%
  \def\code##1{\realbackslash code {##1}}%
+ \def\dotless##1{\realbackslash dotless {##1}}%
  \def\samp##1{\realbackslash samp {##1}}%
! \def\,##1{\realbackslash ,{##1}}%
! \def\t##1{\realbackslash t {##1}}%
  \def\r##1{\realbackslash r {##1}}%
  \def\i##1{\realbackslash i {##1}}%
  \def\b##1{\realbackslash b {##1}}%
+ \def\sc##1{\realbackslash sc {##1}}%
  \def\cite##1{\realbackslash cite {##1}}%
  \def\key##1{\realbackslash key {##1}}%
*************** July\or August\or September\or October\o
*** 1992,1995 ****
--- 2334,2338 ----
  \def\dfn##1{\realbackslash dfn {##1}}%
  \def\emph##1{\realbackslash emph {##1}}%
+ \def\value##1{\realbackslash value {##1}}%
  \unsepspaces
  }
*************** July\or August\or September\or October\o
*** 2009,2012 ****
--- 2352,2356 ----
  \def\indexnofonts{%
  % Just ignore accents.
+ \let\,=\indexdummyfont
  \let\"=\indexdummyfont
  \let\`=\indexdummyfont
*************** July\or August\or September\or October\o
*** 2021,2024 ****
--- 2365,2369 ----
  \let\v=\indexdummyfont
  \let\H=\indexdummyfont
+ \let\dotless=\indexdummyfont
  % Take care of the plain tex special European modified letters.
  \def\oe{oe}%
*************** July\or August\or September\or October\o
*** 2054,2057 ****
--- 2399,2403 ----
  \let\TeX=\indexdummytex
  \let\dots=\indexdummydots
+ \def\@{@}%
  }
  
*************** July\or August\or September\or October\o
*** 2069,2095 ****
  % #1 is name of index, #2 is stuff to put there
  \def\doind #1#2{%
! % Put the index entry in the margin if desired.
! \ifx\SETmarginindex\relax\else%
! \insert\margin{\hbox{\vrule height8pt depth3pt width0pt #2}}%
! \fi%
! {\count10=\lastpenalty %
! {\indexdummies % Must do this here, since \bf, etc expand at this stage
! \escapechar=`\\%
! {\let\folio=0% Expand all macros now EXCEPT \folio
! \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now
! % so it will be output as is; and it will print as backslash in the indx.
! %
! % Now process the index-string once, with all font commands turned off,
! % to get the string to sort the index by.
! {\indexnofonts
! \xdef\temp1{#2}%
! }%
! % Now produce the complete index entry.  We process the index-string again,
! % this time with font commands expanded, to get what to print in the index.
! \edef\temp{%
! \write \csname#1indfile\endcsname{%
! \realbackslash entry {\temp1}{\folio}{#2}}}%
! \temp }%
! }\penalty\count10}}
  
  \def\dosubind #1#2#3{%
--- 2415,2449 ----
  % #1 is name of index, #2 is stuff to put there
  \def\doind #1#2{%
!   % Put the index entry in the margin if desired.
!   \ifx\SETmarginindex\relax\else
!     \insert\margin{\hbox{\vrule height8pt depth3pt width0pt #2}}%
!   \fi
!   {%
!     \count255=\lastpenalty
!     {%
!       \indexdummies % Must do this here, since \bf, etc expand at this stage
!       \escapechar=`\\
!       {%
!         \let\folio=0% We will expand all macros now EXCEPT \folio.
!         \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now
!         % so it will be output as is; and it will print as backslash.
!         %
!         % First process the index-string with all font commands turned off
!         % to get the string to sort by.
!         {\indexnofonts \xdef\indexsorttmp{#2}}%
!         %
!         % Now produce the complete index entry, with both the sort key and the
!         % original text, including any font commands.
!         \toks0 = {#2}%
!         \edef\temp{%
!           \write\csname#1indfile\endcsname{%
!             \realbackslash entry{\indexsorttmp}{\folio}{\the\toks0}}%
!         }%
!         \temp
!       }%
!     }%
!     \penalty\count255
!   }%
! }
  
  \def\dosubind #1#2#3{%
*************** July\or August\or September\or October\o
*** 2145,2176 ****
  % Define the macros used in formatting output of the sorted index material.
  
! % This is what you call to cause a particular index to get printed.
! % Write
! % @unnumbered Function Index
! % @printindex fn
! 
  \def\printindex{\parsearg\doprintindex}
! 
! \def\doprintindex#1{%
!   \tex
!   \dobreak \chapheadingskip {10000}
!   \catcode`\%=\other\catcode`\&=\other\catcode`\#=\other
!   \catcode`\$=\other
!   \catcode`\~=\other
!   \indexbreaks
    %
!   % The following don't help, since the chars were translated
!   % when the raw index was written, and their fonts were discarded
!   % due to \indexnofonts.
!   %\catcode`\"=\active
!   %\catcode`\^=\active
!   %\catcode`\_=\active
!   %\catcode`\|=\active
!   %\catcode`\<=\active
!   %\catcode`\>=\active
!   % %
!   \def\indexbackslash{\rawbackslashxx}
!   \indexfonts\rm \tolerance=9500 \advance\baselineskip -1pt
!   \begindoublecolumns
    %
    % See if the index file exists and is nonempty.
--- 2499,2512 ----
  % Define the macros used in formatting output of the sorted index material.
  
! % @printindex causes a particular index (the ??s file) to get printed.
! % It does not print any chapter heading (usually an @unnumbered).
! %
  \def\printindex{\parsearg\doprintindex}
! \def\doprintindex#1{\begingroup
!   \dobreak \chapheadingskip{10000}%
    %
!   \indexfonts \rm
!   \tolerance = 9500
!   \indexbreaks
    %
    % See if the index file exists and is nonempty.
*************** July\or August\or September\or October\o
*** 2182,2186 ****
      % there is some text.
      (Index is nonexistent)
!     \else
      %
      % If the index file exists but is empty, then \openin leaves \ifeof
--- 2518,2522 ----
      % there is some text.
      (Index is nonexistent)
!   \else
      %
      % If the index file exists but is empty, then \openin leaves \ifeof
*************** July\or August\or September\or October\o
*** 2191,2201 ****
        (Index is empty)
      \else
        \input \jobname.#1s
      \fi
    \fi
    \closein 1
!   \enddoublecolumns
!   \Etex
! }
  
  % These macros are used by the sorted index file itself.
--- 2527,2544 ----
        (Index is empty)
      \else
+       % Index files are almost Texinfo source, but we use \ as the escape
+       % character.  It would be better to use @, but that's too big a change
+       % to make right now.
+       \def\indexbackslash{\rawbackslashxx}%
+       \catcode`\\ = 0
+       \catcode`\@ = 11
+       \escapechar = `\\
+       \begindoublecolumns
        \input \jobname.#1s
+       \enddoublecolumns
      \fi
    \fi
    \closein 1
! \endgroup}
  
  % These macros are used by the sorted index file itself.
*************** July\or August\or September\or October\o
*** 2288,2307 ****
  }}
  
! %% Define two-column mode, which is used in indexes.
! %% Adapted from the TeXbook, page 416.
! \catcode `\@=11
  
  \newbox\partialpage
- 
  \newdimen\doublecolumnhsize
  
! \def\begindoublecolumns{\begingroup
    % Grab any single-column material above us.
!   \output = {\global\setbox\partialpage
!     =\vbox{\unvbox255\kern -\topskip \kern \baselineskip}}%
    \eject
    %
!   % Now switch to the double-column output routine.
!   \output={\doublecolumnout}%
    %
    % Change the page size parameters.  We could do this once outside this
--- 2631,2665 ----
  }}
  
! % Define two-column mode, which we use to typeset indexes.
! % Adapted from the TeXbook, page 416, which is to say,
! % the manmac.tex format used to print the TeXbook itself.
! \catcode`\@=11
  
  \newbox\partialpage
  \newdimen\doublecolumnhsize
  
! \def\begindoublecolumns{\begingroup % ended by \enddoublecolumns
    % Grab any single-column material above us.
!   \output = {\global\setbox\partialpage = \vbox{%
!     % 
!     % Here is a possibility not foreseen in manmac: if we accumulate a
!     % whole lot of material, we might end up calling this \output
!     % routine twice in a row (see the doublecol-lose test, which is
!     % essentially a couple of indexes with @setchapternewpage off).  In
!     % that case, we must prevent the second \partialpage from
!     % simply overwriting the first, causing us to lose the page.
!     % This will preserve it until a real output routine can ship it
!     % out.  Generally, \partialpage will be empty when this runs and
!     % this will be a no-op.
!     \unvbox\partialpage
!     %
!     % Unvbox the main output page.
!     \unvbox255
!     \kern-\topskip \kern\baselineskip
!   }}%
    \eject
    %
!   % Use the double-column output routine for subsequent pages.
!   \output = {\doublecolumnout}%
    %
    % Change the page size parameters.  We could do this once outside this
*************** July\or August\or September\or October\o
*** 2309,2319 ****
    % format, but then we repeat the same computation.  Repeating a couple
    % of assignments once per index is clearly meaningless for the
!   % execution time, so we may as well do it once.
    %
    % First we halve the line length, less a little for the gutter between
    % the columns.  We compute the gutter based on the line length, so it
    % changes automatically with the paper format.  The magic constant
!   % below is chosen so that the gutter has the same value (well, +- <
!   % 1pt) as it did when we hard-coded it.
    %
    % We put the result in a separate register, \doublecolumhsize, so we
--- 2667,2677 ----
    % format, but then we repeat the same computation.  Repeating a couple
    % of assignments once per index is clearly meaningless for the
!   % execution time, so we may as well do it in one place.
    %
    % First we halve the line length, less a little for the gutter between
    % the columns.  We compute the gutter based on the line length, so it
    % changes automatically with the paper format.  The magic constant
!   % below is chosen so that the gutter has the same value (well, +-<1pt)
!   % as it did when we hard-coded it.
    %
    % We put the result in a separate register, \doublecolumhsize, so we
*************** July\or August\or September\or October\o
*** 2329,2392 ****
    % since nobody clobbers \vsize.)
    \vsize = 2\vsize
-   \doublecolumnpagegoal
  }
- 
- \def\enddoublecolumns{\eject \endgroup \pagegoal=\vsize \unvbox\partialpage}
- 
- \def\doublecolumnsplit{\splittopskip=\topskip \splitmaxdepth=\maxdepth
-   \global\dimen@=\pageheight \global\advance\dimen@ by-\ht\partialpage
-   \global\setbox1=\vsplit255 to\dimen@ \global\setbox0=\vbox{\unvbox1}
-   \global\setbox3=\vsplit255 to\dimen@ \global\setbox2=\vbox{\unvbox3}
-   \ifdim\ht0>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi
-   \ifdim\ht2>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi
- }
- \def\doublecolumnpagegoal{%
-   \dimen@=\vsize \advance\dimen@ by-2\ht\partialpage \global\pagegoal=\dimen@
- }
- \def\pagesofar{\unvbox\partialpage %
-   \hsize=\doublecolumnhsize % have to restore this since output routine
-   \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}}
  \def\doublecolumnout{%
!   \setbox5=\copy255
!   {\vbadness=10000 \doublecolumnsplit}
!   \ifvbox255
!     \setbox0=\vtop to\dimen@{\unvbox0}
!     \setbox2=\vtop to\dimen@{\unvbox2}
!     \onepageout\pagesofar \unvbox255 \penalty\outputpenalty
!   \else
!     \setbox0=\vbox{\unvbox5}
!     \ifvbox0
!       \dimen@=\ht0 \advance\dimen@ by\topskip \advance\dimen@ by-\baselineskip
!       \divide\dimen@ by2 \splittopskip=\topskip \splitmaxdepth=\maxdepth
!       {\vbadness=10000
! 	\loop \global\setbox5=\copy0
!           \setbox1=\vsplit5 to\dimen@
!           \setbox3=\vsplit5 to\dimen@
!           \ifvbox5 \global\advance\dimen@ by1pt \repeat
!         \setbox0=\vbox to\dimen@{\unvbox1}
!         \setbox2=\vbox to\dimen@{\unvbox3}
!         \global\setbox\partialpage=\vbox{\pagesofar}
!         \doublecolumnpagegoal
!       }
!     \fi
!   \fi
  }
  
- \catcode `\@=\other
  \message{sectioning,}
  % Define chapters, sections, etc.
  
! \newcount \chapno
! \newcount \secno        \secno=0
! \newcount \subsecno     \subsecno=0
! \newcount \subsubsecno  \subsubsecno=0
  
  % This counter is funny since it counts through charcodes of letters A, B, ...
! \newcount \appendixno  \appendixno = `\@
  \def\appendixletter{\char\the\appendixno}
  
! \newwrite \contentsfile
  % This is called from \setfilename.
! \def\opencontents{\openout \contentsfile = \jobname.toc}
  
  % Each @chapter defines this as the name of the chapter.
--- 2687,2754 ----
    % since nobody clobbers \vsize.)
    \vsize = 2\vsize
  }
  \def\doublecolumnout{%
!   \splittopskip=\topskip \splitmaxdepth=\maxdepth
!   % Get the available space for the double columns -- the normal
!   % (undoubled) page height minus any material left over from the
!   % previous page.
!   \dimen@=\pageheight \advance\dimen@ by-\ht\partialpage
!   % box0 will be the left-hand column, box2 the right.
!   \setbox0=\vsplit255 to\dimen@ \setbox2=\vsplit255 to\dimen@
!   \onepageout\pagesofar
!   \unvbox255
!   \penalty\outputpenalty
! }
! \def\pagesofar{%
!   % Re-output the contents of the output page -- any previous material,
!   % followed by the two boxes we just split.
!   \unvbox\partialpage
!   \hsize = \doublecolumnhsize
!   \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}%
! }
! \def\enddoublecolumns{%
!   \output = {\balancecolumns}\eject % split what we have
!   \endgroup % started in \begindoublecolumns
!   %
!   % Back to normal single-column typesetting, but take account of the
!   % fact that we just accumulated some stuff on the output page.
!   \pagegoal = \vsize
! }
! \def\balancecolumns{%
!   % Called at the end of the double column material.
!   \setbox0 = \vbox{\unvbox255}%
!   \dimen@ = \ht0
!   \advance\dimen@ by \topskip
!   \advance\dimen@ by-\baselineskip
!   \divide\dimen@ by 2
!   \splittopskip = \topskip
!   % Loop until we get a decent breakpoint.
!   {\vbadness=10000 \loop
!     \global\setbox3=\copy0
!     \global\setbox1=\vsplit3 to\dimen@
!     \ifdim\ht3>\dimen@ \global\advance\dimen@ by1pt
!    \repeat}%
!   \setbox0=\vbox to\dimen@{\unvbox1}%
!   \setbox2=\vbox to\dimen@{\unvbox3}%
!   \pagesofar
  }
+ \catcode`\@ = \other
+ 
  
  \message{sectioning,}
  % Define chapters, sections, etc.
  
! \newcount\chapno
! \newcount\secno        \secno=0
! \newcount\subsecno     \subsecno=0
! \newcount\subsubsecno  \subsubsecno=0
  
  % This counter is funny since it counts through charcodes of letters A, B, ...
! \newcount\appendixno  \appendixno = `\@
  \def\appendixletter{\char\the\appendixno}
  
! \newwrite\contentsfile
  % This is called from \setfilename.
! \def\opencontents{\openout\contentsfile = \jobname.toc }
  
  % Each @chapter defines this as the name of the chapter.
*************** July\or August\or September\or October\o
*** 2394,2433 ****
  
  \def\thischapter{} \def\thissection{}
! \def\seccheck#1{\if \pageno<0 %
! \errmessage{@#1 not allowed after generating table of contents}\fi
! %
! }
  
  \def\chapternofonts{%
! \let\rawbackslash=\relax%
! \let\frenchspacing=\relax%
! \def\result{\realbackslash result}
! \def\equiv{\realbackslash equiv}
! \def\expansion{\realbackslash expansion}
! \def\print{\realbackslash print}
! \def\TeX{\realbackslash TeX}
! \def\dots{\realbackslash dots}
! \def\copyright{\realbackslash copyright}
! \def\tt{\realbackslash tt}
! \def\bf{\realbackslash bf }
! \def\w{\realbackslash w}
! \def\less{\realbackslash less}
! \def\gtr{\realbackslash gtr}
! \def\hat{\realbackslash hat}
! \def\char{\realbackslash char}
! \def\tclose##1{\realbackslash tclose {##1}}
! \def\code##1{\realbackslash code {##1}}
! \def\samp##1{\realbackslash samp {##1}}
! \def\r##1{\realbackslash r {##1}}
! \def\b##1{\realbackslash b {##1}}
! \def\key##1{\realbackslash key {##1}}
! \def\file##1{\realbackslash file {##1}}
! \def\kbd##1{\realbackslash kbd {##1}}
! % These are redefined because @smartitalic wouldn't work inside xdef.
! \def\i##1{\realbackslash i {##1}}
! \def\cite##1{\realbackslash cite {##1}}
! \def\var##1{\realbackslash var {##1}}
! \def\emph##1{\realbackslash emph {##1}}
! \def\dfn##1{\realbackslash dfn {##1}}
  }
  
--- 2756,2800 ----
  
  \def\thischapter{} \def\thissection{}
! \def\seccheck#1{\ifnum \pageno<0
!   \errmessage{@#1 not allowed after generating table of contents}%
! \fi}
  
  \def\chapternofonts{%
!   \let\rawbackslash=\relax
!   \let\frenchspacing=\relax
!   \def\result{\realbackslash result}%
!   \def\equiv{\realbackslash equiv}%
!   \def\expansion{\realbackslash expansion}%
!   \def\print{\realbackslash print}%
!   \def\TeX{\realbackslash TeX}%
!   \def\dots{\realbackslash dots}%
!   \def\result{\realbackslash result}%
!   \def\equiv{\realbackslash equiv}%
!   \def\expansion{\realbackslash expansion}%
!   \def\print{\realbackslash print}%
!   \def\error{\realbackslash error}%
!   \def\point{\realbackslash point}%
!   \def\copyright{\realbackslash copyright}%
!   \def\tt{\realbackslash tt}%
!   \def\bf{\realbackslash bf}%
!   \def\w{\realbackslash w}%
!   \def\less{\realbackslash less}%
!   \def\gtr{\realbackslash gtr}%
!   \def\hat{\realbackslash hat}%
!   \def\char{\realbackslash char}%
!   \def\tclose##1{\realbackslash tclose{##1}}%
!   \def\code##1{\realbackslash code{##1}}%
!   \def\samp##1{\realbackslash samp{##1}}%
!   \def\r##1{\realbackslash r{##1}}%
!   \def\b##1{\realbackslash b{##1}}%
!   \def\key##1{\realbackslash key{##1}}%
!   \def\file##1{\realbackslash file{##1}}%
!   \def\kbd##1{\realbackslash kbd{##1}}%
!   % These are redefined because @smartitalic wouldn't work inside xdef.
!   \def\i##1{\realbackslash i{##1}}%
!   \def\cite##1{\realbackslash cite{##1}}%
!   \def\var##1{\realbackslash var{##1}}%
!   \def\emph##1{\realbackslash emph{##1}}%
!   \def\dfn##1{\realbackslash dfn{##1}}%
  }
  
*************** July\or August\or September\or October\o
*** 2516,2520 ****
  \xdef\thischapter{\putwordChapter{} \the\chapno: \noexpand\thischaptername}%
  {\chapternofonts%
! \edef\temp{{\realbackslash chapentry {#1}{\the\chapno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
--- 2883,2888 ----
  \xdef\thischapter{\putwordChapter{} \the\chapno: \noexpand\thischaptername}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash chapentry{\the\toks0}{\the\chapno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
*************** July\or August\or September\or October\o
*** 2535,2540 ****
  \xdef\thischapter{\putwordAppendix{} \appendixletter: \noexpand\thischaptername}%
  {\chapternofonts%
! \edef\temp{{\realbackslash chapentry
!   {#1}{\putwordAppendix{} \appendixletter}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
--- 2903,2909 ----
  \xdef\thischapter{\putwordAppendix{} \appendixletter: \noexpand\thischaptername}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash chapentry{\the\toks0}%
!   {\putwordAppendix{} \appendixletter}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
*************** July\or August\or September\or October\o
*** 2545,2548 ****
--- 2914,2921 ----
  }}
  
+ % @centerchap is like @unnumbered, but the heading is centered.
+ \outer\def\centerchap{\parsearg\centerchapyyy}
+ \def\centerchapyyy #1{{\let\unnumbchapmacro=\centerchapmacro \unnumberedyyy{#1}}}
+ 
  \outer\def\top{\parsearg\unnumberedyyy}
  \outer\def\unnumbered{\parsearg\unnumberedyyy}
*************** July\or August\or September\or October\o
*** 2566,2570 ****
  \gdef\thischapter{#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \edef\temp{{\realbackslash unnumbchapentry {#1}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
--- 2939,2944 ----
  \gdef\thischapter{#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash unnumbchapentry{\the\toks0}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp  %
*************** July\or August\or September\or October\o
*** 2581,2586 ****
  \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}%
  {\chapternofonts%
  \edef\temp{{\realbackslash secentry %
! {#1}{\the\chapno}{\the\secno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 2955,2961 ----
  \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}%
  {\chapternofonts%
+ \toks0 = {#1}%
  \edef\temp{{\realbackslash secentry %
! {\the\toks0}{\the\chapno}{\the\secno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2596,2601 ****
  \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}%
  {\chapternofonts%
  \edef\temp{{\realbackslash secentry %
! {#1}{\appendixletter}{\the\secno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 2971,2977 ----
  \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}%
  {\chapternofonts%
+ \toks0 = {#1}%
  \edef\temp{{\realbackslash secentry %
! {\the\toks0}{\appendixletter}{\the\secno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2609,2613 ****
  \plainsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \edef\temp{{\realbackslash unnumbsecentry{#1}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 2985,2990 ----
  \plainsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash unnumbsecentry{\the\toks0}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2622,2627 ****
  \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}%
  {\chapternofonts%
  \edef\temp{{\realbackslash subsecentry %
! {#1}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 2999,3005 ----
  \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}%
  {\chapternofonts%
+ \toks0 = {#1}%
  \edef\temp{{\realbackslash subsecentry %
! {\the\toks0}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2636,2641 ****
  \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}%
  {\chapternofonts%
  \edef\temp{{\realbackslash subsecentry %
! {#1}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 3014,3020 ----
  \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}%
  {\chapternofonts%
+ \toks0 = {#1}%
  \edef\temp{{\realbackslash subsecentry %
! {\the\toks0}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2647,2653 ****
  \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz
  \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}%
! \plainsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \edef\temp{{\realbackslash unnumbsubsecentry{#1}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 3026,3033 ----
  \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz
  \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}%
! \plainsubsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash unnumbsubsecentry{\the\toks0}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2663,2668 ****
    {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}%
  {\chapternofonts%
! \edef\temp{{\realbackslash subsubsecentry %
!   {#1}
    {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}
    {\noexpand\folio}}}%
--- 3043,3048 ----
    {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash subsubsecentry{\the\toks0}
    {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}
    {\noexpand\folio}}}%
*************** July\or August\or September\or October\o
*** 2680,2684 ****
    {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}%
  {\chapternofonts%
! \edef\temp{{\realbackslash subsubsecentry{#1}%
    {\appendixletter}
    {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}%
--- 3060,3065 ----
    {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash subsubsecentry{\the\toks0}%
    {\appendixletter}
    {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}%
*************** July\or August\or September\or October\o
*** 2692,2698 ****
  \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz
  \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}%
! \plainsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \edef\temp{{\realbackslash unnumbsubsubsecentry{#1}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
--- 3073,3080 ----
  \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz
  \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}%
! \plainsubsubsecheading {#1}\gdef\thissection{#1}%
  {\chapternofonts%
! \toks0 = {#1}%
! \edef\temp{{\realbackslash unnumbsubsubsecentry{\the\toks0}{\noexpand\folio}}}%
  \escapechar=`\\%
  \write \contentsfile \temp %
*************** July\or August\or September\or October\o
*** 2730,2737 ****
  % NOTE on use of \vbox for chapter headings, section headings, and
  % such:
! %	1) We use \vbox rather than the earlier \line to permit
! %	   overlong headings to fold.
! %	2) \hyphenpenalty is set to 10000 because hyphenation in a
! %	   heading is obnoxious; this forbids it.
  %       3) Likewise, headings look best if no \parindent is used, and
  %          if justification is not attempted.  Hence \raggedright.
--- 3112,3119 ----
  % NOTE on use of \vbox for chapter headings, section headings, and
  % such:
! %       1) We use \vbox rather than the earlier \line to permit
! %          overlong headings to fold.
! %       2) \hyphenpenalty is set to 10000 because hyphenation in a
! %          heading is obnoxious; this forbids it.
  %       3) Likewise, headings look best if no \parindent is used, and
  %          if justification is not attempted.  Hence \raggedright.
*************** July\or August\or September\or October\o
*** 2751,2759 ****
                    \rm #1\hfill}}\bigskip \par\penalty 200}
  
! \def\heading{\parsearg\secheadingi}
! 
! \def\subheading{\parsearg\subsecheadingi}
! 
! \def\subsubheading{\parsearg\subsubsecheadingi}
  
  % These macros generate a chapter, section, etc. heading only
--- 3133,3140 ----
                    \rm #1\hfill}}\bigskip \par\penalty 200}
  
! % @heading, @subheading, @subsubheading.
! \def\heading{\parsearg\plainsecheading}
! \def\subheading{\parsearg\plainsubsecheading}
! \def\subsubheading{\parsearg\plainsubsubsecheading}
  
  % These macros generate a chapter, section, etc. heading only
*************** July\or August\or September\or October\o
*** 2769,2773 ****
  % Parameter controlling skip before chapter headings (if needed)
  
! \newskip \chapheadingskip \chapheadingskip = 30pt plus 8pt minus 4pt
  
  \def\chapbreak{\dobreak \chapheadingskip {-4000}}
--- 3150,3154 ----
  % Parameter controlling skip before chapter headings (if needed)
  
! \newskip\chapheadingskip
  
  \def\chapbreak{\dobreak \chapheadingskip {-4000}}
*************** July\or August\or September\or October\o
*** 2778,2785 ****
--- 3159,3168 ----
  
  \def\CHAPPAGoff{
+ \global\let\contentsalignmacro = \chappager
  \global\let\pchapsepmacro=\chapbreak
  \global\let\pagealignmacro=\chappager}
  
  \def\CHAPPAGon{
+ \global\let\contentsalignmacro = \chappager
  \global\let\pchapsepmacro=\chappager
  \global\let\pagealignmacro=\chappager
*************** July\or August\or September\or October\o
*** 2787,2790 ****
--- 3170,3174 ----
  
  \def\CHAPPAGodd{
+ \global\let\contentsalignmacro = \chapoddpage
  \global\let\pchapsepmacro=\chapoddpage
  \global\let\pagealignmacro=\chapoddpage
*************** July\or August\or September\or October\o
*** 2795,2817 ****
  \def\CHAPFplain{
  \global\let\chapmacro=\chfplain
! \global\let\unnumbchapmacro=\unnchfplain}
  
! \def\chfplain #1#2{%
    \pchapsepmacro
    {%
!     \chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000
!                      \parindent=0pt\raggedright
!                      \rm #2\enspace #1}%
    }%
!   \bigskip
!   \penalty5000
  }
  
! \def\unnchfplain #1{%
! \pchapsepmacro %
! {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000
!                   \parindent=0pt\raggedright
!                   \rm #1\hfill}}\bigskip \par\penalty 10000 %
! }
  \CHAPFplain % The default
  
--- 3179,3215 ----
  \def\CHAPFplain{
  \global\let\chapmacro=\chfplain
! \global\let\unnumbchapmacro=\unnchfplain
! \global\let\centerchapmacro=\centerchfplain}
  
! % Plain chapter opening.
! % #1 is the text, #2 the chapter number or empty if unnumbered.
! \def\chfplain#1#2{%
    \pchapsepmacro
    {%
!     \chapfonts \rm
!     \def\chapnum{#2}%
!     \setbox0 = \hbox{#2\ifx\chapnum\empty\else\enspace\fi}%
!     \vbox{\hyphenpenalty=10000 \tolerance=5000 \parindent=0pt \raggedright
!           \hangindent = \wd0 \centerparametersmaybe
!           \unhbox0 #1\par}%
    }%
!   \nobreak\bigskip % no page break after a chapter title
!   \nobreak
  }
  
! % Plain opening for unnumbered.
! \def\unnchfplain#1{\chfplain{#1}{}}
! 
! % @centerchap -- centered and unnumbered.
! \let\centerparametersmaybe = \relax
! \def\centerchfplain#1{{%
!   \def\centerparametersmaybe{%
!     \advance\rightskip by 3\rightskip
!     \leftskip = \rightskip
!     \parfillskip = 0pt
!   }%
!   \chfplain{#1}{}%
! }}
! 
  \CHAPFplain % The default
  
*************** July\or August\or September\or October\o
*** 2827,2883 ****
  }
  
  \def\CHAPFopen{
  \global\let\chapmacro=\chfopen
! \global\let\unnumbchapmacro=\unnchfopen}
  
- % Parameter controlling skip before section headings.
  
! \newskip \subsecheadingskip  \subsecheadingskip = 17pt plus 8pt minus 4pt
! \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}}
! 
! \newskip \secheadingskip  \secheadingskip = 21pt plus 8pt minus 4pt
  \def\secheadingbreak{\dobreak \secheadingskip {-1000}}
  
! % @paragraphindent  is defined for the Info formatting commands only.
! \let\paragraphindent=\comment
  
! % Section fonts are the base font at magstep2, which produces
! % a size a bit more than 14 points in the default situation.
  
- \def\secheading #1#2#3{\secheadingi {#2.#3\enspace #1}}
- \def\plainsecheading #1{\secheadingi {#1}}
- \def\secheadingi #1{{\advance \secheadingskip by \parskip %
- \secheadingbreak}%
- {\secfonts \vbox{\hyphenpenalty=10000\tolerance=5000
-                  \parindent=0pt\raggedright
-                  \rm #1\hfill}}%
- \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 }
- 
- 
- % Subsection fonts are the base font at magstep1,
- % which produces a size of 12 points.
- 
- \def\subsecheading #1#2#3#4{\subsecheadingi {#2.#3.#4\enspace #1}}
- \def\subsecheadingi #1{{\advance \subsecheadingskip by \parskip %
- \subsecheadingbreak}%
- {\subsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000
-                      \parindent=0pt\raggedright
-                      \rm #1\hfill}}%
- \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 }
- 
- \def\subsubsecfonts{\subsecfonts} % Maybe this should change:
- 				  % Perhaps make sssec fonts scaled
- 				  % magstep half
- \def\subsubsecheading #1#2#3#4#5{\subsubsecheadingi {#2.#3.#4.#5\enspace #1}}
- \def\subsubsecheadingi #1{{\advance \subsecheadingskip by \parskip %
- \subsecheadingbreak}%
- {\subsubsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000
-                        \parindent=0pt\raggedright
-                        \rm #1\hfill}}%
- \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000}
  
  
- \message{toc printing,}
  
  % Finish up the main text and prepare to read what we've written
  % to \contentsfile.
--- 3225,3285 ----
  }
  
+ \def\centerchfopen #1{%
+ \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000
+                        \parindent=0pt
+                        \hfill {\rm #1}\hfill}}\bigskip \par\penalty 10000 %
+ }
+ 
  \def\CHAPFopen{
  \global\let\chapmacro=\chfopen
! \global\let\unnumbchapmacro=\unnchfopen
! \global\let\centerchapmacro=\centerchfopen}
  
  
! % Section titles.
! \newskip\secheadingskip
  \def\secheadingbreak{\dobreak \secheadingskip {-1000}}
+ \def\secheading#1#2#3{\sectionheading{sec}{#2.#3}{#1}}
+ \def\plainsecheading#1{\sectionheading{sec}{}{#1}}
  
! % Subsection titles.
! \newskip \subsecheadingskip
! \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}}
! \def\subsecheading#1#2#3#4{\sectionheading{subsec}{#2.#3.#4}{#1}}
! \def\plainsubsecheading#1{\sectionheading{subsec}{}{#1}}
  
! % Subsubsection titles.
! \let\subsubsecheadingskip = \subsecheadingskip
! \let\subsubsecheadingbreak = \subsecheadingbreak
! \def\subsubsecheading#1#2#3#4#5{\sectionheading{subsubsec}{#2.#3.#4.#5}{#1}}
! \def\plainsubsubsecheading#1{\sectionheading{subsubsec}{}{#1}}
  
  
+ % Print any size section title.
+ %
+ % #1 is the section type (sec/subsec/subsubsec), #2 is the section
+ % number (maybe empty), #3 the text.
+ \def\sectionheading#1#2#3{%
+   {%
+     \expandafter\advance\csname #1headingskip\endcsname by \parskip
+     \csname #1headingbreak\endcsname
+   }%
+   {%
+     % Switch to the right set of fonts.
+     \csname #1fonts\endcsname \rm
+     %
+     % Only insert the separating space if we have a section number.
+     \def\secnum{#2}%
+     \setbox0 = \hbox{#2\ifx\secnum\empty\else\enspace\fi}%
+     %
+     \vbox{\hyphenpenalty=10000 \tolerance=5000 \parindent=0pt \raggedright
+           \hangindent = \wd0 % zero if no section number
+           \unhbox0 #3}%
+   }%
+   \ifdim\parskip<10pt \nobreak\kern10pt\nobreak\kern-\parskip\fi \nobreak
+ }
  
  
+ \message{toc printing,}
  % Finish up the main text and prepare to read what we've written
  % to \contentsfile.
*************** July\or August\or September\or October\o
*** 2885,2899 ****
  \newskip\contentsrightmargin \contentsrightmargin=1in
  \def\startcontents#1{%
!    \pagealignmacro
     \immediate\closeout \contentsfile
     \ifnum \pageno>0
!       \pageno = -1		% Request roman numbered pages.
     \fi
     % Don't need to put `Contents' or `Short Contents' in the headline.
     % It is abundantly clear what they are.
     \unnumbchapmacro{#1}\def\thischapter{}%
!    \begingroup   		% Set up to handle contents files properly.
        \catcode`\\=0  \catcode`\{=1  \catcode`\}=2  \catcode`\@=11
!       \catcode`\^=7 % to see ^^e4 as \"a etc. juha@piuha.ydi.vtt.fi
        \raggedbottom             % Worry more about breakpoints than the bottom.
        \advance\hsize by -\contentsrightmargin % Don't use the full line length.
--- 3287,3307 ----
  \newskip\contentsrightmargin \contentsrightmargin=1in
  \def\startcontents#1{%
!    % If @setchapternewpage on, and @headings double, the contents should
!    % start on an odd page, unlike chapters.  Thus, we maintain
!    % \contentsalignmacro in parallel with \pagealignmacro.
!    % From: Torbjorn Granlund <tege@matematik.su.se>
!    \contentsalignmacro
     \immediate\closeout \contentsfile
     \ifnum \pageno>0
!       \pageno = -1              % Request roman numbered pages.
     \fi
     % Don't need to put `Contents' or `Short Contents' in the headline.
     % It is abundantly clear what they are.
     \unnumbchapmacro{#1}\def\thischapter{}%
!    \begingroup                  % Set up to handle contents files properly.
        \catcode`\\=0  \catcode`\{=1  \catcode`\}=2  \catcode`\@=11
!       % We can't do this, because then an actual ^ in a section
!       % title fails, e.g., @chapter ^ -- exponentiation.  --karl, 9jul97.
!       %\catcode`\^=7 % to see ^^e4 as \"a etc. juha@piuha.ydi.vtt.fi
        \raggedbottom             % Worry more about breakpoints than the bottom.
        \advance\hsize by -\contentsrightmargin % Don't use the full line length.
*************** July\or August\or September\or October\o
*** 2919,2922 ****
--- 3327,3331 ----
        \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl
        \rm
+       \hyphenpenalty = 10000
        \advance\baselineskip by 1pt % Open it up a little.
        \def\secentry ##1##2##3##4{}
*************** July\or August\or September\or October\o
*** 2962,2966 ****
    % widest letter (M) is 1em, at least in the Computer Modern fonts.
    % (This space doesn't include the extra space that gets added after
!   % the label; that gets put in in \shortchapentry above.)
    \advance\dimen0 by 1.1em
    \hbox to \dimen0{#1\hfil}%
--- 3371,3375 ----
    % widest letter (M) is 1em, at least in the Computer Modern fonts.
    % (This space doesn't include the extra space that gets added after
!   % the label; that gets put in by \shortchapentry above.)
    \advance\dimen0 by 1.1em
    \hbox to \dimen0{#1\hfil}%
*************** July\or August\or September\or October\o
*** 2983,2987 ****
  \def\unnumbsubsubsecentry#1#2{\dosubsubsecentry{#1}{#2}}
  
- 
  % This parameter controls the indentation of the various levels.
  \newdimen\tocindent \tocindent = 3pc
--- 3392,3395 ----
*************** July\or August\or September\or October\o
*** 2990,3002 ****
  % page number.
  %
! % If the toc has to be broken over pages, we would want to be at chapters
  % if at all possible; hence the \penalty.
  \def\dochapentry#1#2{%
!    \penalty-300 \vskip\baselineskip
     \begingroup
       \chapentryfonts
       \tocentry{#1}{\dopageno{#2}}%
     \endgroup
!    \nobreak\vskip .25\baselineskip
  }
  
--- 3398,3410 ----
  % page number.
  %
! % If the toc has to be broken over pages, we want it to be at chapters
  % if at all possible; hence the \penalty.
  \def\dochapentry#1#2{%
!    \penalty-300 \vskip1\baselineskip plus.33\baselineskip minus.25\baselineskip
     \begingroup
       \chapentryfonts
       \tocentry{#1}{\dopageno{#2}}%
     \endgroup
!    \nobreak\vskip .25\baselineskip plus.1\baselineskip
  }
  
*************** July\or August\or September\or October\o
*** 3023,3027 ****
  % \turnoffactive is for the sake of @" used for umlauts.
  \def\tocentry#1#2{\begingroup
!   \hyphenpenalty = 10000
    \entry{\turnoffactive #1}{\turnoffactive #2}%
  \endgroup}
--- 3431,3435 ----
  % \turnoffactive is for the sake of @" used for umlauts.
  \def\tocentry#1#2{\begingroup
!   \vskip 0pt plus1pt % allow a little stretch for the sake of nice page breaks
    \entry{\turnoffactive #1}{\turnoffactive #2}%
  \endgroup}
*************** July\or August\or September\or October\o
*** 3048,3053 ****
  \newbox\equivbox       \newbox\errorbox
  
- \let\ptexequiv = \equiv
- 
  %{\tentt
  %\global\setbox\dblarrowbox = \hbox to 1em{\hfil$\Rightarrow$\hfil}
--- 3456,3459 ----
*************** July\or August\or September\or October\o
*** 3060,3069 ****
  %}
  
  \def\point{$\star$}
- 
  \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}}
  \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}}
  \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}}
- 
  \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}}
  
--- 3466,3474 ----
  %}
  
+ % @point{}, @result{}, @expansion{}, @print{}, @equiv{}.
  \def\point{$\star$}
  \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}}
  \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}}
  \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}}
  \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}}
  
*************** July\or August\or September\or October\o
*** 3097,3101 ****
  \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie
  \catcode `\%=14
! \catcode 43=12
  \catcode`\"=12
  \catcode`\==12
--- 3502,3506 ----
  \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie
  \catcode `\%=14
! \catcode 43=12 % plus
  \catcode`\"=12
  \catcode`\==12
*************** July\or August\or September\or October\o
*** 3105,3109 ****
  \escapechar=`\\
  %
! \let\~=\ptextilde
  \let\{=\ptexlbrace
  \let\}=\ptexrbrace
--- 3510,3514 ----
  \escapechar=`\\
  %
! \let\,=\ptexcomma
  \let\{=\ptexlbrace
  \let\}=\ptexrbrace
*************** July\or August\or September\or October\o
*** 3111,3118 ****
  \let\*=\ptexstar
  \let\dots=\ptexdots
  \def\@{@}%
  \let\bullet=\ptexbullet
! \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext \let\l=\ptexl
! \let\L=\ptexL
  %
  \let\Etex=\endgroup}
--- 3516,3524 ----
  \let\*=\ptexstar
  \let\dots=\ptexdots
+ \def\endldots{\mathinner{\ldots\ldots\ldots\ldots}}%
+ \def\enddots{\relax\ifmmode\endldots\else$\mathsurround=0pt \endldots\,$\fi}%
  \def\@{@}%
  \let\bullet=\ptexbullet
! \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext
  %
  \let\Etex=\endgroup}
*************** July\or August\or September\or October\o
*** 3173,3181 ****
  \def\cbr{{\hskip 6pt\circle\char'011}}
  \def\carttop{\hbox to \cartouter{\hskip\lskip
! 	\ctl\leaders\hrule height\circthick\hfil\ctr
! 	\hskip\rskip}}
  \def\cartbot{\hbox to \cartouter{\hskip\lskip
! 	\cbl\leaders\hrule height\circthick\hfil\cbr
! 	\hskip\rskip}}
  %
  \newskip\lskip\newskip\rskip
--- 3579,3587 ----
  \def\cbr{{\hskip 6pt\circle\char'011}}
  \def\carttop{\hbox to \cartouter{\hskip\lskip
!         \ctl\leaders\hrule height\circthick\hfil\ctr
!         \hskip\rskip}}
  \def\cartbot{\hbox to \cartouter{\hskip\lskip
!         \cbl\leaders\hrule height\circthick\hfil\cbr
!         \hskip\rskip}}
  %
  \newskip\lskip\newskip\rskip
*************** July\or August\or September\or October\o
*** 3183,3220 ****
  \long\def\cartouche{%
  \begingroup
! 	\lskip=\leftskip \rskip=\rightskip
! 	\leftskip=0pt\rightskip=0pt %we want these *outside*.
! 	\cartinner=\hsize \advance\cartinner by-\lskip
! 		 	  \advance\cartinner by-\rskip
! 	\cartouter=\hsize
! 	\advance\cartouter by 18pt % allow for 3pt kerns on either
! %				     side, and for 6pt waste from
! %				     each corner char
! 	\normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip
! 	% Flag to tell @lisp, etc., not to narrow margin.
! 	\let\nonarrowing=\comment
! 	\vbox\bgroup
! 		\baselineskip=0pt\parskip=0pt\lineskip=0pt
! 		\carttop
! 		\hbox\bgroup
! 			\hskip\lskip
! 			\vrule\kern3pt
! 			\vbox\bgroup
! 				\hsize=\cartinner
! 				\kern3pt
! 				\begingroup
! 					\baselineskip=\normbskip
! 					\lineskip=\normlskip
! 					\parskip=\normpskip
! 					\vskip -\parskip
  \def\Ecartouche{%
! 				\endgroup
! 				\kern3pt
! 			\egroup
! 			\kern3pt\vrule
! 			\hskip\rskip
! 		\egroup
! 		\cartbot
! 	\egroup
  \endgroup
  }}
--- 3589,3626 ----
  \long\def\cartouche{%
  \begingroup
!         \lskip=\leftskip \rskip=\rightskip
!         \leftskip=0pt\rightskip=0pt %we want these *outside*.
!         \cartinner=\hsize \advance\cartinner by-\lskip
!                           \advance\cartinner by-\rskip
!         \cartouter=\hsize
!         \advance\cartouter by 18pt % allow for 3pt kerns on either
! %                                    side, and for 6pt waste from
! %                                    each corner char
!         \normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip
!         % Flag to tell @lisp, etc., not to narrow margin.
!         \let\nonarrowing=\comment
!         \vbox\bgroup
!                 \baselineskip=0pt\parskip=0pt\lineskip=0pt
!                 \carttop
!                 \hbox\bgroup
!                         \hskip\lskip
!                         \vrule\kern3pt
!                         \vbox\bgroup
!                                 \hsize=\cartinner
!                                 \kern3pt
!                                 \begingroup
!                                         \baselineskip=\normbskip
!                                         \lineskip=\normlskip
!                                         \parskip=\normpskip
!                                         \vskip -\parskip
  \def\Ecartouche{%
!                                 \endgroup
!                                 \kern3pt
!                         \egroup
!                         \kern3pt\vrule
!                         \hskip\rskip
!                 \egroup
!                 \cartbot
!         \egroup
  \endgroup
  }}
*************** July\or August\or September\or October\o
*** 3252,3260 ****
  \def\nonfillfinish{\afterenvbreak\endgroup}%
  
- % This macro is
  \def\lisp{\begingroup
    \nonfillstart
    \let\Elisp = \nonfillfinish
    \tt
    \rawbackslash % have \ input char produce \ char from current font
    \gobble
--- 3658,3667 ----
  \def\nonfillfinish{\afterenvbreak\endgroup}%
  
  \def\lisp{\begingroup
    \nonfillstart
    \let\Elisp = \nonfillfinish
    \tt
+   % Make @kbd do something special, if requested.
+   \let\kbdfont\kbdexamplefont
    \rawbackslash % have \ input char produce \ char from current font
    \gobble
*************** July\or August\or September\or October\o
*** 3279,3284 ****
    \let\Esmallexample = \nonfillfinish
    %
!   % Smaller interline space and fonts for small examples.
!   \setleading{10pt}%
    \indexfonts \tt
    \rawbackslash % make \ output the \ character from the current font (tt)
--- 3686,3690 ----
    \let\Esmallexample = \nonfillfinish
    %
!   % Smaller fonts for small examples.
    \indexfonts \tt
    \rawbackslash % make \ output the \ character from the current font (tt)
*************** July\or August\or September\or October\o
*** 3375,3380 ****
  % Definitions of (, ) and & used in args for functions.
  % This is the definition of ( outside of all parentheses.
! \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested %
! \global\advance\parencount by 1 }
  %
  % This is the definition of ( when already inside a level of parens.
--- 3781,3787 ----
  % Definitions of (, ) and & used in args for functions.
  % This is the definition of ( outside of all parentheses.
! \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested
!   \global\advance\parencount by 1
! }
  %
  % This is the definition of ( when already inside a level of parens.
*************** July\or August\or September\or October\o
*** 3382,3388 ****
  %
  \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0.
! % also in that case restore the outer-level definition of (.
! \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi
! \global\advance \parencount by -1 }
  % If we encounter &foo, then turn on ()-hacking afterwards
  \gdef\amprm#1 {{\rm\&#1}\let(=\oprm \let)=\clrm\ }
--- 3789,3795 ----
  %
  \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0.
!   % also in that case restore the outer-level definition of (.
!   \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi
!   \global\advance \parencount by -1 }
  % If we encounter &foo, then turn on ()-hacking afterwards
  \gdef\amprm#1 {{\rm\&#1}\let(=\oprm \let)=\clrm\ }
*************** July\or August\or September\or October\o
*** 3392,3397 ****
  %% These parens (in \boldbrax) actually are a little bolder than the
  %% contained text.  This is especially needed for [ and ]
! \def\opnr{{\sf\char`\(}} \def\clnr{{\sf\char`\)}} \def\ampnr{\&}
! \def\lbrb{{\bf\char`\[}} \def\rbrb{{\bf\char`\]}}
  
  % First, defname, which formats the header line itself.
--- 3799,3807 ----
  %% These parens (in \boldbrax) actually are a little bolder than the
  %% contained text.  This is especially needed for [ and ]
! \def\opnr{{\sf\char`\(}\global\advance\parencount by 1 }
! \def\clnr{{\sf\char`\)}\global\advance\parencount by -1 }
! \def\ampnr{\&}
! \def\lbrb{{\bf\char`\[}}
! \def\rbrb{{\bf\char`\]}}
  
  % First, defname, which formats the header line itself.
*************** July\or August\or September\or October\o
*** 3486,3490 ****
  % This is used for \def{tp,vr}parsebody.  It could probably be used for
  % some of the others, too, with some judicious conditionals.
! % 
  \def\parsebodycommon#1#2#3{%
    \begingroup\inENV %
--- 3896,3900 ----
  % This is used for \def{tp,vr}parsebody.  It could probably be used for
  % some of the others, too, with some judicious conditionals.
! %
  \def\parsebodycommon#1#2#3{%
    \begingroup\inENV %
*************** July\or August\or September\or October\o
*** 3520,3534 ****
  
  % Fine, but then we have to eventually remove the \empty *and* the
! % braces (if any).  That's what this does, putting the result in \tptemp.
! % 
! \def\removeemptybraces\empty#1\relax{\def\tptemp{#1}}%
  
  % After \spacesplit has done its work, this is called -- #1 is the final
  % thing to call, #2 the type name (which starts with \empty), and #3
  % (which might be empty) the arguments.
! % 
  \def\parsetpheaderline#1#2#3{%
!   \removeemptybraces#2\relax
!   #1{\tptemp}{#3}%
  }%
  
--- 3930,3943 ----
  
  % Fine, but then we have to eventually remove the \empty *and* the
! % braces (if any).  That's what this does.
! %
! \def\removeemptybraces\empty#1\relax{#1}
  
  % After \spacesplit has done its work, this is called -- #1 is the final
  % thing to call, #2 the type name (which starts with \empty), and #3
  % (which might be empty) the arguments.
! %
  \def\parsetpheaderline#1#2#3{%
!   #1{\removeemptybraces#2\relax}{#3}%
  }%
  
*************** July\or August\or September\or October\o
*** 3571,3575 ****
  #1%
  \hyphenchar\tensl=45
! \ifnum\parencount=0 \else \errmessage{unbalanced parens in @def arguments}\fi%
  \interlinepenalty=10000
  \advance\rightskip by 0pt plus 1fil
--- 3980,3984 ----
  #1%
  \hyphenchar\tensl=45
! \ifnum\parencount=0 \else \errmessage{Unbalanced parentheses in @def}\fi%
  \interlinepenalty=10000
  \advance\rightskip by 0pt plus 1fil
*************** July\or August\or September\or October\o
*** 3672,3675 ****
--- 4081,4085 ----
  \def\defspecx #1 {\errmessage{@defspecx in invalid context}}
  \def\deftypefnx #1 {\errmessage{@deftypefnx in invalid context}}
+ \def\deftypemethodx #1 {\errmessage{@deftypemethodx in invalid context}}
  \def\deftypeunx #1 {\errmessage{@deftypeunx in invalid context}}
  
*************** July\or August\or September\or October\o
*** 3687,3690 ****
--- 4097,4110 ----
  }
  
+ % @deftypemethod foo-class return-type foo-method args
+ %
+ \def\deftypemethod{%
+   \defmethparsebody\Edeftypemethod\deftypemethodx\deftypemethodheader}
+ %
+ % #1 is the class name, #2 the data type, #3 the method name, #4 the args.
+ \def\deftypemethodheader#1#2#3#4{%
+   \deftypefnheaderx{Method on #1}{#2}#3 #4\relax
+ }
+ 
  % @defmethod == @defop Method
  
*************** July\or August\or September\or October\o
*** 3764,3774 ****
  \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader}
  
! % #1 is the data type.  #2 is the name.
  \def\deftypevarheader #1#2{%
! \doind {vr}{\code{#2}}% Make entry in variables index
  \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Variable}%
  \interlinepenalty=10000
  \endgraf\penalty 10000\vskip -\parskip\penalty 10000
  \endgroup}
  
  % @deftypevr {Global Flag} int enable
--- 4184,4196 ----
  \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader}
  
! % #1 is the data type.  #2 is the name, perhaps followed by text that
! % is actually part of the data type, which should not be put into the index.
  \def\deftypevarheader #1#2{%
! \dovarind#2 \relax% Make entry in variables index
  \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Variable}%
  \interlinepenalty=10000
  \endgraf\penalty 10000\vskip -\parskip\penalty 10000
  \endgroup}
+ \def\dovarind#1 #2\relax{\doind{vr}{\code{#1}}}
  
  % @deftypevr {Global Flag} int enable
*************** July\or August\or September\or October\o
*** 3776,3780 ****
  \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader}
  
! \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}%
  \begingroup\defname {\defheaderxcond#2\relax$$$#3}{#1}
  \interlinepenalty=10000
--- 4198,4202 ----
  \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader}
  
! \def\deftypevrheader #1#2#3{\dovarind#3 \relax%
  \begingroup\defname {\defheaderxcond#2\relax$$$#3}{#1}
  \interlinepenalty=10000
*************** July\or August\or September\or October\o
*** 3808,3811 ****
--- 4230,4234 ----
  \def\deftpx #1 {\errmessage{@deftpx in invalid context}}
  
+ 
  \message{cross reference,}
  % Define cross-reference macros
*************** July\or August\or September\or October\o
*** 3815,3818 ****
--- 4238,4246 ----
  \newif\ifwarnedxrefs  % True if we warned once that they aren't known.
  
+ % @inforef is simple.
+ \def\inforef #1{\inforefzzz #1,,,,**}
+ \def\inforefzzz #1,#2,#3,#4**{\putwordSee{} \putwordInfo{} \putwordfile{} \file{\ignorespaces #3{}},
+   node \samp{\ignorespaces#1{}}}
+ 
  % \setref{foo} defines a cross-reference point named foo.
  
*************** July\or August\or September\or October\o
*** 3848,3852 ****
    \ifdim \wd0 = 0pt
      % No printed node name was explicitly given.
!     \ifx\SETxref-automatic-section-title\thisisundefined
        % Use the node name inside the square brackets.
        \def\printednodename{\ignorespaces #1}%
--- 4276,4280 ----
    \ifdim \wd0 = 0pt
      % No printed node name was explicitly given.
!     \expandafter\ifx\csname SETxref-automatic-section-title\endcsname\relax
        % Use the node name inside the square brackets.
        \def\printednodename{\ignorespaces #1}%
*************** July\or August\or September\or October\o
*** 3893,3897 ****
  % Use \turnoffactive so that punctuation chars such as underscore
  % work in node names.
! \def\dosetq #1#2{{\let\folio=0 \turnoffactive \auxhat%
  \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}%
  \next}}
--- 4321,4325 ----
  % Use \turnoffactive so that punctuation chars such as underscore
  % work in node names.
! \def\dosetq #1#2{{\let\folio=0 \turnoffactive
  \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}%
  \next}}
*************** July\or August\or September\or October\o
*** 3962,4043 ****
  }
  
- % Read the last existing aux file, if any.  No error if none exists.
- 
  % This is the macro invoked by entries in the aux file.
! \def\xrdef #1#2{
! {\catcode`\'=\other\expandafter \gdef \csname X#1\endcsname {#2}}}
  
! \def\readauxfile{%
! \begingroup
! \catcode `\^^@=\other
! \catcode `\
=\other
! \catcode `\=\other
! \catcode `\^^C=\other
! \catcode `\^^D=\other
! \catcode `\^^E=\other
! \catcode `\^^F=\other
! \catcode `\^^G=\other
! \catcode `\^^H=\other
! \catcode `\=\other
! \catcode `\^^L=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode `\=\other
! \catcode 26=\other
! \catcode `\^^[=\other
! \catcode `\^^\=\other
! \catcode `\^^]=\other
! \catcode `\^^^=\other
! \catcode `\^^_=\other
! \catcode `\@=\other
! \catcode `\^=\other
! \catcode `\~=\other
! \catcode `\[=\other
! \catcode `\]=\other
! \catcode`\"=\other
! \catcode`\_=\other
! \catcode`\|=\other
! \catcode`\<=\other
! \catcode`\>=\other
! \catcode `\$=\other
! \catcode `\#=\other
! \catcode `\&=\other
! % `\+ does not work, so use 43.
! \catcode 43=\other
! % Make the characters 128-255 be printing characters
! {%
!   \count 1=128
!   \def\loop{%
!     \catcode\count 1=\other
!     \advance\count 1 by 1
!     \ifnum \count 1<256 \loop \fi
    }%
! }%
! % the aux file uses ' as the escape.
! % Turn off \ as an escape so we do not lose on
! % entries which were dumped with control sequences in their names.
! % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^
! % Reference to such entries still does not work the way one would wish,
! % but at least they do not bomb out when the aux file is read in.
! \catcode `\{=1 \catcode `\}=2
! \catcode `\%=\other
! \catcode `\'=0
! \catcode`\^=7 % to make ^^e4 etc usable in xref tags 
! \catcode `\\=\other
! \openin 1 \jobname.aux
! \ifeof 1 \else \closein 1 \input \jobname.aux \global\havexrefstrue
! \global\warnedobstrue
! \fi
! % Open the new aux file.  Tex will close it automatically at exit.
! \openout \auxfile=\jobname.aux
  \endgroup}
  
--- 4390,4486 ----
  }
  
  % This is the macro invoked by entries in the aux file.
! \def\xrdef #1#2{{%
!   \catcode`\'=\other
!   \expandafter\gdef\csname X#1\endcsname{#2}%
! }}
  
! % Read the last existing aux file, if any.  No error if none exists.
! \def\readauxfile{\begingroup
!   \catcode`\^^@=\other
!   \catcode`\^^A=\other
!   \catcode`\^^B=\other
!   \catcode`\^^C=\other
!   \catcode`\^^D=\other
!   \catcode`\^^E=\other
!   \catcode`\^^F=\other
!   \catcode`\^^G=\other
!   \catcode`\^^H=\other
!   \catcode`\^^K=\other
!   \catcode`\^^L=\other
!   \catcode`\^^N=\other
!   \catcode`\^^P=\other
!   \catcode`\^^Q=\other
!   \catcode`\^^R=\other
!   \catcode`\^^S=\other
!   \catcode`\^^T=\other
!   \catcode`\^^U=\other
!   \catcode`\^^V=\other
!   \catcode`\^^W=\other
!   \catcode`\^^X=\other
!   \catcode`\^^Z=\other
!   \catcode`\^^[=\other
!   \catcode`\^^\=\other
!   \catcode`\^^]=\other
!   \catcode`\^^^=\other
!   \catcode`\^^_=\other
!   \catcode`\@=\other
!   \catcode`\^=\other
!   % It was suggested to define this as 7, which would allow ^^e4 etc.
!   % in xref tags, i.e., node names.  But since ^^e4 notation isn't
!   % supported in the main text, it doesn't seem desirable.  Furthermore,
!   % that is not enough: for node names that actually contain a ^
!   % character, we would end up writing a line like this: 'xrdef {'hat
!   % b-title}{'hat b} and \xrdef does a \csname...\endcsname on the first
!   % argument, and \hat is not an expandable control sequence.  It could
!   % all be worked out, but why?  Either we support ^^ or we don't.
!   %
!   % The other change necessary for this was to define \auxhat:
!   % \def\auxhat{\def^{'hat }}% extra space so ok if followed by letter
!   % and then to call \auxhat in \setq.
!   %
!   \catcode`\~=\other
!   \catcode`\[=\other
!   \catcode`\]=\other
!   \catcode`\"=\other
!   \catcode`\_=\other
!   \catcode`\|=\other
!   \catcode`\<=\other
!   \catcode`\>=\other
!   \catcode`\$=\other
!   \catcode`\#=\other
!   \catcode`\&=\other
!   % `\+ does not work, so use 43.
!   \catcode43=\other
!   % Make the characters 128-255 be printing characters
!   {%
!     \count 1=128
!     \def\loop{%
!       \catcode\count 1=\other
!       \advance\count 1 by 1
!       \ifnum \count 1<256 \loop \fi
!     }%
    }%
!   % The aux file uses ' as the escape (for now).
!   % Turn off \ as an escape so we do not lose on
!   % entries which were dumped with control sequences in their names.
!   % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^
!   % Reference to such entries still does not work the way one would wish,
!   % but at least they do not bomb out when the aux file is read in.
!   \catcode`\{=1
!   \catcode`\}=2
!   \catcode`\%=\other
!   \catcode`\'=0
!   \catcode`\\=\other
!   %
!   \openin 1 \jobname.aux
!   \ifeof 1 \else
!     \closein 1
!     \input \jobname.aux
!     \global\havexrefstrue
!     \global\warnedobstrue
!   \fi
!   % Open the new aux file.  TeX will close it automatically at exit.
!   \openout\auxfile=\jobname.aux
  \endgroup}
  
*************** July\or August\or September\or October\o
*** 4050,4057 ****
  % vital for proper filling; pages come out unaligned when you do a
  % pagealignmacro call if that space before the closing brace is
! % removed.
  \def\supereject{\par\penalty -20000\footnoteno =0 }
  
! % @footnotestyle is meaningful for info output only..
  \let\footnotestyle=\comment
  
--- 4493,4501 ----
  % vital for proper filling; pages come out unaligned when you do a
  % pagealignmacro call if that space before the closing brace is
! % removed. (Generally, numeric constants should always be followed by a
! % space to prevent strange expansion errors.)
  \def\supereject{\par\penalty -20000\footnoteno =0 }
  
! % @footnotestyle is meaningful for info output only.
  \let\footnotestyle=\comment
  
*************** July\or August\or September\or October\o
*** 4079,4083 ****
  % footnote text as a parameter.  Our footnotes don't need to be so general.
  %
! \long\gdef\footnotezzz#1{\insert\footins{%
    % We want to typeset this text as a normal paragraph, even if the
    % footnote reference occurs in (for example) a display environment.
--- 4523,4531 ----
  % footnote text as a parameter.  Our footnotes don't need to be so general.
  %
! % Oh yes, they do; otherwise, @ifset and anything else that uses
! % \parseargline fail inside footnotes because the tokens are fixed when
! % the footnote is read.  --karl, 16nov96.
! %
! \long\gdef\footnotezzz{\insert\footins\bgroup
    % We want to typeset this text as a normal paragraph, even if the
    % footnote reference occurs in (for example) a display environment.
*************** July\or August\or September\or October\o
*** 4101,4106 ****
    % provide a place where TeX can split the footnote.
    \footstrut
!   #1\strut}%
  }
  
  }%end \catcode `\@=11
--- 4549,4559 ----
    % provide a place where TeX can split the footnote.
    \footstrut
!   \futurelet\next\fo@t
  }
+ \def\fo@t{\ifcat\bgroup\noexpand\next \let\next\f@@t
+   \else\let\next\f@t\fi \next}
+ \def\f@@t{\bgroup\aftergroup\@foot\let\next}
+ \def\f@t#1{#1\@foot}
+ \def\@foot{\strut\egroup}
  
  }%end \catcode `\@=11
*************** July\or August\or September\or October\o
*** 4159,4165 ****
--- 4612,4660 ----
  \def\finalout{\overfullrule=0pt}
  
+ % @image.  We use the macros from epsf.tex to support this.
+ % If epsf.tex is not installed and @image is used, we complain.
+ % 
+ % Check for and read epsf.tex up front.  If we read it only at @image
+ % time, we might be inside a group, and then its definitions would get
+ % undone and the next image would fail.
+ \openin 1 = epsf.tex
+ \ifeof 1 \else
+   \closein 1
+   \def\epsfannounce{\toks0 = }% do not bother showing banner
+   \input epsf.tex
+ \fi
+ %
+ \newif\ifwarnednoepsf
+ \newhelp\noepsfhelp{epsf.tex must be installed for images to
+   work.  It is also included in the Texinfo distribution, or you can get
+   it from ftp://ftp.tug.org/tex/epsf.tex.}
+ %
+ % Only complain once about lack of epsf.tex.
+ \def\image#1{%
+   \ifx\epsfbox\undefined
+     \ifwarnednoepsf \else
+       \errhelp = \noepsfhelp
+       \errmessage{epsf.tex not found, images will be ignored}%
+       \global\warnednoepsftrue
+     \fi
+   \else
+     \imagexxx #1,,,\finish
+   \fi
+ }
+ %
+ % Arguments to @image:
+ % #1 is (mandatory) image filename; we tack on .eps extension.
+ % #2 is (optional) width, #3 is (optional) height.
+ % #4 is just the usual extra ignored arg for parsing this stuff.
+ \def\imagexxx#1,#2,#3,#4\finish{%
+   % \epsfbox itself resets \epsf?size at each figure.
+   \setbox0 = \hbox{\ignorespaces #2}\ifdim\wd0 > 0pt \epsfxsize=#2\relax \fi
+   \setbox0 = \hbox{\ignorespaces #3}\ifdim\wd0 > 0pt \epsfysize=#3\relax \fi
+   \epsfbox{#1.eps}%
+ }
  
  % End of control word definitions.
  
+ 
  \message{and turning on texinfo input format.}
  
*************** July\or August\or September\or October\o
*** 4175,4185 ****
  % Set some numeric style parameters, for 8.5 x 11 format.
  
! %\hsize = 6.5in
  \newdimen\defaultparindent \defaultparindent = 15pt
  \parindent = \defaultparindent
! \parskip 18pt plus 1pt
! \setleading{15pt}
  \advance\topskip by 1.2cm
  
  % Prevent underfull vbox error messages.
  \vbadness=10000
--- 4670,4685 ----
  % Set some numeric style parameters, for 8.5 x 11 format.
  
! \hsize = 6in
! \hoffset = .25in
  \newdimen\defaultparindent \defaultparindent = 15pt
  \parindent = \defaultparindent
! \parskip 3pt plus 2pt minus 1pt
! \setleading{13.2pt}
  \advance\topskip by 1.2cm
  
+ \chapheadingskip = 15pt plus 4pt minus 2pt
+ \secheadingskip = 12pt plus 3pt minus 2pt
+ \subsecheadingskip = 9pt plus 2pt minus 2pt
+ 
  % Prevent underfull vbox error messages.
  \vbadness=10000
*************** July\or August\or September\or October\o
*** 4204,4231 ****
  % Use @smallbook to reset parameters for 7x9.5 format  (or else 7x9.25)
  \def\smallbook{
! 
! % These values for secheadingskip and subsecheadingskip are
! % experiments.  RJC 7 Aug 1992
! \global\secheadingskip = 17pt plus 6pt minus 3pt
! \global\subsecheadingskip = 14pt plus 6pt minus 3pt
! 
! \global\lispnarrowing = 0.3in
! \setleading{12pt}
! \advance\topskip by -1cm
! \global\parskip 3pt plus 1pt
! \global\hsize = 5in
! \global\vsize=7.5in
! \global\tolerance=700
! \global\hfuzz=1pt
! \global\contentsrightmargin=0pt
! \global\deftypemargin=0pt
! \global\defbodyindent=.5cm
! 
! \global\pagewidth=\hsize
! \global\pageheight=\vsize
! 
! \global\let\smalllisp=\smalllispx
! \global\let\smallexample=\smalllispx
! \global\def\Esmallexample{\Esmalllisp}
  }
  
--- 4704,4729 ----
  % Use @smallbook to reset parameters for 7x9.5 format  (or else 7x9.25)
  \def\smallbook{
!   \global\chapheadingskip = 15pt plus 4pt minus 2pt
!   \global\secheadingskip = 12pt plus 3pt minus 2pt
!   \global\subsecheadingskip = 9pt plus 2pt minus 2pt
!   %
!   \global\lispnarrowing = 0.3in
!   \setleading{12pt}
!   \advance\topskip by -1cm
!   \global\parskip 2pt plus 1pt
!   \global\hsize = 5in
!   \global\vsize=7.5in
!   \global\tolerance=700
!   \global\hfuzz=1pt
!   \global\contentsrightmargin=0pt
!   \global\deftypemargin=0pt
!   \global\defbodyindent=.5cm
!   %
!   \global\pagewidth=\hsize
!   \global\pageheight=\vsize
!   %
!   \global\let\smalllisp=\smalllispx
!   \global\let\smallexample=\smalllispx
!   \global\def\Esmallexample{\Esmalllisp}
  }
  
*************** July\or August\or September\or October\o
*** 4250,4259 ****
  }
  
  % Allow control of the text dimensions.  Parameters in order: textheight;
! % textwidth; \voffset; \hoffset (!); binding offset.  All require a dimension;
  % header is additional; added length extends the bottom of the page.
  
! \def\changepagesizes#1#2#3#4#5{
   \global\vsize= #1
   \advance\vsize by \topskip
   \global\voffset= #3
--- 4748,4764 ----
  }
  
+ \bindingoffset=0pt
+ \normaloffset=\hoffset
+ \pagewidth=\hsize
+ \pageheight=\vsize
+ 
  % Allow control of the text dimensions.  Parameters in order: textheight;
! % textwidth; voffset; hoffset; binding offset; topskip.
! % All require a dimension;
  % header is additional; added length extends the bottom of the page.
  
! \def\changepagesizes#1#2#3#4#5#6{
   \global\vsize= #1
+  \global\topskip= #6
   \advance\vsize by \topskip
   \global\voffset= #3
*************** July\or August\or September\or October\o
*** 4268,4278 ****
   \global\bindingoffset= #5}
  
! % This layout is compatible with Latex on A4 paper.
! 
! \def\afourlatex{\changepagesizes{22cm}{15cm}{7mm}{4.6mm}{5mm}}
  
  % Use @afourwide to print on European A4 paper in wide format.
  \def\afourwide{\afourpaper
! \changepagesizes{9.5in}{6.5in}{\hoffset}{\normaloffset}{\bindingoffset}}
  
  % Define macros to output various characters with catcode for normal text.
--- 4773,4790 ----
   \global\bindingoffset= #5}
  
! % A specific text layout, 24x15cm overall, intended for A4 paper.  Top margin
! % 29mm, hence bottom margin 28mm, nominal side margin 3cm.
! \def\afourlatex
!         {\global\tolerance=700
!         \global\hfuzz=1pt
!         \setleading{12pt}
!         \global\parskip 15pt plus 1pt
!         \advance\baselineskip by 1.6pt
!         \changepagesizes{237mm}{150mm}{3.6mm}{3.6mm}{3mm}{7mm}
!         }
  
  % Use @afourwide to print on European A4 paper in wide format.
  \def\afourwide{\afourpaper
! \changepagesizes{9.5in}{6.5in}{\hoffset}{\normaloffset}{\bindingoffset}{7mm}}
  
  % Define macros to output various characters with catcode for normal text.
*************** July\or August\or September\or October\o
*** 4317,4321 ****
  \chardef\hat=`\^
  \catcode`\^=\active
- \def\auxhat{\def^{'hat}}
  \def^{{\tt \hat}}
  
--- 4829,4832 ----
*************** July\or August\or September\or October\o
*** 4323,4334 ****
  \def_{\ifusingtt\normalunderscore\_}
  % Subroutine for the previous macro.
! \def\_{\lvvmode \kern.06em \vbox{\hrule width.3em height.1ex}}
! 
! % \lvvmode is equivalent in function to \leavevmode.
! % Using \leavevmode runs into trouble when written out to
! % an index file due to the expansion of \leavevmode into ``\unhbox
! % \voidb@x'' ---which looks to TeX like ``\unhbox \voidb\x'' due to our
! % magic tricks with @.
! \def\lvvmode{\vbox to 0pt{}}
  
  \catcode`\|=\active
--- 4834,4838 ----
  \def_{\ifusingtt\normalunderscore\_}
  % Subroutine for the previous macro.
! \def\_{\leavevmode \kern.06em \vbox{\hrule width.3em height.1ex}}
  
  \catcode`\|=\active
diff -rcp2N gcc-2.7.2.3/tm.texi gcc-2.7.2.3.f.2/tm.texi
*** gcc-2.7.2.3/tm.texi	Sun Sep  3 12:59:01 1995
--- gcc-2.7.2.3.f.2/tm.texi	Tue Sep  9 07:01:47 1997
*************** This describes the stack layout and call
*** 1951,1954 ****
--- 1951,1955 ----
  @menu
  * Frame Layout::
+ * Stack Checking::
  * Frame Registers::
  * Elimination::			
*************** This discusses registers that address th
*** 2070,2073 ****
--- 2071,2156 ----
  @table @code
  @findex STACK_POINTER_REGNUM
+ @end table
+ 
+ @node Stack Checking
+ @subsection Specifying How Stack Checking is Done
+ 
+ GNU CC will check that stack references are within the boundaries of
+ the stack, if the @samp{-fstack-check} is specified, in one of three ways:
+ 
+ @enumerate
+ @item
+ If the value of the @code{STACK_CHECK_BUILTIN} macro is nonzero, GNU CC
+ will assume that you have arranged for stack checking to be done at
+ appropriate places in the configuration files, e.g., in
+ @code{FUNCTION_PROLOGUE}.  GNU CC will do not other special processing.
+ 
+ @item
+ If @code{STACK_CHECK_BUILTIN} is zero and you defined a named pattern
+ called @code{check_stack} in your @file{md} file, GNU CC will call that
+ pattern with one argument which is the address to compare the stack
+ value against.  You must arrange for this pattern to report an error if
+ the stack pointer is out of range.
+ 
+ @item
+ If neither of the above are true, GNU CC will generate code to periodically
+ ``probe'' the stack pointer using the values of the macros defined below.
+ @end enumerate
+ 
+ Normally, you will use the default values of these macros, so GNU CC
+ will use the third approach.
+ 
+ @table @code
+ @findex STACK_CHECK_BUILTIN
+ @item STACK_CHECK_BUILTIN
+ A nonzero value if stack checking is done by the configuration files in a
+ machine-dependent manner.  You should define this macro if stack checking 
+ is require by the ABI of your machine or if you would like to have to stack 
+ checking in some more efficient way than GNU CC's portable approach.
+ The default value of this macro is zero.
+ 
+ @findex STACK_CHECK_PROBE_INTERVAL
+ @item STACK_CHECK_PROBE_INTERVAL
+ An integer representing the interval at which GNU CC must generate stack
+ probe instructions.  You will normally define this macro to be no larger
+ than the size of the ``guard pages'' at the end of a stack area.  The
+ default value of 4096 is suitable for most systems.
+ 
+ @findex STACK_CHECK_PROBE_LOAD
+ @item STACK_CHECK_PROBE_LOAD
+ A integer which is nonzero if GNU CC should perform the stack probe 
+ as a load instruction and zero if GNU CC should use a store instruction.
+ The default is zero, which is the most efficient choice on most systems.
+ 
+ @findex STACK_CHECK_PROTECT
+ @item STACK_CHECK_PROTECT
+ The number of bytes of stack needed to recover from a stack overflow,
+ for languages where such a recovery is supported.  The default value of
+ 75 words should be adequate for most machines.
+ 
+ @findex STACK_CHECK_MAX_FRAME_SIZE
+ @item STACK_CHECK_MAX_FRAME_SIZE
+ The maximum size of a stack frame, in bytes.  GNU CC will generate probe
+ instructions in non-leaf functions to ensure at least this many bytes of
+ stack are available.  If a stack frame is larger than this size, stack
+ checking will not be reliable and GNU CC will issue a warning.  The
+ default is chosen so that GNU CC only generates one instruction on most
+ systems.  You should normally not change the default value of this macro.
+ 
+ @findex STACK_CHECK_FIXED_FRAME_SIZE
+ @item STACK_CHECK_FIXED_FRAME_SIZE
+ GNU CC uses this value to generate the above warning message.  It
+ represents the amount of fixed frame used by a function, not including
+ space for any callee-saved registers, temporaries and user variables.
+ You need only specify an upper bound for this amount and will normally
+ use the default of four words.
+ 
+ @findex STACK_CHECK_MAX_VAR_SIZE
+ @item STACK_CHECK_MAX_VAR_SIZE
+ The maximum size, in bytes, of an object that GNU CC will place in the
+ fixed area of the stack frame when the user specifies
+ @samp{-fstack-check}.
+ GNU CC computed the default from the values of the above macros and you will
+ normally not need to override that default.
  @item STACK_POINTER_REGNUM
  The register number of the stack pointer register, which must also be a
diff -rcp2N gcc-2.7.2.3/toplev.c gcc-2.7.2.3.f.2/toplev.c
*** gcc-2.7.2.3/toplev.c	Fri Oct 20 21:56:35 1995
--- gcc-2.7.2.3.f.2/toplev.c	Tue Sep  9 07:01:47 1997
*************** int flag_unroll_loops;
*** 388,391 ****
--- 388,405 ----
  int flag_unroll_all_loops;
  
+ /* Nonzero forces all invariant computations in loops to be moved
+    outside the loop. */
+ 
+ int flag_move_all_movables = 0;
+ 
+ /* Nonzero forces all general induction variables in loops to be
+    strength reduced. */
+ 
+ int flag_reduce_all_givs = 0;
+ 
+ /* Nonzero gets another run of loop_optimize performed. */
+ 
+ int flag_rerun_loop_opt = 0;
+ 
  /* Nonzero for -fwritable-strings:
     store string constants in data segment and don't uniquize them.  */
*************** int flag_gnu_linker = 1;
*** 522,525 ****
--- 536,554 ----
  int flag_pack_struct = 0;
  
+ /* 1 if alias checking is on (by default, when -O).  */
+ int flag_alias_check = 0;
+ 
+ /* 0 if pointer arguments may alias each other.  True in C.
+    1 if pointer arguments may not alias each other but may alias
+    global variables.
+    2 if pointer arguments may not alias each other and may not
+    alias global variables.  True in Fortran.
+    This defaults to 0 for C.  */
+ int flag_argument_noalias = 0;
+ 
+ /* Emit code to check for stack overflow; also may cause large objects
+    to be allocated dynamically.  */
+ int flag_stack_check;
+ 
  /* Table of language-independent -f options.
     STRING is the option name.  VARIABLE is the address of the variable.
*************** struct { char *string; int *variable; in
*** 542,545 ****
--- 571,577 ----
    {"unroll-loops", &flag_unroll_loops, 1},
    {"unroll-all-loops", &flag_unroll_all_loops, 1},
+   {"move-all-movables", &flag_move_all_movables, 1},
+   {"reduce-all-givs", &flag_reduce_all_givs, 1},
+   {"rerun-loop-opt", &flag_rerun_loop_opt, 1},
    {"writable-strings", &flag_writable_strings, 1},
    {"peephole", &flag_no_peephole, 0},
*************** struct { char *string; int *variable; in
*** 568,572 ****
    {"gnu-linker", &flag_gnu_linker, 1},
    {"pack-struct", &flag_pack_struct, 1},
!   {"bytecode", &output_bytecode, 1}
  };
  
--- 600,609 ----
    {"gnu-linker", &flag_gnu_linker, 1},
    {"pack-struct", &flag_pack_struct, 1},
!   {"bytecode", &output_bytecode, 1},
!   {"alias-check", &flag_alias_check, 1},
!   {"argument-alias", &flag_argument_noalias, 0},
!   {"argument-noalias", &flag_argument_noalias, 1},
!   {"argument-noalias-global", &flag_argument_noalias, 2},
!   {"stack-check", &flag_stack_check, 1}
  };
  
*************** rest_of_compilation (decl)
*** 2715,2725 ****
  	 finish_compilation will call rest_of_compilation again
  	 for those functions that need to be output.  Also defer those
! 	 functions that we are supposed to defer.  */
! 
!       if (DECL_DEFER_OUTPUT (decl)
! 	  || ((specd || DECL_INLINE (decl))
! 	      && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
! 		   && ! flag_keep_inline_functions)
! 		  || DECL_EXTERNAL (decl))))
  	{
  	  DECL_DEFER_OUTPUT (decl) = 1;
--- 2752,2765 ----
  	 finish_compilation will call rest_of_compilation again
  	 for those functions that need to be output.  Also defer those
! 	 functions that we are supposed to defer.  We cannot defer
! 	 functions containing nested functions since the nested function
! 	 data is in our non-saved obstack.  */
! 
!       if (! current_function_contains_functions
! 	  && (DECL_DEFER_OUTPUT (decl)
! 	      || ((specd || DECL_INLINE (decl))
! 		  && ((! TREE_PUBLIC (decl) && ! TREE_ADDRESSABLE (decl)
! 		       && ! flag_keep_inline_functions)
! 		      || DECL_EXTERNAL (decl)))))
  	{
  	  DECL_DEFER_OUTPUT (decl) = 1;
*************** rest_of_compilation (decl)
*** 2893,2897 ****
--- 2933,2956 ----
        TIMEVAR (loop_time,
  	       {
+ 		 int save_unroll_flag;
+ 		 int save_unroll_all_flag;
+ 
+ 		 if (flag_rerun_loop_opt)
+ 		   {
+ 		     save_unroll_flag = flag_unroll_loops;
+ 		     save_unroll_all_flag = flag_unroll_all_loops;
+ 		     flag_unroll_loops = 0;
+ 		     flag_unroll_all_loops = 0;
+ 		   }
+ 
  		 loop_optimize (insns, loop_dump_file);
+ 
+ 		 if (flag_rerun_loop_opt)
+ 		   {
+ 		     flag_unroll_loops = save_unroll_flag;
+ 		     flag_unroll_all_loops = save_unroll_all_flag;
+ 
+ 		     loop_optimize (insns, loop_dump_file);
+ 		   }
  	       });
      }
*************** rest_of_compilation (decl)
*** 3280,3283 ****
--- 3339,3346 ----
    resume_temporary_allocation ();
  
+   /* Show no temporary slots allocated.  */
+ 
+   init_temp_slots ();
+ 
    /* The parsing time is all the time spent in yyparse
       *except* what is spent in this function.  */
*************** main (argc, argv, envp)
*** 3383,3386 ****
--- 3446,3450 ----
        flag_omit_frame_pointer = 1;
  #endif
+       flag_alias_check = 1;
      }
  
diff -rcp2N gcc-2.7.2.3/tree.c gcc-2.7.2.3.f.2/tree.c
*** gcc-2.7.2.3/tree.c	Mon Oct  2 01:26:56 1995
--- gcc-2.7.2.3.f.2/tree.c	Tue Sep  9 07:01:48 1997
*************** build_string (len, str)
*** 1428,1436 ****
  /* Return a newly constructed COMPLEX_CST node whose value is
     specified by the real and imaginary parts REAL and IMAG.
!    Both REAL and IMAG should be constant nodes.
!    The TREE_TYPE is not initialized.  */
  
  tree
! build_complex (real, imag)
       tree real, imag;
  {
--- 1428,1437 ----
  /* Return a newly constructed COMPLEX_CST node whose value is
     specified by the real and imaginary parts REAL and IMAG.
!    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
!    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
  
  tree
! build_complex (type, real, imag)
!      tree type;
       tree real, imag;
  {
*************** build_complex (real, imag)
*** 1439,1443 ****
    TREE_REALPART (t) = real;
    TREE_IMAGPART (t) = imag;
!   TREE_TYPE (t) = build_complex_type (TREE_TYPE (real));
    TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
    TREE_CONSTANT_OVERFLOW (t)
--- 1440,1444 ----
    TREE_REALPART (t) = real;
    TREE_IMAGPART (t) = imag;
!   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
    TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
    TREE_CONSTANT_OVERFLOW (t)
*************** integer_zerop (expr)
*** 1484,1487 ****
--- 1485,1489 ----
  
    return ((TREE_CODE (expr) == INTEGER_CST
+ 	   && ! TREE_CONSTANT_OVERFLOW (expr)
  	   && TREE_INT_CST_LOW (expr) == 0
  	   && TREE_INT_CST_HIGH (expr) == 0)
*************** integer_onep (expr)
*** 1501,1504 ****
--- 1503,1507 ----
  
    return ((TREE_CODE (expr) == INTEGER_CST
+ 	   && ! TREE_CONSTANT_OVERFLOW (expr)
  	   && TREE_INT_CST_LOW (expr) == 1
  	   && TREE_INT_CST_HIGH (expr) == 0)
*************** integer_all_onesp (expr)
*** 1525,1529 ****
      return 1;
  
!   else if (TREE_CODE (expr) != INTEGER_CST)
      return 0;
  
--- 1528,1533 ----
      return 1;
  
!   else if (TREE_CODE (expr) != INTEGER_CST
! 	   || TREE_CONSTANT_OVERFLOW (expr))
      return 0;
  
*************** integer_pow2p (expr)
*** 1574,1578 ****
      return 1;
  
!   if (TREE_CODE (expr) != INTEGER_CST)
      return 0;
  
--- 1578,1582 ----
      return 1;
  
!   if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
      return 0;
  
*************** real_zerop (expr)
*** 1596,1599 ****
--- 1600,1604 ----
  
    return ((TREE_CODE (expr) == REAL_CST
+ 	   && ! TREE_CONSTANT_OVERFLOW (expr)
  	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
  	  || (TREE_CODE (expr) == COMPLEX_CST
*************** real_onep (expr)
*** 1611,1614 ****
--- 1616,1620 ----
  
    return ((TREE_CODE (expr) == REAL_CST
+ 	   && ! TREE_CONSTANT_OVERFLOW (expr)
  	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
  	  || (TREE_CODE (expr) == COMPLEX_CST
*************** real_twop (expr)
*** 1626,1629 ****
--- 1632,1636 ----
  
    return ((TREE_CODE (expr) == REAL_CST
+ 	   && ! TREE_CONSTANT_OVERFLOW (expr)
  	   && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
  	  || (TREE_CODE (expr) == COMPLEX_CST
*************** staticp (arg)
*** 2055,2061 ****
        return 1;
  
      case COMPONENT_REF:
      case BIT_FIELD_REF:
!       return staticp (TREE_OPERAND (arg, 0));
  
  #if 0
--- 2062,2073 ----
        return 1;
  
+       /* If we are referencing a bitfield, we can't evaluate an
+ 	 ADDR_EXPR at compile time and so it isn't a constant.  */
      case COMPONENT_REF:
+       return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
+ 	      && staticp (TREE_OPERAND (arg, 0)));
+ 
      case BIT_FIELD_REF:
!       return 0;
  
  #if 0
*************** save_expr (expr)
*** 2141,2148 ****
  
  /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
!    or offset that depends on a field within a record.
! 
!    Note that we only allow such expressions within simple arithmetic
!    or a COND_EXPR.  */
  
  int
--- 2153,2157 ----
  
  /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
!    or offset that depends on a field within a record.  */
  
  int
*************** contains_placeholder_p (exp)
*** 2151,2155 ****
  {
    register enum tree_code code = TREE_CODE (exp);
-   tree inner;
  
    /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
--- 2160,2163 ----
*************** contains_placeholder_p (exp)
*** 2157,2173 ****
    if (code == WITH_RECORD_EXPR)
      return 0;
  
    switch (TREE_CODE_CLASS (code))
      {
      case 'r':
!       for (inner = TREE_OPERAND (exp, 0);
! 	   TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
! 	   inner = TREE_OPERAND (inner, 0))
! 	;
!       return TREE_CODE (inner) == PLACEHOLDER_EXPR;
  
      case '1':
      case '2':  case '<':
      case 'e':
        switch (tree_code_length[(int) code])
  	{
--- 2165,2203 ----
    if (code == WITH_RECORD_EXPR)
      return 0;
+   else if (code == PLACEHOLDER_EXPR)
+     return 1;
  
    switch (TREE_CODE_CLASS (code))
      {
      case 'r':
!       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
! 	 position computations since they will be converted into a
! 	 WITH_RECORD_EXPR involving the reference, which will assume
! 	 here will be valid.  */
!       return contains_placeholder_p (TREE_OPERAND (exp, 0));
  
      case '1':
      case '2':  case '<':
      case 'e':
+       switch (code)
+ 	{
+ 	case COMPOUND_EXPR:
+ 	  /* Ignoring the first operand isn't quite right, but works best. */
+ 	  return contains_placeholder_p (TREE_OPERAND (exp, 1));
+ 
+ 	case RTL_EXPR:
+ 	case CONSTRUCTOR:
+ 	  return 0;
+ 
+ 	case COND_EXPR:
+ 	  return (contains_placeholder_p (TREE_OPERAND (exp, 0))
+ 		  || contains_placeholder_p (TREE_OPERAND (exp, 1))
+ 		  || contains_placeholder_p (TREE_OPERAND (exp, 2)));
+ 
+ 	case SAVE_EXPR:
+ 	   return (SAVE_EXPR_RTL (exp) == 0
+ 		   && contains_placeholder_p (TREE_OPERAND (exp, 0)));
+ 	}
+ 
        switch (tree_code_length[(int) code])
  	{
*************** contains_placeholder_p (exp)
*** 2175,2189 ****
  	  return contains_placeholder_p (TREE_OPERAND (exp, 0));
  	case 2:
! 	  return (code != RTL_EXPR
! 		  && code != CONSTRUCTOR
! 		  && ! (code == SAVE_EXPR && SAVE_EXPR_RTL (exp) != 0)
! 		  && code != WITH_RECORD_EXPR
! 		  && (contains_placeholder_p (TREE_OPERAND (exp, 0))
! 		      || contains_placeholder_p (TREE_OPERAND (exp, 1))));
! 	case 3:
! 	  return (code == COND_EXPR
! 		  && (contains_placeholder_p (TREE_OPERAND (exp, 0))
! 		      || contains_placeholder_p (TREE_OPERAND (exp, 1))
! 		      || contains_placeholder_p (TREE_OPERAND (exp, 2))));
  	}
      }
--- 2205,2210 ----
  	  return contains_placeholder_p (TREE_OPERAND (exp, 0));
  	case 2:
! 	  return (contains_placeholder_p (TREE_OPERAND (exp, 0))
! 		  || contains_placeholder_p (TREE_OPERAND (exp, 1)));
  	}
      }
*************** substitute_in_expr (exp, f, r)
*** 2204,2207 ****
--- 2225,2229 ----
  {
    enum tree_code code = TREE_CODE (exp);
+   tree op0, op1, op2;
    tree new = 0;
    tree inner;
*************** substitute_in_expr (exp, f, r)
*** 2225,2231 ****
  	{
  	case 1:
! 	  new = fold (build1 (code, TREE_TYPE (exp),
! 			      substitute_in_expr (TREE_OPERAND (exp, 0),
! 						  f, r)));
  	  break;
  
--- 2247,2255 ----
  	{
  	case 1:
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0))
! 	    return exp;
! 	  
! 	  new = fold (build1 (code, TREE_TYPE (exp), op0));
  	  break;
  
*************** substitute_in_expr (exp, f, r)
*** 2238,2245 ****
  	    abort ();
  
! 	  new = fold (build (code, TREE_TYPE (exp),
! 			     substitute_in_expr (TREE_OPERAND (exp, 0), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 1),
! 						 f, r)));
  	  break;
  
--- 2262,2271 ----
  	    abort ();
  
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
! 	    return exp;
! 
! 	  new = fold (build (code, TREE_TYPE (exp), op0, op1));
  	  break;
  
*************** substitute_in_expr (exp, f, r)
*** 2253,2261 ****
  	    abort ();
  
! 	  new = fold (build (code, TREE_TYPE (exp),
! 			     substitute_in_expr (TREE_OPERAND (exp, 0), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 1), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 2),
! 						 f, r)));
  	}
  
--- 2279,2290 ----
  	    abort ();
  
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
! 	  op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
! 	      && op2 == TREE_OPERAND (exp, 2))
! 	    return exp;
! 
! 	  new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
  	}
  
*************** substitute_in_expr (exp, f, r)
*** 2276,2302 ****
  	    return r;
  
! 	  new = fold (build (code, TREE_TYPE (exp),
! 			     substitute_in_expr (TREE_OPERAND (exp, 0), f, r),
  			     TREE_OPERAND (exp, 1)));
  	  break;
  
  	case BIT_FIELD_REF:
! 	  new = fold (build (code, TREE_TYPE (exp),
! 			     substitute_in_expr (TREE_OPERAND (exp, 0), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 1), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 2), f, r)));
  	  break;
  
  	case INDIRECT_REF:
  	case BUFFER_REF:
! 	  new = fold (build1 (code, TREE_TYPE (exp),
! 			      substitute_in_expr (TREE_OPERAND (exp, 0),
! 						  f, r)));
  	  break;
  
  	case OFFSET_REF:
! 	  new = fold (build (code, TREE_TYPE (exp),
! 			     substitute_in_expr (TREE_OPERAND (exp, 0), f, r),
! 			     substitute_in_expr (TREE_OPERAND (exp, 1), f, r)));
  	  break;
  	}
--- 2305,2349 ----
  	    return r;
  
! 	  /* If this expression hasn't been completed let, leave it 
! 	     alone.  */
! 	  if (TREE_CODE (inner) == PLACEHOLDER_EXPR
! 	      && TREE_TYPE (inner) == 0)
! 	    return exp;
! 
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0))
! 	    return exp;
! 
! 	  new = fold (build (code, TREE_TYPE (exp), op0,
  			     TREE_OPERAND (exp, 1)));
  	  break;
  
  	case BIT_FIELD_REF:
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
! 	  op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
! 	      && op2 == TREE_OPERAND (exp, 2))
! 	    return exp;
! 
! 	  new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
  	  break;
  
  	case INDIRECT_REF:
  	case BUFFER_REF:
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0))
! 	    return exp;
! 
! 	  new = fold (build1 (code, TREE_TYPE (exp), op0));
  	  break;
  
  	case OFFSET_REF:
! 	  op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
! 	  op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
! 	  if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
! 	    return exp;
! 
! 	  new = fold (build (code, TREE_TYPE (exp), op0, op1));
  	  break;
  	}
*************** substitute_in_expr (exp, f, r)
*** 2311,2454 ****
  }
  
- /* Given a type T, a FIELD_DECL F, and a replacement value R,
-    return a new type with all size expressions that contain F
-    updated by replacing F with R.  */
- 
- tree
- substitute_in_type (t, f, r)
-      tree t, f, r;
- {
-   switch (TREE_CODE (t))
-     {
-     case POINTER_TYPE:
-     case VOID_TYPE:
-       return t;
-     case INTEGER_TYPE:
-     case ENUMERAL_TYPE:
-     case BOOLEAN_TYPE:
-     case CHAR_TYPE:
-       if ((TREE_CODE (TYPE_MIN_VALUE (t)) != INTEGER_CST
- 	   && contains_placeholder_p (TYPE_MIN_VALUE (t)))
- 	  || (TREE_CODE (TYPE_MAX_VALUE (t)) != INTEGER_CST
- 	      && contains_placeholder_p (TYPE_MAX_VALUE (t))))
- 	return build_range_type (t,
- 				 substitute_in_expr (TYPE_MIN_VALUE (t), f, r),
- 				 substitute_in_expr (TYPE_MAX_VALUE (t), f, r));
-       return t;
- 
-     case REAL_TYPE:
-       if ((TYPE_MIN_VALUE (t) != 0
- 	   && TREE_CODE (TYPE_MIN_VALUE (t)) != REAL_CST
- 	   && contains_placeholder_p (TYPE_MIN_VALUE (t)))
- 	  || (TYPE_MAX_VALUE (t) != 0
- 	      && TREE_CODE (TYPE_MAX_VALUE (t)) != REAL_CST
- 	      && contains_placeholder_p (TYPE_MAX_VALUE (t))))
- 	{
- 	  t = build_type_copy (t);
- 
- 	  if (TYPE_MIN_VALUE (t))
- 	    TYPE_MIN_VALUE (t) = substitute_in_expr (TYPE_MIN_VALUE (t), f, r);
- 	  if (TYPE_MAX_VALUE (t))
- 	    TYPE_MAX_VALUE (t) = substitute_in_expr (TYPE_MAX_VALUE (t), f, r);
- 	}
-       return t;
- 
-     case COMPLEX_TYPE:
-       return build_complex_type (substitute_in_type (TREE_TYPE (t), f, r));
- 
-     case OFFSET_TYPE:
-     case METHOD_TYPE:
-     case REFERENCE_TYPE:
-     case FILE_TYPE:
-     case SET_TYPE:
-     case FUNCTION_TYPE:
-     case LANG_TYPE:
-       /* Don't know how to do these yet.  */
-       abort ();
- 
-     case ARRAY_TYPE:
-       t = build_array_type (substitute_in_type (TREE_TYPE (t), f, r),
- 			    substitute_in_type (TYPE_DOMAIN (t), f, r));
-       TYPE_SIZE (t) = 0;
-       layout_type (t);
-       return t;
- 
-     case RECORD_TYPE:
-     case UNION_TYPE:
-     case QUAL_UNION_TYPE:
-       {
- 	tree new = copy_node (t);
- 	tree field;
- 	tree last_field = 0;
- 
- 	/* Start out with no fields, make new fields, and chain them
- 	   in.  */
- 
- 	TYPE_FIELDS (new) = 0;
- 	TYPE_SIZE (new) = 0;
- 
- 	for (field = TYPE_FIELDS (t); field;
- 	     field = TREE_CHAIN (field))
- 	  {
- 	    tree new_field = copy_node (field);
- 
- 	    TREE_TYPE (new_field)
- 	      = substitute_in_type (TREE_TYPE (new_field), f, r);
- 
- 	    /* If this is an anonymous field and the type of this field is
- 	       a UNION_TYPE or RECORD_TYPE with no elements, ignore it.  If
- 	       the type just has one element, treat that as the field. 
- 	       But don't do this if we are processing a QUAL_UNION_TYPE.  */
- 	    if (TREE_CODE (t) != QUAL_UNION_TYPE && DECL_NAME (new_field) == 0
- 		&& (TREE_CODE (TREE_TYPE (new_field)) == UNION_TYPE
- 		    || TREE_CODE (TREE_TYPE (new_field)) == RECORD_TYPE))
- 	      {
- 		if (TYPE_FIELDS (TREE_TYPE (new_field)) == 0)
- 		  continue;
- 
- 		if (TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (new_field))) == 0)
- 		  new_field = TYPE_FIELDS (TREE_TYPE (new_field));
- 	      }
- 
- 	    DECL_CONTEXT (new_field) = new;
- 	    DECL_SIZE (new_field) = 0;
- 
- 	    if (TREE_CODE (t) == QUAL_UNION_TYPE)
- 	      {
- 		/* Do the substitution inside the qualifier and if we find
- 		   that this field will not be present, omit it.  */
- 		DECL_QUALIFIER (new_field)
- 		  = substitute_in_expr (DECL_QUALIFIER (field), f, r);
- 		if (integer_zerop (DECL_QUALIFIER (new_field)))
- 		  continue;
- 	      }
- 
- 	    if (last_field == 0)
- 	      TYPE_FIELDS (new) = new_field;
- 	    else
- 	      TREE_CHAIN (last_field) = new_field;
- 
- 	    last_field = new_field;
- 
- 	    /* If this is a qualified type and this field will always be
- 	       present, we are done.  */
- 	    if (TREE_CODE (t) == QUAL_UNION_TYPE
- 		&& integer_onep (DECL_QUALIFIER (new_field)))
- 	      break;
- 	  }
- 
- 	/* If this used to be a qualified union type, but we now know what
- 	   field will be present, make this a normal union.  */
- 	if (TREE_CODE (new) == QUAL_UNION_TYPE
- 	    && (TYPE_FIELDS (new) == 0
- 		|| integer_onep (DECL_QUALIFIER (TYPE_FIELDS (new)))))
- 	  TREE_SET_CODE (new, UNION_TYPE);
- 
- 	layout_type (new);
- 	return new;
-       }
-     }
- }
- 
  /* Stabilize a reference so that we can use it any number of times
     without causing its operands to be evaluated more than once.
--- 2358,2361 ----
*************** build_type_variant (type, constp, volati
*** 3141,3145 ****
       preserve the TYPE_NAME, since there is code that depends on this.  */
  
!   for (t = TYPE_MAIN_VARIANT(type); t; t = TYPE_NEXT_VARIANT (t))
      if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t)
  	&& TYPE_NAME (t) == TYPE_NAME (type))
--- 3048,3052 ----
       preserve the TYPE_NAME, since there is code that depends on this.  */
  
!   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
      if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t)
  	&& TYPE_NAME (t) == TYPE_NAME (type))
*************** get_unwidened (op, for_type)
*** 4051,4055 ****
    if (TREE_CODE (op) == COMPONENT_REF
        /* Since type_for_size always gives an integer type.  */
!       && TREE_CODE (type) != REAL_TYPE)
      {
        unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
--- 3958,3964 ----
    if (TREE_CODE (op) == COMPONENT_REF
        /* Since type_for_size always gives an integer type.  */
!       && TREE_CODE (type) != REAL_TYPE
!       /* Don't crash if field not layed out yet.  */
!       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
      {
        unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
diff -rcp2N gcc-2.7.2.3/tree.h gcc-2.7.2.3.f.2/tree.h
*** gcc-2.7.2.3/tree.h	Mon Sep 25 21:49:40 1995
--- gcc-2.7.2.3.f.2/tree.h	Mon Oct 27 07:40:49 1997
*************** enum built_in_function
*** 98,101 ****
--- 98,103 ----
    BUILT_IN_APPLY,
    BUILT_IN_RETURN,
+   BUILT_IN_SETJMP,
+   BUILT_IN_LONGJMP,
  
    /* C++ extensions */
*************** struct tree_int_cst
*** 408,411 ****
--- 410,415 ----
  {
    char common[sizeof (struct tree_common)];
+   struct rtx_def *rtl;	/* acts as link to register transfer language
+ 			   (rtl) info */
    HOST_WIDE_INT int_cst_low;
    HOST_WIDE_INT int_cst_high;
*************** struct tree_type
*** 957,960 ****
--- 961,967 ----
  #define DECL_STATIC_DESTRUCTOR(NODE) ((NODE)->decl.static_dtor_flag)
  
+ /* In a PARM_DECL, nonzero if this is a restricted pointer.  */
+ #define DECL_RESTRICT(NODE) (NODE)->decl.static_ctor_flag
+ 
  /* Used to indicate that this DECL represents a compiler-generated entity.  */
  #define DECL_ARTIFICIAL(NODE) ((NODE)->decl.artificial_flag)
*************** extern tree build_int_2_wide		PROTO((HOS
*** 1176,1180 ****
  extern tree build_real			PROTO((tree, REAL_VALUE_TYPE));
  extern tree build_real_from_int_cst 	PROTO((tree, tree));
! extern tree build_complex		PROTO((tree, tree));
  extern tree build_string		PROTO((int, char *));
  extern tree build1			PROTO((enum tree_code, tree, tree));
--- 1183,1187 ----
  extern tree build_real			PROTO((tree, REAL_VALUE_TYPE));
  extern tree build_real_from_int_cst 	PROTO((tree, tree));
! extern tree build_complex		PROTO((tree, tree, tree));
  extern tree build_string		PROTO((int, char *));
  extern tree build1			PROTO((enum tree_code, tree, tree));
*************** extern int contains_placeholder_p	PROTO(
*** 1378,1387 ****
  extern tree substitute_in_expr		PROTO((tree, tree, tree));
  
- /* Given a type T, a FIELD_DECL F, and a replacement value R,
-    return a new type with all size expressions that contain F
-    updated by replacing the reference to F with R.  */
- 
- extern tree substitute_in_type		PROTO((tree, tree, tree));
- 
  /* variable_size (EXP) is like save_expr (EXP) except that it
     is for the special case of something that is part of a
--- 1385,1388 ----
*************** extern tree maybe_build_cleanup		PROTO((
*** 1456,1460 ****
     and find the ultimate containing object, which is returned.  */
  
! extern tree get_inner_reference		PROTO((tree, int *, int *, tree *, enum machine_mode *, int *, int *));
  
  /* Return the FUNCTION_DECL which provides this _DECL with its context,
--- 1457,1463 ----
     and find the ultimate containing object, which is returned.  */
  
! extern tree get_inner_reference		PROTO((tree, int *, int *, tree *,
! 					       enum machine_mode *, int *,
! 					       int *, int *));
  
  /* Return the FUNCTION_DECL which provides this _DECL with its context,
diff -rcp2N gcc-2.7.2.3/unroll.c gcc-2.7.2.3.f.2/unroll.c
*** gcc-2.7.2.3/unroll.c	Tue Jun 24 18:42:51 1997
--- gcc-2.7.2.3.f.2/unroll.c	Tue Sep  9 07:01:48 1997
*************** unroll_loop (loop_end, insn_count, loop_
*** 268,273 ****
       structure of the function.  This can happen as a result of the
       "if (foo) bar; else break;" optimization in jump.c.  */
  
!   if (write_symbols != NO_DEBUG)
      {
        int block_begins = 0;
--- 268,277 ----
       structure of the function.  This can happen as a result of the
       "if (foo) bar; else break;" optimization in jump.c.  */
+   /* ??? Gcc has a general policy that -g is never supposed to change the code
+      that the compiler emits, so we must disable this optimization always,
+      even if debug info is not being output.  This is rare, so this should
+      not be a significant performance problem.  */
  
!   if (1 /* write_symbols != NO_DEBUG */)
      {
        int block_begins = 0;
*************** unroll_loop (loop_end, insn_count, loop_
*** 633,636 ****
--- 637,657 ----
      }
  
+   if (unroll_type == UNROLL_NAIVE
+       && GET_CODE (last_loop_insn) == JUMP_INSN
+       && start_label != JUMP_LABEL (last_loop_insn))
+     {
+       /* ??? The loop ends with a conditional branch that does not branch back
+ 	 to the loop start label.  In this case, we must emit an unconditional
+ 	 branch to the loop exit after emitting the final branch.
+ 	 copy_loop_body does not have support for this currently, so we
+ 	 give up.  It doesn't seem worthwhile to unroll anyways since
+ 	 unrolling would increase the number of branch instructions
+ 	 executed.  */
+       if (loop_dump_stream)
+ 	fprintf (loop_dump_stream,
+ 		 "Unrolling failure: final conditional branch not to loop start\n");
+       return;
+     }
+ 
    /* Allocate a translation table for the labels and insn numbers.
       They will be filled in as we copy the insns in the loop.  */
*************** unroll_loop (loop_end, insn_count, loop_
*** 995,999 ****
  	      for (j = FIRST_PSEUDO_REGISTER; j < max_reg_before_loop; j++)
  		if (local_regno[j])
! 		  map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j]));
  
  	      /* The last copy needs the compare/branch insns at the end,
--- 1016,1024 ----
  	      for (j = FIRST_PSEUDO_REGISTER; j < max_reg_before_loop; j++)
  		if (local_regno[j])
! 		  {
! 		    map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j]));
! 		    record_base_value (REGNO (map->reg_map[j]),
! 				       regno_reg_rtx[j]);
! 		  }
  
  	      /* The last copy needs the compare/branch insns at the end,
*************** unroll_loop (loop_end, insn_count, loop_
*** 1136,1140 ****
        for (j = FIRST_PSEUDO_REGISTER; j < max_reg_before_loop; j++)
  	if (local_regno[j])
! 	  map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j]));
  
        /* If loop starts with a branch to the test, then fix it so that
--- 1161,1169 ----
        for (j = FIRST_PSEUDO_REGISTER; j < max_reg_before_loop; j++)
  	if (local_regno[j])
! 	  {
! 	    map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j]));
! 	    record_base_value (REGNO (map->reg_map[j]),
! 			       regno_reg_rtx[j]);
! 	  }
  
        /* If loop starts with a branch to the test, then fix it so that
*************** copy_loop_body (copy_start, copy_end, ma
*** 1605,1608 ****
--- 1634,1641 ----
  		    int this_giv_inc = INTVAL (giv_inc);
  
+ 		    /* If this DEST_ADDR giv was not split, then ignore it.  */
+ 		    if (*tv->location != tv->dest_reg)
+ 		      continue;
+ 
  		    /* Scale this_giv_inc if the multiplicative factors of
  		       the two givs are different.  */
*************** copy_loop_body (copy_start, copy_end, ma
*** 1631,1635 ****
  			   incrementing the shared pseudo reg more than
  			   once.  */
! 			if (! tv->same_insn)
  			  {
  			    /* tv->dest_reg may actually be a (PLUS (REG)
--- 1664,1668 ----
  			   incrementing the shared pseudo reg more than
  			   once.  */
! 			if (! tv->same_insn && ! tv->shared)
  			  {
  			    /* tv->dest_reg may actually be a (PLUS (REG)
*************** copy_loop_body (copy_start, copy_end, ma
*** 1757,1760 ****
--- 1790,1794 ----
  		      giv_dest_reg = tem;
  		      map->reg_map[regno] = tem;
+ 		      record_base_value (REGNO (tem), giv_src_reg);
  		    }
  		  else
*************** iteration_info (iteration_var, initial_v
*** 2220,2231 ****
        return;
      }
!   /* Reject iteration variables larger than the host long size, since they
       could result in a number of iterations greater than the range of our
!      `unsigned long' variable loop_n_iterations.  */
!   else if (GET_MODE_BITSIZE (GET_MODE (iteration_var)) > HOST_BITS_PER_LONG)
      {
        if (loop_dump_stream)
  	fprintf (loop_dump_stream,
! 		 "Loop unrolling: Iteration var rejected because mode larger than host long.\n");
        return;
      }
--- 2254,2266 ----
        return;
      }
!   /* Reject iteration variables larger than the host wide int size, since they
       could result in a number of iterations greater than the range of our
!      `unsigned HOST_WIDE_INT' variable loop_n_iterations.  */
!   else if ((GET_MODE_BITSIZE (GET_MODE (iteration_var))
! 	    > HOST_BITS_PER_WIDE_INT))
      {
        if (loop_dump_stream)
  	fprintf (loop_dump_stream,
! 		 "Loop unrolling: Iteration var rejected because mode too large.\n");
        return;
      }
*************** find_splittable_regs (unroll_type, loop_
*** 2443,2447 ****
  		{
  		  rtx tem = gen_reg_rtx (bl->biv->mode);
! 		  
  		  emit_insn_before (gen_move_insn (tem, bl->biv->src_reg),
  				    loop_start);
--- 2478,2483 ----
  		{
  		  rtx tem = gen_reg_rtx (bl->biv->mode);
! 
! 		  record_base_value (REGNO (tem), bl->biv->add_val);
  		  emit_insn_before (gen_move_insn (tem, bl->biv->src_reg),
  				    loop_start);
*************** find_splittable_regs (unroll_type, loop_
*** 2500,2503 ****
--- 2536,2541 ----
  		 exits.  */
  	      rtx tem = gen_reg_rtx (bl->biv->mode);
+ 	      record_base_value (REGNO (tem), bl->biv->add_val);
+ 
  	      emit_insn_before (gen_move_insn (tem, bl->biv->src_reg),
  				loop_start);
*************** find_splittable_givs (bl, unroll_type, l
*** 2675,2678 ****
--- 2713,2717 ----
  	      rtx tem = gen_reg_rtx (bl->biv->mode);
  
+ 	      record_base_value (REGNO (tem), bl->biv->add_val);
  	      emit_insn_before (gen_move_insn (tem, bl->biv->src_reg),
  				loop_start);
*************** find_splittable_givs (bl, unroll_type, l
*** 2716,2719 ****
--- 2755,2759 ----
  		{
  		  rtx tem = gen_reg_rtx (v->mode);
+ 		  record_base_value (REGNO (tem), v->add_val);
  		  emit_iv_add_mult (bl->initial_value, v->mult_val,
  				    v->add_val, tem, loop_start);
*************** find_splittable_givs (bl, unroll_type, l
*** 2734,2747 ****
  		 register for the split addr giv, just to be safe.  */
  
! 	      /* ??? If there are multiple address givs which have been
! 		 combined with the same dest_reg giv, then we may only need
! 		 one new register for them.  Pulling out constants below will
! 		 catch some of the common cases of this.  Currently, I leave
! 		 the work of simplifying multiple address givs to the
! 		 following cse pass.  */
! 	      
! 	      /* As a special case, if we have multiple identical address givs
! 		 within a single instruction, then we do use a single pseudo
! 		 reg for both.  This is necessary in case one is a match_dup
  		 of the other.  */
  
--- 2774,2780 ----
  		 register for the split addr giv, just to be safe.  */
  
! 	      /* If we have multiple identical address givs within a
! 		 single instruction, then use a single pseudo reg for
! 		 both.  This is necessary in case one is a match_dup
  		 of the other.  */
  
*************** find_splittable_givs (bl, unroll_type, l
*** 2756,2759 ****
--- 2789,2812 ----
  			     INSN_UID (v->insn));
  		}
+ 	      /* If multiple address GIVs have been combined with the
+ 		 same dest_reg GIV, do not create a new register for
+ 		 each.  */
+ 	      else if (unroll_type != UNROLL_COMPLETELY
+ 		       && v->giv_type == DEST_ADDR
+ 		       && v->same && v->same->giv_type == DEST_ADDR
+ 		       && v->same->unrolled
+ #ifdef ADDRESS_COST
+ 		       /* combine_givs_p may return true when ADDRESS_COST is
+ 			  defined even if the multiply and add values are
+ 			  not equal.  To share a register here, the values
+ 			  must be equal, as well as related.  */
+ 		       && rtx_equal_p (v->mult_val, v->same->mult_val)
+ 		       && rtx_equal_p (v->add_val, v->same->add_val)
+ #endif
+ 		       )
+ 		{
+ 		  v->dest_reg = v->same->dest_reg;
+ 		  v->shared = 1;
+ 		}
  	      else if (unroll_type != UNROLL_COMPLETELY)
  		{
*************** find_splittable_givs (bl, unroll_type, l
*** 2761,2765 ****
  		     register to hold the split value of the DEST_ADDR giv.
  		     Emit insn to initialize its value before loop start.  */
! 		  tem = gen_reg_rtx (v->mode);
  
  		  /* If the address giv has a constant in its new_reg value,
--- 2814,2821 ----
  		     register to hold the split value of the DEST_ADDR giv.
  		     Emit insn to initialize its value before loop start.  */
! 
! 		  rtx tem = gen_reg_rtx (v->mode);
! 		  record_base_value (REGNO (tem), v->add_val);
! 		  v->unrolled = 1;
  
  		  /* If the address giv has a constant in its new_reg value,
*************** find_splittable_givs (bl, unroll_type, l
*** 2772,2781 ****
  		      v->dest_reg
  			= plus_constant (tem, INTVAL (XEXP (v->new_reg,1)));
! 		      
  		      /* Only succeed if this will give valid addresses.
  			 Try to validate both the first and the last
  			 address resulting from loop unrolling, if
  			 one fails, then can't do const elim here.  */
! 		      if (! verify_addresses (v, giv_inc, unroll_number))
  			{
  			  /* Save the negative of the eliminated const, so
--- 2828,2837 ----
  		      v->dest_reg
  			= plus_constant (tem, INTVAL (XEXP (v->new_reg,1)));
! 
  		      /* Only succeed if this will give valid addresses.
  			 Try to validate both the first and the last
  			 address resulting from loop unrolling, if
  			 one fails, then can't do const elim here.  */
! 		      if (verify_addresses (v, giv_inc, unroll_number))
  			{
  			  /* Save the negative of the eliminated const, so
*************** final_biv_value (bl, loop_start, loop_en
*** 3068,3071 ****
--- 3124,3128 ----
  
  	  tem = gen_reg_rtx (bl->biv->mode);
+ 	  record_base_value (REGNO (tem), bl->biv->add_val);
  	  /* Make sure loop_end is not the last insn.  */
  	  if (NEXT_INSN (loop_end) == 0)
*************** final_giv_value (v, loop_start, loop_end
*** 3161,3164 ****
--- 3218,3222 ----
  	  /* Put the final biv value in tem.  */
  	  tem = gen_reg_rtx (bl->biv->mode);
+ 	  record_base_value (REGNO (tem), bl->biv->add_val);
  	  emit_iv_add_mult (increment, GEN_INT (loop_n_iterations),
  			    bl->initial_value, tem, insert_before);
diff -rcp2N gcc-2.7.2.3/varasm.c gcc-2.7.2.3.f.2/varasm.c
*** gcc-2.7.2.3/varasm.c	Wed Aug 13 17:23:27 1997
--- gcc-2.7.2.3.f.2/varasm.c	Tue Sep  9 07:01:49 1997
*************** assemble_variable (decl, top_level, at_e
*** 1067,1070 ****
--- 1067,1072 ----
    if (! dont_output_data)
      {
+       int size;
+ 
        if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
  	goto finish;
*************** assemble_variable (decl, top_level, at_e
*** 1072,1078 ****
        /* This is better than explicit arithmetic, since it avoids overflow.  */
        size_tree = size_binop (CEIL_DIV_EXPR,
! 			  DECL_SIZE (decl), size_int (BITS_PER_UNIT));
  
!       if (TREE_INT_CST_HIGH (size_tree) != 0)
  	{
  	  error_with_decl (decl, "size of variable `%s' is too large");
--- 1074,1082 ----
        /* This is better than explicit arithmetic, since it avoids overflow.  */
        size_tree = size_binop (CEIL_DIV_EXPR,
! 			      DECL_SIZE (decl), size_int (BITS_PER_UNIT));
  
!       size = TREE_INT_CST_LOW (size_tree);
!       if (TREE_INT_CST_HIGH (size_tree) != 0
! 	  || size != TREE_INT_CST_LOW (size_tree))
  	{
  	  error_with_decl (decl, "size of variable `%s' is too large");
*************** decode_addr_const (exp, value)
*** 2134,2137 ****
--- 2138,2142 ----
      case COMPLEX_CST:
      case CONSTRUCTOR:
+     case INTEGER_CST:
        x = TREE_CST_RTL (target);
        break;
*************** const_hash (exp)
*** 2249,2253 ****
      return const_hash (TREE_OPERAND (exp, 0)) * 9
        +  const_hash (TREE_OPERAND (exp, 1));
!   else if (code == NOP_EXPR || code == CONVERT_EXPR)
      return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
  
--- 2254,2258 ----
      return const_hash (TREE_OPERAND (exp, 0)) * 9
        +  const_hash (TREE_OPERAND (exp, 1));
!   else if (code == NOP_EXPR || code == CONVERT_EXPR || code == NON_LVALUE_EXPR)
      return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
  
*************** compare_constant_1 (exp, p)
*** 2314,2317 ****
--- 2319,2324 ----
        if (flag_writable_strings)
  	return 0;
+       if (*p++ != TYPE_MODE (TREE_TYPE (exp)))
+ 	return 0;
        strp = TREE_STRING_POINTER (exp);
        len = TREE_STRING_LENGTH (exp);
*************** compare_constant_1 (exp, p)
*** 2403,2407 ****
        return p;
      }
!   else if (code == NOP_EXPR || code == CONVERT_EXPR)
      {
        p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
--- 2410,2414 ----
        return p;
      }
!   else if (code == NOP_EXPR || code == CONVERT_EXPR || code == NON_LVALUE_EXPR)
      {
        p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
*************** record_constant_1 (exp)
*** 2469,2472 ****
--- 2476,2480 ----
  	return;
  
+       obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
        strp = TREE_STRING_POINTER (exp);
        len = TREE_STRING_LENGTH (exp);
*************** copy_constant (exp)
*** 2635,2639 ****
  
      case COMPLEX_CST:
!       return build_complex (copy_constant (TREE_REALPART (exp)),
  			    copy_constant (TREE_IMAGPART (exp)));
  
--- 2643,2648 ----
  
      case COMPLEX_CST:
!       return build_complex (TREE_TYPE (exp),
! 			    copy_constant (TREE_REALPART (exp)),
  			    copy_constant (TREE_IMAGPART (exp)));
  
*************** copy_constant (exp)
*** 2646,2649 ****
--- 2655,2659 ----
      case NOP_EXPR:
      case CONVERT_EXPR:
+     case NON_LVALUE_EXPR:
        return build1 (TREE_CODE (exp), TREE_TYPE (exp),
  		     copy_constant (TREE_OPERAND (exp, 0)));
*************** output_constant_def (exp)
*** 2692,2698 ****
    register rtx def;
  
-   if (TREE_CODE (exp) == INTEGER_CST)
-     abort ();			/* No TREE_CST_RTL slot in these.  */
- 
    if (TREE_CST_RTL (exp))
      return TREE_CST_RTL (exp);
--- 2702,2705 ----
*************** bc_assemble_integer (exp, size)
*** 3622,3626 ****
    exp = fold (exp);
    
!   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
      exp = TREE_OPERAND (exp, 0);
    if (TREE_CODE (exp) == INTEGER_CST)
--- 3629,3634 ----
    exp = fold (exp);
    
!   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
! 	 || TREE_CODE (exp) == NON_LVALUE_EXPR)
      exp = TREE_OPERAND (exp, 0);
    if (TREE_CODE (exp) == INTEGER_CST)
*************** bc_assemble_integer (exp, size)
*** 3633,3641 ****
        const_part = TREE_OPERAND (exp, 0);
        while (TREE_CODE (const_part) == NOP_EXPR
! 	     || TREE_CODE (const_part) == CONVERT_EXPR)
  	const_part = TREE_OPERAND (const_part, 0);
        addr_part = TREE_OPERAND (exp, 1);
        while (TREE_CODE (addr_part) == NOP_EXPR
! 	     || TREE_CODE (addr_part) == CONVERT_EXPR)
  	addr_part = TREE_OPERAND (addr_part, 0);
        if (TREE_CODE (const_part) != INTEGER_CST)
--- 3641,3651 ----
        const_part = TREE_OPERAND (exp, 0);
        while (TREE_CODE (const_part) == NOP_EXPR
! 	     || TREE_CODE (const_part) == CONVERT_EXPR
! 	     || TREE_CODE (const_part) == NON_LVALUE_EXPR)
  	const_part = TREE_OPERAND (const_part, 0);
        addr_part = TREE_OPERAND (exp, 1);
        while (TREE_CODE (addr_part) == NOP_EXPR
! 	     || TREE_CODE (addr_part) == CONVERT_EXPR
! 	     || TREE_CODE (addr_part) == NON_LVALUE_EXPR)
  	addr_part = TREE_OPERAND (addr_part, 0);
        if (TREE_CODE (const_part) != INTEGER_CST)
diff -rcp2N gcc-2.7.2.3/version.c gcc-2.7.2.3.f.2/version.c
*** gcc-2.7.2.3/version.c	Tue Aug 19 21:26:09 1997
--- gcc-2.7.2.3.f.2/version.c	Tue Sep 16 06:07:36 1997
***************
*** 1 ****
! char *version_string = "2.7.2.3";
--- 1 ----
! char *version_string = "2.7.2.3.f.2";
diff -rcp2N gcc-2.7.2.3/c-gperf.h gcc-2.7.2.3.f.2/c-gperf.h
*** gcc-2.7.2.3/c-gperf.h	Fri Mar  4 19:15:53 1994
--- gcc-2.7.2.3.f.2/c-gperf.h	Mon Sep 29 20:55:29 1997
***************
*** 1,15 ****
  /* C code produced by gperf version 2.5 (GNU C++ version) */
! /* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ c-parse.gperf  */
  struct resword { char *name; short token; enum rid rid; };
  
! #define TOTAL_KEYWORDS 79
  #define MIN_WORD_LENGTH 2
  #define MAX_WORD_LENGTH 20
! #define MIN_HASH_VALUE 10
! #define MAX_HASH_VALUE 144
! /* maximum key range = 135, duplicates = 0 */
  
  #ifdef __GNUC__
! __inline
  #endif
  static unsigned int
--- 1,16 ----
  /* C code produced by gperf version 2.5 (GNU C++ version) */
! /* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ ../g77-new/c-parse.gperf  */
! /* Command-line: gperf -p -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,$ c-parse.gperf  */ 
  struct resword { char *name; short token; enum rid rid; };
  
! #define TOTAL_KEYWORDS 81
  #define MIN_WORD_LENGTH 2
  #define MAX_WORD_LENGTH 20
! #define MIN_HASH_VALUE 13
! #define MAX_HASH_VALUE 223
! /* maximum key range = 211, duplicates = 0 */
  
  #ifdef __GNUC__
! inline
  #endif
  static unsigned int
*************** hash (str, len)
*** 20,36 ****
    static unsigned char asso_values[] =
      {
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145,  25, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
!      145, 145, 145, 145, 145,   1, 145,  46,   8,  15,
!       61,   6,  36,  48,   3,   5, 145,  18,  63,  25,
!       29,  76,   1, 145,  13,   2,   1,  51,  37,   9,
!        9,   1,   3, 145, 145, 145, 145, 145,
      };
    register int hval = len;
--- 21,37 ----
    static unsigned char asso_values[] =
      {
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224,  36, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
!      224, 224, 224, 224, 224,   1, 224,  68,   6,  51,
!       53,   6,  34,  36,   2,  13, 224,   2,  68,  16,
!       48,  66,   4, 224,  19,  98,   1,  22,  38,   2,
!       12,   2,   2, 224, 224, 224, 224, 224,
      };
    register int hval = len;
*************** hash (str, len)
*** 44,47 ****
--- 45,49 ----
        case 1:
          hval += asso_values[str[0]];
+         break;
      }
    return hval + asso_values[str[len - 1]];
*************** hash (str, len)
*** 50,166 ****
  static struct resword wordlist[] =
  {
!   {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!   {"",}, 
!   {"int",  TYPESPEC, RID_INT},
!   {"",}, {"",}, 
!   {"__typeof__",  TYPEOF, NORID},
!   {"__signed__",  TYPESPEC, RID_SIGNED},
!   {"__imag__",  IMAGPART, NORID},
!   {"switch",  SWITCH, NORID},
!   {"__inline__",  SCSPEC, RID_INLINE},
!   {"else",  ELSE, NORID},
!   {"__iterator__",  SCSPEC, RID_ITERATOR},
!   {"__inline",  SCSPEC, RID_INLINE},
!   {"__extension__",  EXTENSION, NORID},
!   {"struct",  STRUCT, NORID},
!   {"__real__",  REALPART, NORID},
!   {"__const",  TYPE_QUAL, RID_CONST},
!   {"while",  WHILE, NORID},
!   {"__const__",  TYPE_QUAL, RID_CONST},
!   {"case",  CASE, NORID},
!   {"__complex__",  TYPESPEC, RID_COMPLEX},
!   {"__iterator",  SCSPEC, RID_ITERATOR},
!   {"bycopy",  TYPE_QUAL, RID_BYCOPY},
!   {"",}, {"",}, {"",}, 
!   {"__complex",  TYPESPEC, RID_COMPLEX},
!   {"",}, 
!   {"in",  TYPE_QUAL, RID_IN},
!   {"break",  BREAK, NORID},
!   {"@defs",  DEFS, NORID},
!   {"",}, {"",}, {"",}, 
!   {"extern",  SCSPEC, RID_EXTERN},
!   {"if",  IF, NORID},
!   {"typeof",  TYPEOF, NORID},
!   {"typedef",  SCSPEC, RID_TYPEDEF},
!   {"__typeof",  TYPEOF, NORID},
!   {"sizeof",  SIZEOF, NORID},
!   {"",}, 
!   {"return",  RETURN, NORID},
!   {"const",  TYPE_QUAL, RID_CONST},
!   {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
!   {"@private",  PRIVATE, NORID},
!   {"@selector",  SELECTOR, NORID},
!   {"__volatile",  TYPE_QUAL, RID_VOLATILE},
!   {"__asm__",  ASM_KEYWORD, NORID},
!   {"",}, {"",}, 
!   {"continue",  CONTINUE, NORID},
!   {"__alignof__",  ALIGNOF, NORID},
!   {"__imag",  IMAGPART, NORID},
!   {"__attribute__",  ATTRIBUTE, NORID},
!   {"",}, {"",}, 
!   {"__attribute",  ATTRIBUTE, NORID},
!   {"for",  FOR, NORID},
!   {"",}, 
!   {"@encode",  ENCODE, NORID},
!   {"id",  OBJECTNAME, RID_ID},
!   {"static",  SCSPEC, RID_STATIC},
!   {"@interface",  INTERFACE, NORID},
!   {"",}, 
!   {"__signed",  TYPESPEC, RID_SIGNED},
!   {"",}, 
!   {"__label__",  LABEL, NORID},
!   {"",}, {"",}, 
!   {"__asm",  ASM_KEYWORD, NORID},
!   {"char",  TYPESPEC, RID_CHAR},
!   {"",}, 
!   {"inline",  SCSPEC, RID_INLINE},
!   {"out",  TYPE_QUAL, RID_OUT},
!   {"register",  SCSPEC, RID_REGISTER},
!   {"__real",  REALPART, NORID},
!   {"short",  TYPESPEC, RID_SHORT},
!   {"",}, 
!   {"enum",  ENUM, NORID},
!   {"inout",  TYPE_QUAL, RID_INOUT},
!   {"",}, 
!   {"oneway",  TYPE_QUAL, RID_ONEWAY},
!   {"union",  UNION, NORID},
!   {"",}, 
!   {"__alignof",  ALIGNOF, NORID},
!   {"",}, 
!   {"@implementation",  IMPLEMENTATION, NORID},
!   {"",}, 
!   {"@class",  CLASS, NORID},
!   {"",}, 
!   {"@public",  PUBLIC, NORID},
!   {"asm",  ASM_KEYWORD, NORID},
!   {"",}, {"",}, {"",}, {"",}, {"",}, 
!   {"default",  DEFAULT, NORID},
!   {"",}, 
!   {"void",  TYPESPEC, RID_VOID},
!   {"",}, 
!   {"@protected",  PROTECTED, NORID},
!   {"@protocol",  PROTOCOL, NORID},
!   {"",}, {"",}, {"",}, 
!   {"volatile",  TYPE_QUAL, RID_VOLATILE},
!   {"",}, {"",}, 
!   {"signed",  TYPESPEC, RID_SIGNED},
!   {"float",  TYPESPEC, RID_FLOAT},
!   {"@end",  END, NORID},
!   {"",}, {"",}, 
!   {"unsigned",  TYPESPEC, RID_UNSIGNED},
!   {"@compatibility_alias",  ALIAS, NORID},
!   {"double",  TYPESPEC, RID_DOUBLE},
!   {"",}, {"",}, 
!   {"auto",  SCSPEC, RID_AUTO},
!   {"",}, 
!   {"goto",  GOTO, NORID},
!   {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!   {"do",  DO, NORID},
!   {"",}, {"",}, {"",}, {"",}, 
!   {"long",  TYPESPEC, RID_LONG},
  };
  
  #ifdef __GNUC__
! __inline
  #endif
  struct resword *
--- 52,184 ----
  static struct resword wordlist[] =
  {
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, {"",}, {"",}, {"",}, 
!       {"__typeof__",  TYPEOF, NORID},
!       {"",}, {"",}, {"",}, {"",}, 
!       {"int",  TYPESPEC, RID_INT},
!       {"break",  BREAK, NORID},
!       {"",}, 
!       {"__extension__",  EXTENSION, NORID},
!       {"",}, 
!       {"__imag__",  IMAGPART, NORID},
!       {"",}, 
!       {"__inline__",  SCSPEC, RID_INLINE},
!       {"while",  WHILE, NORID},
!       {"__iterator__",  SCSPEC, RID_ITERATOR},
!       {"__inline",  SCSPEC, RID_INLINE},
!       {"__real__",  REALPART, NORID},
!       {"",}, 
!       {"__restrict",  TYPE_QUAL, RID_RESTRICT},
!       {"",}, 
!       {"__restrict__",  TYPE_QUAL, RID_RESTRICT},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"__iterator",  SCSPEC, RID_ITERATOR},
!       {"__typeof",  TYPEOF, NORID},
!       {"typeof",  TYPEOF, NORID},
!       {"typedef",  SCSPEC, RID_TYPEDEF},
!       {"",}, 
!       {"enum",  ENUM, NORID},
!       {"if",  IF, NORID},
!       {"",}, {"",}, 
!       {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
!       {"",}, {"",}, 
!       {"__volatile",  TYPE_QUAL, RID_VOLATILE},
!       {"__imag",  IMAGPART, NORID},
!       {"",}, {"",}, {"",}, 
!       {"__const",  TYPE_QUAL, RID_CONST},
!       {"extern",  SCSPEC, RID_EXTERN},
!       {"__const__",  TYPE_QUAL, RID_CONST},
!       {"in",  TYPE_QUAL, RID_IN},
!       {"__complex__",  TYPESPEC, RID_COMPLEX},
!       {"bycopy",  TYPE_QUAL, RID_BYCOPY},
!       {"",}, {"",}, 
!       {"id",  OBJECTNAME, RID_ID},
!       {"@private",  PRIVATE, NORID},
!       {"@selector",  SELECTOR, NORID},
!       {"out",  TYPE_QUAL, RID_OUT},
!       {"",}, 
!       {"__complex",  TYPESPEC, RID_COMPLEX},
!       {"return",  RETURN, NORID},
!       {"for",  FOR, NORID},
!       {"",}, 
!       {"__asm__",  ASM_KEYWORD, NORID},
!       {"",}, 
!       {"__label__",  LABEL, NORID},
!       {"oneway",  TYPE_QUAL, RID_ONEWAY},
!       {"__alignof__",  ALIGNOF, NORID},
!       {"register",  SCSPEC, RID_REGISTER},
!       {"__attribute__",  ATTRIBUTE, NORID},
!       {"",}, 
!       {"inout",  TYPE_QUAL, RID_INOUT},
!       {"__attribute",  ATTRIBUTE, NORID},
!       {"double",  TYPESPEC, RID_DOUBLE},
!       {"union",  UNION, NORID},
!       {"",}, 
!       {"__asm",  ASM_KEYWORD, NORID},
!       {"",}, {"",}, 
!       {"inline",  SCSPEC, RID_INLINE},
!       {"__real",  REALPART, NORID},
!       {"default",  DEFAULT, NORID},
!       {"",}, 
!       {"@encode",  ENCODE, NORID},
!       {"",}, {"",}, 
!       {"@interface",  INTERFACE, NORID},
!       {"",}, {"",}, 
!       {"asm",  ASM_KEYWORD, NORID},
!       {"",}, 
!       {"const",  TYPE_QUAL, RID_CONST},
!       {"float",  TYPESPEC, RID_FLOAT},
!       {"goto",  GOTO, NORID},
!       {"void",  TYPESPEC, RID_VOID},
!       {"",}, 
!       {"__signed__",  TYPESPEC, RID_SIGNED},
!       {"",}, 
!       {"__alignof",  ALIGNOF, NORID},
!       {"continue",  CONTINUE, NORID},
!       {"else",  ELSE, NORID},
!       {"@implementation",  IMPLEMENTATION, NORID},
!       {"@public",  PUBLIC, NORID},
!       {"",}, 
!       {"@protected",  PROTECTED, NORID},
!       {"switch",  SWITCH, NORID},
!       {"volatile",  TYPE_QUAL, RID_VOLATILE},
!       {"do",  DO, NORID},
!       {"",}, {"",}, 
!       {"struct",  STRUCT, NORID},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"@protocol",  PROTOCOL, NORID},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"auto",  SCSPEC, RID_AUTO},
!       {"sizeof",  SIZEOF, NORID},
!       {"@end",  END, NORID},
!       {"char",  TYPESPEC, RID_CHAR},
!       {"",}, {"",}, 
!       {"@defs",  DEFS, NORID},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, 
!       {"long",  TYPESPEC, RID_LONG},
!       {"",}, {"",}, 
!       {"case",  CASE, NORID},
!       {"__signed",  TYPESPEC, RID_SIGNED},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"short",  TYPESPEC, RID_SHORT},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, 
!       {"unsigned",  TYPESPEC, RID_UNSIGNED},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, {"",}, 
!       {"signed",  TYPESPEC, RID_SIGNED},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"@class",  CLASS, NORID},
!       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
!       {"",}, {"",}, 
!       {"@compatibility_alias",  ALIAS, NORID},
!       {"",}, {"",}, 
!       {"static",  SCSPEC, RID_STATIC},
  };
  
  #ifdef __GNUC__
! inline
  #endif
  struct resword *