This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

[PATCH] Backport patchset for gcc-2_95-branch (was: Re: State of maturity for gcc 2.95.3 and gcc 2.96)


Hi,

as promised, here is a possible backport patchset for the gcc-2_95-branch. It 
contains a bunch of backports from the mainline I did end of June. If someone 
dares to review and comment on it, that would be really nice.

It's heavily tested on powerpc-linux-gnu, but on nothing else. It causes no 
testsuite regressions and works fine in practice too. If run against the 
current mainline testsuite, I get the following execution fails:

FAIL: gcc.c-torture/execute/20000412-2.c execution,  -O1
FAIL: gcc.c-torture/execute/20000412-2.c execution,  -O2
FAIL: gcc.c-torture/execute/20000412-2.c execution,  -O3
FAIL: gcc.c-torture/execute/20000412-2.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/20000412-2.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/20000412-2.c execution,  -Os
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O0
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O1
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O2
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O3
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/20000917-1.c execution,  -Os
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O0
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O1
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O2
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O3
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O3 -fomit-frame-pointer 
-funroll-loops
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O3 -fomit-frame-pointer 
-funroll-all-loops -finline-functions
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/20001009-2.c execution,  -Os
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O0
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O1
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O2
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O3
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/991202-3.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/991202-3.c execution,  -Os
FAIL: gcc.c-torture/execute/align-1.c execution,  -O0
FAIL: gcc.c-torture/execute/align-1.c execution,  -O1
FAIL: gcc.c-torture/execute/align-1.c execution,  -O2
FAIL: gcc.c-torture/execute/align-1.c execution,  -O3
FAIL: gcc.c-torture/execute/align-1.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/align-1.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/align-1.c execution,  -Os
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -O1
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -O2
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -O3
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -O3 -fomit-frame-pointer
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -O3 -g
FAIL: gcc.c-torture/execute/widechar-2.c execution,  -Os
FAIL: gcc.dg/20000623-1.c execution test

I didn't care too much about about compilation fails and cpp related stuff.

All but Geoff's loop fix have been accepted for the mainline.

Franz.

gcc/ChangeLog
2000-10-14  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>

       2000-03-17  Martin v. Löwis  <loewis@informatik.hu-berlin.de>
       * calls.c (special_function_p): It is only malloc if it returns
       Pmode.

       1999-12-14  Bernd Schmidt  <bernds@cygnus.co.uk>
       * combine.c (combine_simplify_rtx): Don't make shared rtl.
       (simplify_logical): Likewise.

       1999-12-16  David S. Miller  <davem@redhat.com>
       * expr.c (emit_move_insn_1): Only emit clobbers if one of
       the outputs is a SUBREG.

       Wed Sep 22 17:35:55 1999  Michael Meissner  <meissner@cygnus.com>
       * expr.c (emit_move_insn_1): If we are copying a complex that fits
       in one word or less (complex char, complex short, or on 64 bit
       systems complex float) to/from a hard register, copy it through
       memory instead of dying in gen_{real,imag}part.  If we have a
       short complex type, prevent inlining since it allocates stack
       memory.

       Sat May 20 07:27:35 2000  Alexandre Oliva  <aoliva@cygnus.com>
       * fold-const.c (make_range): Handle degenerated intervals.
       Fixes c-torture/execute/991221-1.c

       2000-07-15  Michael Meissner  <meissner@redhat.com>
       * fold-const.c (fold): When optimizing FOO++ == CONST into ++FOO
       == CONST + INCREMENT, don't overwrite the tree node for FOO++,
       create a new node instead.

       2000-03-06  Mark Mitchell  <mark@codesourcery.com>
       * function.c (free_temps_for_rtl_expr): Don't free slots
       that have been pushed into a higher level.

       Tue Sep 14 01:33:15 1999  Andreas Schwab  <schwab@suse.de>
       * loop.c (strength_reduce): Don't call reg_used_between_p if the
       insn from BL2 is after the insn from BL.

       Tue Dec 14 18:13:32 1999  J"orn Rennecke <amylaar@cygnus.co.uk>
       * loop.c (strength_reduce): Fix sign of giv lifetime calculation
       for givs made from biv increments.

       Mon Feb 28 11:34:43 2000  J"orn Rennecke <amylaar@cygnus.co.uk>
       * loop.c (reg_in_basic_block_p): Don't abort when falling through
       to the end of the function.

       Sat Apr 22 22:35:38 MET DST 2000  Jan Hubicka  <jh@suse.cz>
       * loop.c (strength_reduce): Fix biv removal code.

       2000-04-26  Geoff Keating  <geoffk@cygnus.com>
       * loop.c (basic_induction_var): If a REG is set from something
       that is not a biv, then the REG is not a biv.  Even if it is
       earlier set from something that is a biv.

       2000-09-29  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>
       * loop.c (check_final_value): A GIV is not replaceable if used
       before set.

       2000-02-26  Geoff Keating  <geoffk@cygnus.com>
       * reload1.c (do_output_reload): Check reg_reloaded_valid before
       looking at reg_reloaded_contents.

       2000-03-22  Richard Henderson  <rth@cygnus.com>
       * stmt.c (expand_asm_operands): Don't promote the temporary.

       Thu Oct 14 03:59:57 1999  Stephane Carrez  <stcarrez@worldnet.fr>
       * stor-layout.c (layout_union): Use HOST_WIDE_INT for const_size;
       check for member bit-size overflow and use var_size if it occurs.
       (layout_record): Use bitsize_int() to define the type size in bits.
       Likewise for computation and assignment to DECL_FIELD_BITPOS.
       (layout_decl): Likewise when assigning to DECL_SIZE.

       Thu Oct 28 10:20:02 1999  Geoffrey Keating  <geoffk@cygnus.com>
       * config/rs6000/rs6000.md (movsf): Don't convert a SUBREG
       of the function return register into a plain REG until
       after function inlining is done.

libio/ChangeLog
2000-09-23  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>

       * stdstreams.cc: Include <libio.h>, not "libio.h".
       * iolibio.h: Likewise.
       (_IO_pos_BAD): Use _IO_off_t instead of _IO_fpos_t.
       * libio.h (_IO_USER_LOCK): Define.

1999-12-22  Jakub Jelinek  <jakub@redhat.com>

       * libio.h (_IO_cookie_io_functions_t): Use _IO_off_t instead of
       _IO_fpos_t.
       (_IO_seekoff, _IO_seekpos): Likewise. Use _IO_off64_t instead of
       _IO_fpos64_t.
       * libioP.h (_IO_seekoff_t, _IO_seekpos_t, _IO_seek_t): Likewise.
       (_IO_seekoff, _IO_seekpos): Likewise.
       (_IO_default_seekoff, _IO_default_seekpos): Likewise.
       (_IO_default_seek): Likewise.
       (_IO_file_seekoff, _IO_file_seek, _IO_str_seekoff): Likewise.
       * streambuf.h (streampos): Typedef to _IO_off_t resp. _IO_off64_t.
       * parsestream.h (class parsebuf::pos_at_line_start): Change type
       to _IO_off_t.
