This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
[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;