Index: gcc/ChangeLog
===================================================================
RCS file: /cvs/gcc/egcs/gcc/ChangeLog,v
retrieving revision 1.3667.4.261
diff -u -p -r1.3667.4.261 ChangeLog
--- gcc/ChangeLog	2000/08/25 17:14:36	1.3667.4.261
+++ gcc/ChangeLog	2000/10/14 18:54:12
@@ -1,3 +1,81 @@
+2000-10-14  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>
+
+	2000-03-17  Martin v. Löwis  <loewis@informatik.hu-berlin.de>
+	* calls.c (special_function_p): It is only malloc if it returns
+	Pmode.
+
+	1999-12-14  Bernd Schmidt  <bernds@cygnus.co.uk>
+	* combine.c (combine_simplify_rtx): Don't make shared rtl.
+	(simplify_logical): Likewise.
+
+	1999-12-16  David S. Miller  <davem@redhat.com>
+	* expr.c (emit_move_insn_1): Only emit clobbers if one of
+	the outputs is a SUBREG.
+
+	Wed Sep 22 17:35:55 1999  Michael Meissner  <meissner@cygnus.com>
+	* expr.c (emit_move_insn_1): If we are copying a complex that fits
+	in one word or less (complex char, complex short, or on 64 bit
+	systems complex float) to/from a hard register, copy it through
+	memory instead of dying in gen_{real,imag}part.  If we have a
+	short complex type, prevent inlining since it allocates stack
+	memory.
+
+	Sat May 20 07:27:35 2000  Alexandre Oliva  <aoliva@cygnus.com>
+	* fold-const.c (make_range): Handle degenerated intervals.
+	Fixes c-torture/execute/991221-1.c
+
+	2000-07-15  Michael Meissner  <meissner@redhat.com>
+	* fold-const.c (fold): When optimizing FOO++ == CONST into ++FOO
+	== CONST + INCREMENT, don't overwrite the tree node for FOO++,
+	create a new node instead.
+
+	2000-03-06  Mark Mitchell  <mark@codesourcery.com>
+	* function.c (free_temps_for_rtl_expr): Don't free slots
+	that have been pushed into a higher level.
+
+	Tue Sep 14 01:33:15 1999  Andreas Schwab  <schwab@suse.de>
+	* loop.c (strength_reduce): Don't call reg_used_between_p if the
+	insn from BL2 is after the insn from BL.
+
+	Tue Dec 14 18:13:32 1999  J"orn Rennecke <amylaar@cygnus.co.uk>
+	* loop.c (strength_reduce): Fix sign of giv lifetime calculation
+	for givs made from biv increments.
+
+	Mon Feb 28 11:34:43 2000  J"orn Rennecke <amylaar@cygnus.co.uk>
+	* loop.c (reg_in_basic_block_p): Don't abort when falling through
+	to the end of the function.
+
+	Sat Apr 22 22:35:38 MET DST 2000  Jan Hubicka  <jh@suse.cz>
+	* loop.c (strength_reduce): Fix biv removal code.
+
+	2000-04-26  Geoff Keating  <geoffk@cygnus.com>
+	* loop.c (basic_induction_var): If a REG is set from something
+	that is not a biv, then the REG is not a biv.  Even if it is
+	earlier set from something that is a biv.
+
+	2000-09-29  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>
+	* loop.c (check_final_value): A GIV is not replaceable if used
+	before set.
+
+	2000-02-26  Geoff Keating  <geoffk@cygnus.com>
+	* reload1.c (do_output_reload): Check reg_reloaded_valid before
+	looking at reg_reloaded_contents.
+
+	2000-03-22  Richard Henderson  <rth@cygnus.com>
+	* stmt.c (expand_asm_operands): Don't promote the temporary.
+
+	Thu Oct 14 03:59:57 1999  Stephane Carrez  <stcarrez@worldnet.fr>
+	* stor-layout.c (layout_union): Use HOST_WIDE_INT for const_size;
+	check for member bit-size overflow and use var_size if it occurs.
+	(layout_record): Use bitsize_int() to define the type size in bits.
+	Likewise for computation and assignment to DECL_FIELD_BITPOS.
+	(layout_decl): Likewise when assigning to DECL_SIZE. 
+
+	Thu Oct 28 10:20:02 1999  Geoffrey Keating  <geoffk@cygnus.com>
+	* config/rs6000/rs6000.md (movsf): Don't convert a SUBREG
+	of the function return register into a plain REG until
+	after function inlining is done.
+
 2000-08-25  David Edelsohn  <edelsohn@gnu.org>
 
 	* collect2.c (use_import_list): Always return 0 (disable).
Index: gcc/calls.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/calls.c,v
retrieving revision 1.57
diff -u -p -r1.57 calls.c
--- gcc/calls.c	1999/05/08 01:58:39	1.57
+++ gcc/calls.c	2000/10/14 18:54:16
@@ -590,9 +590,10 @@ special_function_p (name, fndecl, return
 	*is_longjmp = 1;
       /* XXX should have "malloc" attribute on functions instead
 	 of recognizing them by name.  */
-      else if (! strcmp (tname, "malloc")
-	       || ! strcmp (tname, "calloc")
-	       || ! strcmp (tname, "realloc")
+      else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl))) == Pmode
+		&& (! strcmp (tname, "malloc")
+		    || ! strcmp (tname, "calloc")
+		    || ! strcmp (tname, "realloc")))
 	       /* Note use of NAME rather than TNAME here.  These functions
 		  are only reserved when preceded with __.  */
 	       || ! strcmp (name, "__vn")	/* mangled __builtin_vec_new */
Index: gcc/combine.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/combine.c,v
retrieving revision 1.62.4.1
diff -u -p -r1.62.4.1 combine.c
--- gcc/combine.c	1999/10/18 07:52:32	1.62.4.1
+++ gcc/combine.c	2000/10/14 18:54:35
@@ -4015,7 +4015,8 @@ simplify_rtx (x, op0_mode, last, in_dest
 			 gen_binary (MULT, mode,
 				     XEXP (XEXP (x, 0), 0), XEXP (x, 1)),
 			 gen_binary (MULT, mode,
-				     XEXP (XEXP (x, 0), 1), XEXP (x, 1))));
+				     XEXP (XEXP (x, 0), 1),
+				     copy_rtx (XEXP (x, 1)))));
 
 	  if (GET_CODE (x) != MULT)
 	    return x;
@@ -4954,7 +4955,8 @@ simplify_logical (x, last)
 	  x = apply_distributive_law
 	    (gen_binary (GET_CODE (op0), mode,
 			 gen_binary (AND, mode, XEXP (op0, 0), op1),
-			 gen_binary (AND, mode, XEXP (op0, 1), op1)));
+			 gen_binary (AND, mode, XEXP (op0, 1),
+				     copy_rtx (op1))));
 	  if (GET_CODE (x) != AND)
 	    return x;
 	}
@@ -4963,7 +4965,8 @@ simplify_logical (x, last)
 	return apply_distributive_law
 	  (gen_binary (GET_CODE (op1), mode,
 		       gen_binary (AND, mode, XEXP (op1, 0), op0),
-		       gen_binary (AND, mode, XEXP (op1, 1), op0)));
+		       gen_binary (AND, mode, XEXP (op1, 1),
+				   copy_rtx (op0))));
 
       /* Similarly, taking advantage of the fact that
 	 (and (not A) (xor B C)) == (xor (ior A B) (ior A C))  */
@@ -4972,13 +4975,14 @@ simplify_logical (x, last)
 	return apply_distributive_law
 	  (gen_binary (XOR, mode,
 		       gen_binary (IOR, mode, XEXP (op0, 0), XEXP (op1, 0)),
-		       gen_binary (IOR, mode, XEXP (op0, 0), XEXP (op1, 1))));
+		       gen_binary (IOR, mode, copy_rtx (XEXP (op0, 0)),
+				   XEXP (op1, 1))));
 							    
       else if (GET_CODE (op1) == NOT && GET_CODE (op0) == XOR)
 	return apply_distributive_law
 	  (gen_binary (XOR, mode,
 		       gen_binary (IOR, mode, XEXP (op1, 0), XEXP (op0, 0)),
-		       gen_binary (IOR, mode, XEXP (op1, 0), XEXP (op0, 1))));
+		       gen_binary (IOR, mode, copy_rtx (XEXP (op1, 0)), XEXP (op0, 1))));
       break;
 
     case IOR:
@@ -5004,7 +5008,8 @@ simplify_logical (x, last)
 	  x = apply_distributive_law
 	    (gen_binary (AND, mode,
 			 gen_binary (IOR, mode, XEXP (op0, 0), op1),
-			 gen_binary (IOR, mode, XEXP (op0, 1), op1)));
+			 gen_binary (IOR, mode, XEXP (op0, 1),
+				     copy_rtx (op1))));
 
 	  if (GET_CODE (x) != IOR)
 	    return x;
@@ -5015,7 +5020,8 @@ simplify_logical (x, last)
 	  x = apply_distributive_law
 	    (gen_binary (AND, mode,
 			 gen_binary (IOR, mode, XEXP (op1, 0), op0),
-			 gen_binary (IOR, mode, XEXP (op1, 1), op0)));
+			 gen_binary (IOR, mode, XEXP (op1, 1),
+				     copy_rtx (op0))));
 
 	  if (GET_CODE (x) != IOR)
 	    return x;
Index: gcc/cse.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/cse.c,v
retrieving revision 1.72.4.5
diff -u -p -r1.72.4.5 cse.c
--- gcc/cse.c	2000/01/04 09:24:24	1.72.4.5
+++ gcc/cse.c	2000/10/14 18:54:46
@@ -694,8 +694,6 @@ static void check_fold_consts	PROTO((PTR
 static struct cse_reg_info* get_cse_reg_info PROTO((int));
 static void free_cse_reg_info   PROTO((splay_tree_value));
 static void flush_hash_table	PROTO((void));
-
-extern int rtx_equal_function_value_matters;
 
 /* Dump the expressions in the equivalence class indicated by CLASSP.
    This function is used only for debugging.  */
Index: gcc/expr.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/expr.c,v
retrieving revision 1.144.4.3
diff -u -p -r1.144.4.3 expr.c
--- gcc/expr.c	1999/06/30 22:59:55	1.144.4.3
+++ gcc/expr.c	2000/10/14 18:55:26
@@ -2679,19 +2679,79 @@ emit_move_insn_1 (x, y)
 	}
       else
 	{
-	  /* Show the output dies here.  This is necessary for pseudos;
+	  rtx realpart_x, realpart_y;
+	  rtx imagpart_x, imagpart_y;
+
+	  /* If this is a complex value with each part being smaller than a
+	     word, the usual calling sequence will likely pack the pieces into
+	     a single register.  Unfortunately, SUBREG of hard registers only
+	     deals in terms of words, so we have a problem converting input
+	     arguments to the CONCAT of two registers that is used elsewhere
+	     for complex values.  If this is before reload, we can copy it into
+	     memory and reload.  FIXME, we should see about using extract and
+	     insert on integer registers, but complex short and complex char
+	     variables should be rarely used.  */
+	  if (GET_MODE_BITSIZE (mode) < 2*BITS_PER_WORD
+	      && (reload_in_progress | reload_completed) == 0)
+	    {
+	      int packed_dest_p = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
+	      int packed_src_p  = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
+
+	      if (packed_dest_p || packed_src_p)
+		{
+		  enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
+					       ? MODE_FLOAT : MODE_INT);
+
+		  enum machine_mode reg_mode = 
+		    mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
+
+		  if (reg_mode != BLKmode)
+		    {
+		      rtx mem = assign_stack_temp (reg_mode,
+						   GET_MODE_SIZE (mode), 0);
+
+		      rtx cmem = change_address (mem, mode, NULL_RTX);
+
+		      current_function_cannot_inline
+			= "function uses short complex types";
+
+		      if (packed_dest_p)
+			{
+			  rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
+			  emit_move_insn_1 (cmem, y);
+			  return emit_move_insn_1 (sreg, mem);
+			}
+		      else
+			{
+			  rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
+			  emit_move_insn_1 (mem, sreg);
+			  return emit_move_insn_1 (x, cmem);
+			}
+		    }
+		}
+	    }
+
+	  realpart_x = gen_realpart (submode, x);
+	  realpart_y = gen_realpart (submode, y);
+	  imagpart_x = gen_imagpart (submode, x);
+	  imagpart_y = gen_imagpart (submode, y);
+
+	  /* Show the output dies here.  This is necessary for SUBREGs
+	     of pseudos since we cannot track their lifetimes correctly;
 	     hard regs shouldn't appear here except as return values.
 	     We never want to emit such a clobber after reload.  */
 	  if (x != y
-	      && ! (reload_in_progress || reload_completed))
+	      && ! (reload_in_progress || reload_completed)
+	      && (GET_CODE (realpart_x) == SUBREG
+		  || GET_CODE (imagpart_x) == SUBREG))
 	    {
 	      emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
 	    }
 
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_realpart (submode, x), gen_realpart (submode, y)));
+		     (realpart_x, realpart_y));
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_imagpart (submode, x), gen_imagpart (submode, y)));
+		     (imagpart_x, imagpart_y));
 	}
 
       return get_last_insn ();
@@ -2703,6 +2763,8 @@ emit_move_insn_1 (x, y)
   else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
     {
       rtx last_insn = 0;
+      rtx seq;
+      int need_clobber;
       
 #ifdef PUSH_ROUNDING
 
@@ -2715,15 +2777,9 @@ emit_move_insn_1 (x, y)
 	}
 #endif
 			     
-      /* Show the output dies here.  This is necessary for pseudos;
-	 hard regs shouldn't appear here except as return values.
-	 We never want to emit such a clobber after reload.  */
-      if (x != y
-	  && ! (reload_in_progress || reload_completed))
-	{
-	  emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
-	}
+      start_sequence ();
 
+      need_clobber = 0;
       for (i = 0;
 	   i < (GET_MODE_SIZE (mode)  + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
 	   i++)
@@ -2745,8 +2801,26 @@ emit_move_insn_1 (x, y)
 	  if (xpart == 0 || ypart == 0)
 	    abort ();
 
+	  need_clobber |= (GET_CODE (xpart) == SUBREG);
+
 	  last_insn = emit_move_insn (xpart, ypart);
 	}
+
+      seq = gen_sequence ();
+      end_sequence ();
+
+      /* Show the output dies here.  This is necessary for SUBREGs
+	 of pseudos since we cannot track their lifetimes correctly;
+	 hard regs shouldn't appear here except as return values.
+	 We never want to emit such a clobber after reload.  */
+      if (x != y
+	  && ! (reload_in_progress || reload_completed)
+	  && need_clobber != 0)
+	{
+	  emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
+	}
+
+      emit_insn (seq);
 
       return last_insn;
     }
Index: gcc/fold-const.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/fold-const.c,v
retrieving revision 1.64.4.6
diff -u -p -r1.64.4.6 fold-const.c
--- gcc/fold-const.c	1999/12/24 18:05:27	1.64.4.6
+++ gcc/fold-const.c	2000/10/14 18:55:33
@@ -3259,8 +3259,17 @@ make_range (exp, pin_p, plow, phigh)
 	      low = range_binop (PLUS_EXPR, type, n_high, 0,
 				 integer_one_node, 0);
 	      high = range_binop (MINUS_EXPR, type, n_low, 0,
-				 integer_one_node, 0);
-	      in_p = ! in_p;
+				  integer_one_node, 0);
+
+	      /* If the range is of the form +/- [ x+1, x ], we won't
+		 be able to normalize it.  But then, it represents the
+		 whole range or the empty set, so make it +/- [ -, - ].
+	      */
+	      if (tree_int_cst_equal (n_low, low)
+		  && tree_int_cst_equal (n_high, high))
+		low = high = 0;
+	      else
+		in_p = ! in_p;
 	    }
 	  else
 	    low = n_low, high = n_high;
@@ -5625,8 +5634,16 @@ fold (expr) 
 		tree newconst
 		  = fold (build (PLUS_EXPR, TREE_TYPE (varop),
 				 constop, TREE_OPERAND (varop, 1)));
-		TREE_SET_CODE (varop, PREINCREMENT_EXPR);
 
+		/* Do not overwrite the current varop to be a preincrement,
+		   create a new node so that we won't confuse our caller who
+		   might create trees and throw them away, reusing the
+		   arguments that they passed to build.  This shows up in
+		   the THEN or ELSE parts of ?: being postincrements.  */
+		varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
+			       TREE_OPERAND (varop, 0),
+			       TREE_OPERAND (varop, 1));
+
 		/* If VAROP is a reference to a bitfield, we must mask
 		   the constant by the width of the field.  */
 		if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
@@ -5669,9 +5686,9 @@ fold (expr) 
 		  }
 							 
 
-		t = build (code, type, TREE_OPERAND (t, 0),
-			   TREE_OPERAND (t, 1));
-		TREE_OPERAND (t, constopnum) = newconst;
+		t = build (code, type,
+			   (constopnum == 0) ? newconst : varop,
+			   (constopnum == 1) ? newconst : varop);
 		return t;
 	      }
 	  }
@@ -5684,7 +5701,15 @@ fold (expr) 
 		tree newconst
 		  = fold (build (MINUS_EXPR, TREE_TYPE (varop),
 				 constop, TREE_OPERAND (varop, 1)));
-		TREE_SET_CODE (varop, PREDECREMENT_EXPR);
+
+		/* Do not overwrite the current varop to be a predecrement,
+		   create a new node so that we won't confuse our caller who
+		   might create trees and throw them away, reusing the
+		   arguments that they passed to build.  This shows up in
+		   the THEN or ELSE parts of ?: being postdecrements.  */
+		varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
+			       TREE_OPERAND (varop, 0),
+			       TREE_OPERAND (varop, 1));
 
 		if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
 		    && DECL_BIT_FIELD(TREE_OPERAND
@@ -5723,9 +5748,9 @@ fold (expr) 
 		  }
 							 
 
-		t = build (code, type, TREE_OPERAND (t, 0),
-			   TREE_OPERAND (t, 1));
-		TREE_OPERAND (t, constopnum) = newconst;
+		t = build (code, type,
+			   (constopnum == 0) ? newconst : varop,
+			   (constopnum == 1) ? newconst : varop);
 		return t;
 	      }
 	  }
Index: gcc/function.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/function.c,v
retrieving revision 1.90.4.3
diff -u -p -r1.90.4.3 function.c
--- gcc/function.c	2000/05/24 06:01:57	1.90.4.3
+++ gcc/function.c	2000/10/14 18:55:42
@@ -1428,7 +1428,16 @@ free_temps_for_rtl_expr (t)
 
   for (p = temp_slots; p; p = p->next)
     if (p->rtl_expr == t)
-      p->in_use = 0;
+      {
+	/* If this slot is below the current TEMP_SLOT_LEVEL, then it
+	   needs to be preserved.  This can happen if a temporary in
+	   the RTL_EXPR was addressed; preserve_temp_slots will move
+	   the temporary into a higher level.   */
+	if (temp_slot_level <= p->level)
+	  p->in_use = 0;
+	else
+	  p->rtl_expr = NULL_TREE;
+      }
 
   combine_temp_slots ();
 }
Index: gcc/loop.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/loop.c,v
retrieving revision 1.156.4.12
diff -u -p -r1.156.4.12 loop.c
--- gcc/loop.c	2000/03/08 04:47:42	1.156.4.12
+++ gcc/loop.c	2000/10/14 18:55:56
@@ -1309,8 +1309,12 @@ reg_in_basic_block_p (insn, reg)
 	}
     }
 
-  /* The "last use" doesn't follow the "first use"??  */
-  abort ();
+  /* The "last use" that was recorded can't be found after the first
+     use.  This can happen when the last use was deleted while
+     processing an inner loop, this inner loop was then completely
+     unrolled, and the outer loop is always exited after the inner loop,
+     so that everything after the first use becomes a single basic block.  */
+  return 1;
 }
 
 /* Compute the benefit of eliminating the insns in the block whose
@@ -4080,11 +4084,11 @@ strength_reduce (scan_start, end, loop_t
 	         in-between when biv_toal_increment returns nonzero both times
 		 but we test it here in case some day some real cfg analysis
 		 gets used to set always_computable.  */
-	      && ((loop_insn_first_p (bl2->biv->insn, bl->biv->insn)
-		   && no_labels_between_p (bl2->biv->insn, bl->biv->insn))
-		  || (! reg_used_between_p (bl->biv->src_reg, bl->biv->insn,
-					    bl2->biv->insn)
-		      && no_jumps_between_p (bl->biv->insn, bl2->biv->insn)))
+	      && (loop_insn_first_p (bl2->biv->insn, bl->biv->insn)
+		  ? no_labels_between_p (bl2->biv->insn, bl->biv->insn)
+		  : (! reg_used_between_p (bl->biv->src_reg, bl->biv->insn,
+					   bl2->biv->insn)
+		     && no_jumps_between_p (bl->biv->insn, bl2->biv->insn)))
 	      && validate_change (bl->biv->insn,
 				  &SET_SRC (single_set (bl->biv->insn)),
 				  copy_rtx (src), 0))
@@ -4149,13 +4153,7 @@ strength_reduce (scan_start, end, loop_t
 				 INSN_LUID (p));
 		}
 	      /* Remove this biv from the chain.  */
-	      if (bl->next)
-		*bl = *bl->next;
-	      else
-		{
-		  *backbl = 0;
-		  break;
-		}
+	      *backbl = bl->next;
 	    }
 
 	  /* If we can't make it a giv,
@@ -4375,7 +4373,7 @@ strength_reduce (scan_start, end, loop_t
 		}
     
 	      v->last_use = last_use_insn;
-	      v->lifetime = INSN_LUID (v->insn) - INSN_LUID (last_use_insn);
+	      v->lifetime = INSN_LUID (last_use_insn) - INSN_LUID (v->insn);
 	      /* If the lifetime is zero, it means that this register is really
 		 a dead store.  So mark this as a giv that can be ignored.
 		 This will not prevent the biv from being eliminated.  */
@@ -5678,6 +5676,7 @@ check_final_value (v, loop_start, loop_e
         or all uses follow that insn in the same basic block),
      - its final value can be calculated (this condition is different
        than the one above in record_giv)
+     - it's not used before it's set
      - no assignments to the biv occur during the giv's lifetime.  */
 
 #if 0
@@ -5689,7 +5688,7 @@ check_final_value (v, loop_start, loop_e
   if ((final_value = final_giv_value (v, loop_start, loop_end, n_iterations))
       && (v->always_computable || last_use_this_basic_block (v->dest_reg, v->insn)))
     {
-      int biv_increment_seen = 0;
+      int biv_increment_seen = 0, before_giv_insn = 0;
       rtx p = v->insn;
       rtx last_giv_use;
 
@@ -5719,14 +5718,17 @@ check_final_value (v, loop_start, loop_e
 	{
 	  p = NEXT_INSN (p);
 	  if (p == loop_end)
-	    p = NEXT_INSN (loop_start);
+	    {
+	      before_giv_insn = 1;
+	      p = NEXT_INSN (loop_start);
+	    }
 	  if (p == v->insn)
 	    break;
 
 	  if (GET_CODE (p) == INSN || GET_CODE (p) == JUMP_INSN
 	      || GET_CODE (p) == CALL_INSN)
 	    {
-	      if (biv_increment_seen)
+	      if (biv_increment_seen || before_giv_insn)
 		{
 		  if (reg_mentioned_p (v->dest_reg, PATTERN (p)))
 		    {
@@ -6000,14 +6002,13 @@ basic_induction_var (x, mode, dest_reg, 
 		       <= UNITS_PER_WORD)
 		   && (GET_MODE_CLASS (GET_MODE (SET_DEST (set)))
 		       == MODE_INT)
-		   && SUBREG_REG (SET_DEST (set)) == x))
-	      && basic_induction_var (SET_SRC (set),
-				      (GET_MODE (SET_SRC (set)) == VOIDmode
-				       ? GET_MODE (x)
-				       : GET_MODE (SET_SRC (set))),
-				      dest_reg, insn,
-				      inc_val, mult_val, location))
-	    return 1;
+		   && SUBREG_REG (SET_DEST (set)) == x)))
+	    return basic_induction_var (SET_SRC (set),
+					(GET_MODE (SET_SRC (set)) == VOIDmode
+					 ? GET_MODE (x)
+					 : GET_MODE (SET_SRC (set))),
+					dest_reg, insn,
+					inc_val, mult_val, location);
 	}
       /* ... fall through ...  */
 
Index: gcc/reload1.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/reload1.c,v
retrieving revision 1.145.4.2
diff -u -p -r1.145.4.2 reload1.c
--- gcc/reload1.c	2000/03/08 05:02:46	1.145.4.2
+++ gcc/reload1.c	2000/10/14 18:56:10
@@ -7112,7 +7112,8 @@ emit_reload_insns (chain)
 	    /* We don't need to test full validity of last_regno for
 	       inherit here; we only want to know if the store actually
 	       matches the pseudo.  */
-	    if (reg_reloaded_contents[last_regno] == pseudo_no
+	    if (TEST_HARD_REG_BIT (reg_reloaded_valid, last_regno)
+		&& reg_reloaded_contents[last_regno] == pseudo_no
 		&& spill_reg_store[last_regno]
 		&& rtx_equal_p (pseudo, spill_reg_stored_to[last_regno]))
 	      delete_output_reload (insn, j, last_regno);
Index: gcc/rtl.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/rtl.h,v
retrieving revision 1.105
diff -u -p -r1.105 rtl.h
--- gcc/rtl.h	1999/04/27 17:08:34	1.105
+++ gcc/rtl.h	2000/10/14 18:56:13
@@ -887,6 +887,12 @@ extern char *note_insn_name[];
 /* For a NOTE_INSN_LIVE note, the original basic block number.  */
 #define RANGE_LIVE_ORIG_BLOCK(INSN) (XINT (INSN, 1))
 
+/* Nonzero if we need to distinguish between the return value of this function
+   and the return value of a function called by this function.  This helps
+   integrate.c.
+   This is 1 until after the rtl generation pass.  */
+extern int rtx_equal_function_value_matters;
+
 /* Generally useful functions.  */
 
 /* The following functions accept a wide integer argument.  Rather than
Index: gcc/stmt.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/stmt.c,v
retrieving revision 1.71.4.4
diff -u -p -r1.71.4.4 stmt.c
--- gcc/stmt.c	2000/01/07 22:41:20	1.71.4.4
+++ gcc/stmt.c	2000/10/14 18:56:22
@@ -1351,7 +1351,7 @@ expand_asm_operands (string, outputs, in
 	}
       else
 	{
-	  output_rtx[i] = assign_temp (type, 0, 0, 0);
+	  output_rtx[i] = assign_temp (type, 0, 0, 1);
 	  TREE_VALUE (tail) = make_tree (type, output_rtx[i]);
 	}
 
Index: gcc/stor-layout.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/stor-layout.c,v
retrieving revision 1.25
diff -u -p -r1.25 stor-layout.c
--- gcc/stor-layout.c	1999/03/11 13:56:20	1.25
+++ gcc/stor-layout.c	2000/10/14 18:56:24
@@ -264,8 +264,8 @@ layout_decl (decl, known_align)
       if (spec_size == 0 && DECL_NAME (decl) != 0)
 	abort ();
 
-      /* Size is specified number of bits.  */
-      DECL_SIZE (decl) = size_int (spec_size);
+      /* Size is specified in number of bits.  */
+      DECL_SIZE (decl) = bitsize_int (spec_size, 0);
     }
   /* Force alignment required for the data type.
      But if the decl itself wants greater alignment, don't override that.
@@ -301,7 +301,7 @@ layout_decl (decl, known_align)
 	  DECL_ALIGN (decl) = MAX ((unsigned) GET_MODE_ALIGNMENT (xmode),
 				   DECL_ALIGN (decl));
 	  DECL_MODE (decl) = xmode;
-	  DECL_SIZE (decl) = size_int (GET_MODE_BITSIZE (xmode));
+	  DECL_SIZE (decl) = bitsize_int (GET_MODE_BITSIZE (xmode), 0);
 	  /* This no longer needs to be accessed as a bit field.  */
 	  DECL_BIT_FIELD (decl) = 0;
 	}
@@ -520,7 +520,7 @@ layout_record (rec)
 	DECL_FIELD_BITPOS (field) = var_size;
       else
 	{
-	  DECL_FIELD_BITPOS (field) = size_int (const_size);
+	  DECL_FIELD_BITPOS (field) = bitsize_int (const_size, 0L);
 
 	  /* If this field ended up more aligned than we thought it
 	     would be (we approximate this by seeing if its position
@@ -562,7 +562,7 @@ layout_record (rec)
 
   if (var_size == 0)
     {
-      TYPE_SIZE (rec) = size_int (const_size);
+      TYPE_SIZE (rec) = bitsize_int (const_size, 0L);
     }
   else
     {
@@ -610,7 +610,7 @@ layout_union (rec)
   /* The size of the union, based on the fields scanned so far,
      is max (CONST_SIZE, VAR_SIZE).
      VAR_SIZE may be null; then CONST_SIZE by itself is the size.  */
-  register int const_size = 0;
+  register HOST_WIDE_INT const_size = 0;
   register tree var_size = 0;
 
 #ifdef STRUCTURE_SIZE_BOUNDARY
@@ -627,6 +627,8 @@ layout_union (rec)
 
   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
     {
+      tree dsize;
+      
       /* Enums which are local to this class need not be laid out.  */
       if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
 	continue;
@@ -645,19 +647,22 @@ layout_union (rec)
 	union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
 #endif
 
+      dsize = DECL_SIZE (field);
       if (TREE_CODE (rec) == UNION_TYPE)
 	{
 	  /* Set union_size to max (decl_size, union_size).
 	     There are more and less general ways to do this.
 	     Use only CONST_SIZE unless forced to use VAR_SIZE.  */
 
-	  if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
+	  if (TREE_CODE (dsize) == INTEGER_CST
+              && ! TREE_CONSTANT_OVERFLOW (dsize)
+              && TREE_INT_CST_HIGH (dsize) == 0)
 	    const_size
-	      = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
+	      = MAX (const_size, TREE_INT_CST_LOW (dsize));
 	  else if (var_size == 0)
-	    var_size = DECL_SIZE (field);
+	    var_size = dsize;
 	  else
-	    var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
+	    var_size = size_binop (MAX_EXPR, var_size, dsize);
 	}
       else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 	var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
Index: gcc/toplev.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/toplev.c,v
retrieving revision 1.185.4.4
diff -u -p -r1.185.4.4 toplev.c
--- gcc/toplev.c	2000/01/04 09:24:24	1.185.4.4
+++ gcc/toplev.c	2000/10/14 18:56:35
@@ -136,8 +136,6 @@ You Lose!  You must define PREFERRED_DEB
 #define DIR_SEPARATOR '/'
 #endif
 
-extern int rtx_equal_function_value_matters;
-
 #if ! (defined (VMS) || defined (OS2))
 extern char **environ;
 #endif
Index: gcc/config/rs6000/rs6000.md
===================================================================
RCS file: /cvs/gcc/egcs/gcc/config/rs6000/rs6000.md,v
retrieving revision 1.55.4.14
diff -u -p -r1.55.4.14 rs6000.md
--- gcc/config/rs6000/rs6000.md	2000/05/14 21:36:34	1.55.4.14
+++ gcc/config/rs6000/rs6000.md	2000/10/14 18:56:55
@@ -6181,7 +6181,9 @@
      reg.  So expand it.  */
   if (GET_CODE (operands[0]) == SUBREG
       && GET_CODE (SUBREG_REG (operands[0])) == REG
-      && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER)
+      && REGNO (SUBREG_REG (operands[0])) < FIRST_PSEUDO_REGISTER
+      && (! REG_FUNCTION_VALUE_P (SUBREG_REG (operands[0]))
+	  || ! rtx_equal_function_value_matters))
     operands[0] = alter_subreg (operands[0]);
   if (GET_CODE (operands[1]) == SUBREG
       && GET_CODE (SUBREG_REG (operands[1])) == REG
Index: libio/ChangeLog
===================================================================
RCS file: /cvs/gcc/egcs/libio/ChangeLog,v
retrieving revision 1.81.4.11
diff -u -p -r1.81.4.11 ChangeLog
--- libio/ChangeLog	2000/01/28 09:54:58	1.81.4.11
+++ libio/ChangeLog	2000/10/14 18:57:07
@@ -1,3 +1,25 @@
+2000-09-23  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>
+
+	* stdstreams.cc: Include <libio.h>, not "libio.h".
+	* iolibio.h: Likewise.
+	(_IO_pos_BAD): Use _IO_off_t instead of _IO_fpos_t.
+	* libio.h (_IO_USER_LOCK): Define.
+
+1999-12-22  Jakub Jelinek  <jakub@redhat.com>
+
+	* libio.h (_IO_cookie_io_functions_t): Use _IO_off_t instead of
+	_IO_fpos_t.
+	(_IO_seekoff, _IO_seekpos): Likewise. Use _IO_off64_t instead of
+	_IO_fpos64_t.
+	* libioP.h (_IO_seekoff_t, _IO_seekpos_t, _IO_seek_t): Likewise.
+	(_IO_seekoff, _IO_seekpos): Likewise.
+	(_IO_default_seekoff, _IO_default_seekpos): Likewise.
+	(_IO_default_seek): Likewise.
+	(_IO_file_seekoff, _IO_file_seek, _IO_str_seekoff): Likewise.
+	* streambuf.h (streampos): Typedef to _IO_off_t resp. _IO_off64_t.
+	* parsestream.h (class parsebuf::pos_at_line_start): Change type
+	to _IO_off_t.
+
 2000-01-28  Martin v. Löwis  <loewis@informatik.hu-berlin.de>
 
 	* fstream.h (ifstream::ifstream): Add ios::in to mode.
Index: libio/iolibio.h
===================================================================
RCS file: /cvs/gcc/egcs/libio/iolibio.h,v
retrieving revision 1.3
diff -u -p -r1.3 iolibio.h
--- libio/iolibio.h	1998/02/24 20:09:50	1.3
+++ libio/iolibio.h	2000/10/15 11:41:25
@@ -1,4 +1,4 @@
-#include "libio.h"
+#include <libio.h>
 
 /* These emulate stdio functionality, but with a different name
    (_IO_ungetc instead of ungetc), and using _IO_FILE instead of FILE. */
@@ -38,7 +38,11 @@ extern int _IO_obstack_vprintf __P ((str
                                     _IO_va_list));
 extern int _IO_obstack_printf __P ((struct obstack *, const char *, ...));
 #ifndef _IO_pos_BAD
-#define _IO_pos_BAD ((_IO_fpos_t)(-1))
+# if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
+#  define _IO_pos_BAD ((_IO_off64_t) -1)
+# else
+#  define _IO_pos_BAD ((_IO_off_t) -1)
+# endif
 #endif
 #define _IO_clearerr(FP) ((FP)->_flags &= ~(_IO_ERR_SEEN|_IO_EOF_SEEN))
 #define _IO_fseek(__fp, __offset, __whence) \
Index: libio/libio.h
===================================================================
RCS file: /cvs/gcc/egcs/libio/libio.h,v
retrieving revision 1.14
diff -u -p -r1.14 libio.h
--- libio/libio.h	1998/06/29 18:06:26	1.14
+++ libio/libio.h	2000/10/14 18:57:07
@@ -136,6 +136,7 @@
 #define _IO_IS_APPENDING 0x1000
 #define _IO_IS_FILEBUF 0x2000
 #define _IO_BAD_SEEN 0x4000
+#define _IO_USER_LOCK 0x8000
 
 /* These are "formatting flags" matching the iostream fmtflags enum values. */
 #define _IO_SKIPWS 01
@@ -277,7 +278,7 @@ typedef struct
 {
   _IO_ssize_t (*read) __PMT ((struct _IO_FILE *, void *, _IO_ssize_t));
   _IO_ssize_t (*write) __PMT ((struct _IO_FILE *, const void *, _IO_ssize_t));
-  _IO_fpos_t (*seek) __PMT ((struct _IO_FILE *, _IO_off_t, int));
+  _IO_off_t (*seek) __PMT ((struct _IO_FILE *, _IO_off_t, int));
   int (*close) __PMT ((struct _IO_FILE *));
 } _IO_cookie_io_functions_t;
 
@@ -348,11 +349,11 @@ extern _IO_ssize_t _IO_padn __P ((_IO_FI
 extern _IO_size_t _IO_sgetn __P ((_IO_FILE *, void *, _IO_size_t));
 
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
-extern _IO_fpos64_t _IO_seekpos __P ((_IO_FILE *, _IO_fpos64_t, int));
+extern _IO_off64_t _IO_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
+extern _IO_off64_t _IO_seekpos __P ((_IO_FILE *, _IO_off64_t, int));
 #else
-extern _IO_fpos_t _IO_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
-extern _IO_fpos_t _IO_seekpos __P ((_IO_FILE *, _IO_fpos_t, int));
+extern _IO_off_t _IO_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
+extern _IO_off_t _IO_seekpos __P ((_IO_FILE *, _IO_off_t, int));
 #endif
 
 extern void _IO_free_backup_area __P ((_IO_FILE *));
Index: libio/libioP.h
===================================================================
RCS file: /cvs/gcc/egcs/libio/libioP.h,v
retrieving revision 1.11
diff -u -p -r1.11 libioP.h
--- libio/libioP.h	1999/05/17 22:58:56	1.11
+++ libio/libioP.h	2000/10/14 18:57:08
@@ -146,10 +146,10 @@ typedef _IO_size_t (*_IO_xsgetn_t) __PMT
    It matches the streambuf::seekoff virtual function.
    It is also used for the ANSI fseek function. */
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-typedef _IO_fpos64_t (*_IO_seekoff_t) __PMT ((_IO_FILE *FP, _IO_off64_t OFF,
+typedef _IO_off64_t (*_IO_seekoff_t) __PMT ((_IO_FILE *FP, _IO_off64_t OFF,
 					  int DIR, int MODE));
 #else
-typedef _IO_fpos_t (*_IO_seekoff_t) __PMT ((_IO_FILE *FP, _IO_off_t OFF,
+typedef _IO_off_t (*_IO_seekoff_t) __PMT ((_IO_FILE *FP, _IO_off_t OFF,
 					  int DIR, int MODE));
 #endif
 #define _IO_SEEKOFF(FP, OFF, DIR, MODE) JUMP3 (__seekoff, FP, OFF, DIR, MODE)
@@ -160,9 +160,9 @@ typedef _IO_fpos_t (*_IO_seekoff_t) __PM
    It is also used for the ANSI fgetpos and fsetpos functions.  */
 /* The _IO_seek_cur and _IO_seek_end options are not allowed. */
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-typedef _IO_fpos64_t (*_IO_seekpos_t) __PMT ((_IO_FILE *, _IO_fpos64_t, int));
+typedef _IO_off64_t (*_IO_seekpos_t) __PMT ((_IO_FILE *, _IO_off64_t, int));
 #else
-typedef _IO_fpos_t (*_IO_seekpos_t) __PMT ((_IO_FILE *, _IO_fpos_t, int));
+typedef _IO_off_t (*_IO_seekpos_t) __PMT ((_IO_FILE *, _IO_off_t, int));
 #endif
 #define _IO_SEEKPOS(FP, POS, FLAGS) JUMP2 (__seekpos, FP, POS, FLAGS)
 
@@ -213,9 +213,9 @@ typedef _IO_ssize_t (*_IO_write_t) __PMT
    It matches the streambuf::sys_seek virtual function, which is
    specific to this implementation. */
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-typedef _IO_fpos64_t (*_IO_seek_t) __PMT ((_IO_FILE *, _IO_off64_t, int));
+typedef _IO_off64_t (*_IO_seek_t) __PMT ((_IO_FILE *, _IO_off64_t, int));
 #else
-typedef _IO_fpos_t (*_IO_seek_t) __PMT ((_IO_FILE *, _IO_off_t, int));
+typedef _IO_off_t (*_IO_seek_t) __PMT ((_IO_FILE *, _IO_off_t, int));
 #endif
 #define _IO_SYSSEEK(FP, OFFSET, MODE) JUMP2 (__seek, FP, OFFSET, MODE)
 
@@ -298,11 +298,11 @@ struct _IO_FILE_plus
 /* Generic functions */
 
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
-extern _IO_fpos64_t _IO_seekpos __P ((_IO_FILE *, _IO_fpos64_t, int));
+extern _IO_off64_t _IO_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
+extern _IO_off64_t _IO_seekpos __P ((_IO_FILE *, _IO_off64_t, int));
 #else
-extern _IO_fpos_t _IO_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
-extern _IO_fpos_t _IO_seekpos __P ((_IO_FILE *, _IO_fpos_t, int));
+extern _IO_off_t _IO_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
+extern _IO_off_t _IO_seekpos __P ((_IO_FILE *, _IO_off_t, int));
 #endif
 
 extern void _IO_switch_to_main_get_area __P ((_IO_FILE *));
@@ -340,22 +340,22 @@ extern _IO_size_t _IO_default_xsputn __P
 					   _IO_size_t));
 extern _IO_size_t _IO_default_xsgetn __P ((_IO_FILE *, void *, _IO_size_t));
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_default_seekoff __P ((_IO_FILE *,
+extern _IO_off64_t _IO_default_seekoff __P ((_IO_FILE *,
 					      _IO_off64_t, int, int));
-extern _IO_fpos64_t _IO_default_seekpos __P ((_IO_FILE *,
-					      _IO_fpos64_t, int));
+extern _IO_off64_t _IO_default_seekpos __P ((_IO_FILE *,
+					      _IO_off64_t, int));
 #else
-extern _IO_fpos_t _IO_default_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
-extern _IO_fpos_t _IO_default_seekpos __P ((_IO_FILE *, _IO_fpos_t, int));
+extern _IO_off_t _IO_default_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
+extern _IO_off_t _IO_default_seekpos __P ((_IO_FILE *, _IO_off_t, int));
 #endif
 extern _IO_ssize_t _IO_default_write __P ((_IO_FILE *, const void *,
 					   _IO_ssize_t));
 extern _IO_ssize_t _IO_default_read __P ((_IO_FILE *, void *, _IO_ssize_t));
 extern int _IO_default_stat __P ((_IO_FILE *, void *));
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_default_seek __P ((_IO_FILE *, _IO_off64_t, int));
+extern _IO_off64_t _IO_default_seek __P ((_IO_FILE *, _IO_off64_t, int));
 #else
-extern _IO_fpos_t _IO_default_seek __P ((_IO_FILE *, _IO_off_t, int));
+extern _IO_off_t _IO_default_seek __P ((_IO_FILE *, _IO_off_t, int));
 #endif
 extern int _IO_default_sync __P ((_IO_FILE *));
 #define _IO_default_close ((_IO_close_t) _IO_default_sync)
@@ -389,11 +389,11 @@ extern void _IO_flush_all_linebuffered _
 extern int _IO_file_doallocate __P ((_IO_FILE *));
 extern _IO_FILE* _IO_file_setbuf __P ((_IO_FILE *, char *, _IO_ssize_t));
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_file_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
-extern _IO_fpos64_t _IO_file_seek __P ((_IO_FILE *, _IO_off64_t, int));
+extern _IO_off64_t _IO_file_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
+extern _IO_off64_t _IO_file_seek __P ((_IO_FILE *, _IO_off64_t, int));
 #else
-extern _IO_fpos_t _IO_file_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
-extern _IO_fpos_t _IO_file_seek __P ((_IO_FILE *, _IO_off_t, int));
+extern _IO_off_t _IO_file_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
+extern _IO_off_t _IO_file_seek __P ((_IO_FILE *, _IO_off_t, int));
 #endif
 extern _IO_size_t _IO_file_xsputn __P ((_IO_FILE *, const void *, _IO_size_t));
 extern int _IO_file_stat __P ((_IO_FILE *, void *));
@@ -427,9 +427,9 @@ extern int _IO_str_underflow __P ((_IO_F
 extern int _IO_str_overflow __P ((_IO_FILE *, int));
 extern int _IO_str_pbackfail __P ((_IO_FILE *, int));
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-extern _IO_fpos64_t _IO_str_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
+extern _IO_off64_t _IO_str_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
 #else
-extern _IO_fpos_t _IO_str_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
+extern _IO_off_t _IO_str_seekoff __P ((_IO_FILE *, _IO_off_t, int, int));
 #endif
 extern void _IO_str_finish __P ((_IO_FILE *, int));
 
@@ -544,12 +544,12 @@ extern int _IO_vscanf __P ((const char *
    where an _IO_fpos_t is a struct.
    Note that _IO_off_t must be an integral type. */
 
-/* _IO_pos_BAD is an _IO_fpos_t value indicating error, unknown, or EOF. */
+/* _IO_pos_BAD is an _IO_off_t value indicating error, unknown, or EOF. */
 #ifndef _IO_pos_BAD
 # if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
-#  define _IO_pos_BAD ((_IO_fpos64_t) -1)
+#  define _IO_pos_BAD ((_IO_off64_t) -1)
 # else
-#  define _IO_pos_BAD ((_IO_fpos_t) -1)
+#  define _IO_pos_BAD ((_IO_off_t) -1)
 # endif
 #endif
 /* _IO_pos_as_off converts an _IO_fpos_t value to an _IO_off_t value. */
Index: libio/parsestream.h
===================================================================
RCS file: /cvs/gcc/egcs/libio/parsestream.h,v
retrieving revision 1.1.1.1
diff -u -p -r1.1.1.1 parsestream.h
--- libio/parsestream.h	1997/08/21 22:58:20	1.1.1.1
+++ libio/parsestream.h	2000/10/14 18:57:09
@@ -42,7 +42,7 @@ extern "C++" {
 
 class parsebuf : public streambuf {
   protected:
-    _IO_fpos_t pos_at_line_start;
+    _IO_off_t pos_at_line_start;
     long _line_length;
     unsigned long __line_number;
     char *buf_start;
Index: libio/stdstreams.cc
===================================================================
RCS file: /cvs/gcc/egcs/libio/stdstreams.cc,v
retrieving revision 1.1.1.1
diff -u -p -r1.1.1.1 stdstreams.cc
--- libio/stdstreams.cc	1997/08/21 22:58:21	1.1.1.1
+++ libio/stdstreams.cc	2000/10/14 18:57:09
@@ -36,7 +36,7 @@ the executable file might be covered by 
 // then we don't need to, since in that case stdin/stdout/stderr
 // are identical to _IO_stdin/_IO_stdout/_IO_stderr.
 
-#include "libio.h"
+#include <libio.h>
 
 #ifdef _STDIO_USES_IOSTREAM
 #define CIN_SBUF _IO_stdin_
Index: libio/streambuf.h
===================================================================
RCS file: /cvs/gcc/egcs/libio/streambuf.h,v
retrieving revision 1.6.4.1
diff -u -p -r1.6.4.1 streambuf.h
--- libio/streambuf.h	1999/08/09 00:07:01	1.6.4.1
+++ libio/streambuf.h	2000/10/14 18:57:09
@@ -72,10 +72,10 @@ class ostream; class streambuf;
 
 #if defined(_G_IO_IO_FILE_VERSION) && _G_IO_IO_FILE_VERSION == 0x20001
 typedef _IO_off64_t streamoff;
-typedef _IO_fpos64_t streampos;
+typedef _IO_off64_t streampos;
 #else
 typedef _IO_off_t streamoff;
-typedef _IO_fpos_t streampos;
+typedef _IO_off_t streampos;
 #endif
 typedef _IO_ssize_t streamsize;
 

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]