bug fix in reload1.c
Richard Henderson
rth@cygnus.com
Wed Dec 10 22:39:00 GMT 1997
I wrote:
>I know. I'm beginning to think that my original solution, widening
>the store, was done at the wrong place.
After some discussion with Jim, I'm positive this is the case.
The correct solution involves having push_reload do the widening
instead, protected by WORD_REGISTER_OPERATIONS, since the situation
should not arrise if this is not defined.
r~
Wed Dec 10 22:27:55 1997 Richard Henderson <rth@cygnus.com>
Revert Mar 15 change.
* reload.c (push_reload): If WORD_REGISTER_OPERATIONS, reload
the SUBREG_REG regardless of the size differences.
* reload1.c (eliminate_regs) [case SET]: If W_R_O, preserve
subregs of identical word size for push_reload.
Index: caller-save.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/caller-save.c,v
retrieving revision 1.1.1.2
diff -u -p -d -r1.1.1.2 caller-save.c
--- caller-save.c 1997/11/02 08:39:16 1.1.1.2
+++ caller-save.c 1997/12/11 06:23:30
@@ -336,7 +336,7 @@ setup_save_areas (pchanged)
for (j = 1; j <= MOVE_MAX / UNITS_PER_WORD; j++)
if (regno_save_mem[i][j] != 0)
ok &= strict_memory_address_p (GET_MODE (regno_save_mem[i][j]),
- XEXP (eliminate_regs (regno_save_mem[i][j], 0, NULL_RTX, 1), 0));
+ XEXP (eliminate_regs (regno_save_mem[i][j], 0, NULL_RTX), 0));
return ok;
}
Index: dbxout.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/dbxout.c,v
retrieving revision 1.4
diff -u -p -d -r1.4 dbxout.c
--- dbxout.c 1997/11/14 01:39:43 1.4
+++ dbxout.c 1997/12/11 06:23:30
@@ -1863,7 +1863,7 @@ dbxout_symbol (decl, local)
/* else it is something we handle like a normal variable. */
}
- DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX, 0);
+ DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
leaf_renumber_regs_insn (DECL_RTL (decl));
@@ -2184,8 +2184,8 @@ dbxout_parms (parms)
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
DECL_INCOMING_RTL (parms)
- = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX, 0);
- DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX, 0);
+ = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
+ DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
{
Index: dwarf2out.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/dwarf2out.c,v
retrieving revision 1.29
diff -u -p -d -r1.29 dwarf2out.c
--- dwarf2out.c 1997/12/07 00:28:19 1.29
+++ dwarf2out.c 1997/12/11 06:23:31
@@ -6968,7 +6968,7 @@ add_location_or_const_value_attribute (d
if (rtl == NULL_RTX)
return;
- rtl = eliminate_regs (rtl, 0, NULL_RTX, 0);
+ rtl = eliminate_regs (rtl, 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
leaf_renumber_regs_insn (rtl);
Index: dwarfout.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/dwarfout.c,v
retrieving revision 1.7
diff -u -p -d -r1.7 dwarfout.c
--- dwarfout.c 1997/12/07 00:28:22 1.7
+++ dwarfout.c 1997/12/11 06:23:31
@@ -1866,7 +1866,7 @@ output_bound_representation (bound, dim_
if (TREE_CODE (bound) == SAVE_EXPR)
output_loc_descriptor
- (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX, 0));
+ (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
}
ASM_OUTPUT_LABEL (asm_out_file, end_label);
@@ -2409,7 +2409,7 @@ location_or_const_value_attribute (decl)
if (rtl == NULL_RTX)
return;
- rtl = eliminate_regs (rtl, 0, NULL_RTX, 0);
+ rtl = eliminate_regs (rtl, 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
leaf_renumber_regs_insn (rtl);
Index: reload.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/reload.c,v
retrieving revision 1.8
diff -u -p -d -r1.8 reload.c
--- reload.c 1997/12/07 00:29:04 1.8
+++ reload.c 1997/12/11 06:23:32
@@ -670,7 +670,7 @@ get_secondary_mem (x, mode, opnum, type)
/* Get a version of the address doing any eliminations needed. If that
didn't give us a new MEM, make a new one if it isn't valid. */
- loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX, 0);
+ loc = eliminate_regs (secondary_memlocs[(int) mode], VOIDmode, NULL_RTX);
mem_valid = strict_memory_address_p (mode, XEXP (loc, 0));
if (! mem_valid && loc == secondary_memlocs[(int) mode])
@@ -984,8 +984,11 @@ push_reload (in, out, inloc, outloc, cla
|| (((GET_CODE (SUBREG_REG (out)) == REG
&& REGNO (SUBREG_REG (out)) >= FIRST_PSEUDO_REGISTER)
|| GET_CODE (SUBREG_REG (out)) == MEM)
+#ifndef WORD_REGISTER_OPERATIONS
&& ((GET_MODE_SIZE (outmode)
- > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))))
+ > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))))
+#endif
+ )
|| (GET_CODE (SUBREG_REG (out)) == REG
&& REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER
&& ((GET_MODE_SIZE (outmode) <= UNITS_PER_WORD
@@ -2599,7 +2602,7 @@ find_reloads (insn, replace, ind_levels,
/* We must rerun eliminate_regs, in case the elimination
offsets have changed. */
rtx address = XEXP (eliminate_regs (reg_equiv_memory_loc[regno],
- 0, NULL_RTX, 0),
+ 0, NULL_RTX),
0);
if (rtx_varies_p (address))
@@ -4097,7 +4100,7 @@ find_reloads_toplev (x, opnum, type, ind
/* We must rerun eliminate_regs, in case the elimination
offsets have changed. */
rtx addr = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0,
- NULL_RTX, 0),
+ NULL_RTX),
0);
if (rtx_varies_p (addr))
@@ -4181,7 +4184,7 @@ find_reloads_toplev (x, opnum, type, ind
/* We must rerun eliminate_regs, in case the elimination
offsets have changed. */
rtx addr = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0,
- NULL_RTX, 0),
+ NULL_RTX),
0);
if (BYTES_BIG_ENDIAN)
{
@@ -4221,8 +4224,7 @@ make_memloc (ad, regno)
register int i;
/* We must rerun eliminate_regs, in case the elimination
offsets have changed. */
- rtx tem = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX, 0),
- 0);
+ rtx tem = XEXP (eliminate_regs (reg_equiv_memory_loc[regno], 0, NULL_RTX), 0);
#if 0 /* We cannot safely reuse a memloc made here;
if the pseudo appears twice, and its mem needs a reload,
Index: reload.h
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/reload.h,v
retrieving revision 1.1.1.2
diff -u -p -d -r1.1.1.2 reload.h
--- reload.h 1997/11/02 08:40:49 1.1.1.2
+++ reload.h 1997/12/11 06:23:32
@@ -215,7 +215,7 @@ extern void mark_home_live PROTO((int));
/* Scan X and replace any eliminable registers (such as fp) with a
replacement (such as sp), plus an offset. */
-extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx, int));
+extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx));
/* Emit code to perform a reload from IN (which may be a reload register) to
OUT (which may also be a reload register). IN or OUT is from operand
Index: reload1.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/reload1.c,v
retrieving revision 1.7
diff -u -p -d -r1.7 reload1.c
--- reload1.c 1997/12/07 00:29:06 1.7
+++ reload1.c 1997/12/11 06:23:32
@@ -980,7 +980,7 @@ reload (first, global, dumpfile)
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
if (reg_renumber[i] < 0 && reg_equiv_memory_loc[i])
{
- rtx x = eliminate_regs (reg_equiv_memory_loc[i], 0, NULL_RTX, 0);
+ rtx x = eliminate_regs (reg_equiv_memory_loc[i], 0, NULL_RTX);
if (strict_memory_address_p (GET_MODE (regno_reg_rtx[i]),
XEXP (x, 0)))
@@ -2812,11 +2812,10 @@ static struct rtvec_def *old_asm_operand
the proper thing. */
rtx
-eliminate_regs (x, mem_mode, insn, storing)
+eliminate_regs (x, mem_mode, insn)
rtx x;
enum machine_mode mem_mode;
rtx insn;
- int storing;
{
enum rtx_code code = GET_CODE (x);
struct elim_table *ep;
@@ -2845,7 +2844,7 @@ eliminate_regs (x, mem_mode, insn, stori
/* This is only for the benefit of the debugging backends, which call
eliminate_regs on DECL_RTL; any ADDRESSOFs in the actual insns are
removed after CSE. */
- new = eliminate_regs (XEXP (x, 0), 0, insn, 0);
+ new = eliminate_regs (XEXP (x, 0), 0, insn);
if (GET_CODE (new) == MEM)
return XEXP (new, 0);
return x;
@@ -2881,8 +2880,7 @@ eliminate_regs (x, mem_mode, insn, stori
elimination) and ignore the fact that this is actually a
reference to the pseudo. Ensure we make a copy of the
address in case it is shared. */
- new = eliminate_regs (reg_equiv_memory_loc[regno],
- mem_mode, insn, 0);
+ new = eliminate_regs (reg_equiv_memory_loc[regno], mem_mode, insn);
if (new != reg_equiv_memory_loc[regno])
{
cannot_omit_stores[regno] = 1;
@@ -2944,8 +2942,8 @@ eliminate_regs (x, mem_mode, insn, stori
reload. This is the desired action. */
{
- rtx new0 = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
- rtx new1 = eliminate_regs (XEXP (x, 1), mem_mode, insn, 0);
+ rtx new0 = eliminate_regs (XEXP (x, 0), mem_mode, insn);
+ rtx new1 = eliminate_regs (XEXP (x, 1), mem_mode, insn);
if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
{
@@ -3016,9 +3014,9 @@ eliminate_regs (x, mem_mode, insn, stori
case GE: case GT: case GEU: case GTU:
case LE: case LT: case LEU: case LTU:
{
- rtx new0 = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
+ rtx new0 = eliminate_regs (XEXP (x, 0), mem_mode, insn);
rtx new1
- = XEXP (x, 1) ? eliminate_regs (XEXP (x, 1), mem_mode, insn, 0) : 0;
+ = XEXP (x, 1) ? eliminate_regs (XEXP (x, 1), mem_mode, insn) : 0;
if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
return gen_rtx (code, GET_MODE (x), new0, new1);
@@ -3029,7 +3027,7 @@ eliminate_regs (x, mem_mode, insn, stori
/* If we have something in XEXP (x, 0), the usual case, eliminate it. */
if (XEXP (x, 0))
{
- new = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, 0), mem_mode, insn);
if (new != XEXP (x, 0))
x = gen_rtx (EXPR_LIST, REG_NOTE_KIND (x), new, XEXP (x, 1));
}
@@ -3042,7 +3040,7 @@ eliminate_regs (x, mem_mode, insn, stori
strictly needed, but it simplifies the code. */
if (XEXP (x, 1))
{
- new = eliminate_regs (XEXP (x, 1), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, 1), mem_mode, insn);
if (new != XEXP (x, 1))
return gen_rtx (GET_CODE (x), GET_MODE (x), XEXP (x, 0), new);
}
@@ -3078,7 +3076,7 @@ eliminate_regs (x, mem_mode, insn, stori
case ABS:
case SQRT:
case FFS:
- new = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, 0), mem_mode, insn);
if (new != XEXP (x, 0))
return gen_rtx (code, GET_MODE (x), new);
return x;
@@ -3097,7 +3095,7 @@ eliminate_regs (x, mem_mode, insn, stori
&& reg_equiv_memory_loc[REGNO (SUBREG_REG (x))] != 0)
{
new = eliminate_regs (reg_equiv_memory_loc[REGNO (SUBREG_REG (x))],
- mem_mode, insn, 0);
+ mem_mode, insn);
/* If we didn't change anything, we must retain the pseudo. */
if (new == reg_equiv_memory_loc[REGNO (SUBREG_REG (x))])
@@ -3117,37 +3115,38 @@ eliminate_regs (x, mem_mode, insn, stori
}
}
else
- new = eliminate_regs (SUBREG_REG (x), mem_mode, insn, 0);
+ new = eliminate_regs (SUBREG_REG (x), mem_mode, insn);
if (new != XEXP (x, 0))
{
int x_size = GET_MODE_SIZE (GET_MODE (x));
int new_size = GET_MODE_SIZE (GET_MODE (new));
- /* When asked to spill a partial word subreg, we need to go
- ahead and spill the whole thing against the possibility
- that we reload the whole reg and find garbage at the top. */
- if (storing
- && GET_CODE (new) == MEM
- && x_size < new_size
- && ((x_size + UNITS_PER_WORD-1) / UNITS_PER_WORD
- == (new_size + UNITS_PER_WORD-1) / UNITS_PER_WORD))
- return new;
- else if (GET_CODE (new) == MEM
- && x_size <= new_size
+ if (GET_CODE (new) == MEM
+ && x_size <= new_size
+#ifdef WORD_REGISTER_OPERATIONS
+ /* On these machines, combine can create rtl of the form
+ (set (subreg:m1 (reg:m2 R) 0) ...)
+ where m1 < m2, and expects something interesting to
+ happen to the entire word. Moreover, it will use the
+ (reg:m2 R) later, expecting all bits to be preserved.
+ So if the number of words is the same, preserve the
+ subreg so that push_reloads can see it. */
+ && ! ((x_size-1)/UNITS_PER_WORD == (new_size-1)/UNITS_PER_WORD)
+#endif
#ifdef LOAD_EXTEND_OP
- /* On these machines we will be reloading what is
- inside the SUBREG if it originally was a pseudo and
- the inner and outer modes are both a word or
- smaller. So leave the SUBREG then. */
- && ! (GET_CODE (SUBREG_REG (x)) == REG
- && x_size <= UNITS_PER_WORD
- && new_size <= UNITS_PER_WORD
- && x_size > new_size
- && INTEGRAL_MODE_P (GET_MODE (new))
- && LOAD_EXTEND_OP (GET_MODE (new)) != NIL)
+ /* On these machines we will be reloading what is
+ inside the SUBREG if it originally was a pseudo and
+ the inner and outer modes are both a word or
+ smaller. So leave the SUBREG then. */
+ && ! (GET_CODE (SUBREG_REG (x)) == REG
+ && x_size <= UNITS_PER_WORD
+ && new_size <= UNITS_PER_WORD
+ && x_size > new_size
+ && INTEGRAL_MODE_P (GET_MODE (new))
+ && LOAD_EXTEND_OP (GET_MODE (new)) != NIL)
#endif
- )
+ )
{
int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
enum machine_mode mode = GET_MODE (x);
@@ -3175,7 +3174,7 @@ eliminate_regs (x, mem_mode, insn, stori
if (ep->from_rtx == XEXP (x, 0))
ep->can_eliminate = 0;
- new = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, 0), mem_mode, insn);
if (new != XEXP (x, 0))
return gen_rtx (code, GET_MODE (x), new);
return x;
@@ -3188,7 +3187,7 @@ eliminate_regs (x, mem_mode, insn, stori
if (ep->to_rtx == XEXP (x, 0))
ep->can_eliminate = 0;
- new = eliminate_regs (XEXP (x, 0), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, 0), mem_mode, insn);
if (new != XEXP (x, 0))
return gen_rtx (code, GET_MODE (x), new);
return x;
@@ -3206,7 +3205,7 @@ eliminate_regs (x, mem_mode, insn, stori
temp_vec = (rtx *) alloca (XVECLEN (x, 3) * sizeof (rtx));
for (i = 0; i < ASM_OPERANDS_INPUT_LENGTH (x); i++)
temp_vec[i] = eliminate_regs (ASM_OPERANDS_INPUT (x, i),
- mem_mode, insn, 0);
+ mem_mode, insn);
for (i = 0; i < ASM_OPERANDS_INPUT_LENGTH (x); i++)
if (temp_vec[i] != ASM_OPERANDS_INPUT (x, i))
@@ -3277,8 +3276,8 @@ eliminate_regs (x, mem_mode, insn, stori
/* Now avoid the loop below in this common case. */
{
- rtx new0 = eliminate_regs (SET_DEST (x), 0, insn, 1);
- rtx new1 = eliminate_regs (SET_SRC (x), 0, insn, 0);
+ rtx new0 = eliminate_regs (SET_DEST (x), 0, insn);
+ rtx new1 = eliminate_regs (SET_SRC (x), 0, insn);
/* If SET_DEST changed from a REG to a MEM and INSN is an insn,
write a CLOBBER insn. */
@@ -3287,12 +3286,6 @@ eliminate_regs (x, mem_mode, insn, stori
&& GET_CODE (insn) != INSN_LIST)
emit_insn_after (gen_rtx (CLOBBER, VOIDmode, SET_DEST (x)), insn);
- /* If SET_DEST was a partial-word subreg, NEW0 may have been widened
- to spill the entire register (see SUBREG case above). If the
- widths of SET_DEST and NEW0 no longer match, adjust NEW1. */
- if (GET_MODE (SET_DEST (x)) != GET_MODE (new0))
- new1 = gen_rtx (SUBREG, GET_MODE (new0), new1, 0);
-
if (new0 != SET_DEST (x) || new1 != SET_SRC (x))
return gen_rtx (SET, VOIDmode, new0, new1);
}
@@ -3304,12 +3297,12 @@ eliminate_regs (x, mem_mode, insn, stori
eliminate_regs on DECL_RTL; any ADDRESSOFs in the actual insns are
removed after CSE. */
if (GET_CODE (XEXP (x, 0)) == ADDRESSOF)
- return eliminate_regs (XEXP (XEXP (x, 0), 0), 0, insn, 0);
+ return eliminate_regs (XEXP (XEXP (x, 0), 0), 0, insn);
/* Our only special processing is to pass the mode of the MEM to our
recursive call and copy the flags. While we are here, handle this
case more efficiently. */
- new = eliminate_regs (XEXP (x, 0), GET_MODE (x), insn, 0);
+ new = eliminate_regs (XEXP (x, 0), GET_MODE (x), insn);
if (new != XEXP (x, 0))
{
new = gen_rtx (MEM, GET_MODE (x), new);
@@ -3332,7 +3325,7 @@ eliminate_regs (x, mem_mode, insn, stori
{
if (*fmt == 'e')
{
- new = eliminate_regs (XEXP (x, i), mem_mode, insn, 0);
+ new = eliminate_regs (XEXP (x, i), mem_mode, insn);
if (new != XEXP (x, i) && ! copied)
{
rtx new_x = rtx_alloc (code);
@@ -3349,7 +3342,7 @@ eliminate_regs (x, mem_mode, insn, stori
int copied_vec = 0;
for (j = 0; j < XVECLEN (x, i); j++)
{
- new = eliminate_regs (XVECEXP (x, i, j), mem_mode, insn, 0);
+ new = eliminate_regs (XVECEXP (x, i, j), mem_mode, insn);
if (new != XVECEXP (x, i, j) && ! copied_vec)
{
rtvec new_v = gen_rtvec_vv (XVECLEN (x, i),
@@ -3527,7 +3520,7 @@ eliminate_regs_in_insn (insn, replace)
but now can do this as a load-address. This saves an insn in this
common case. */
- new_body = eliminate_regs (old_body, 0, replace ? insn : NULL_RTX, 0);
+ new_body = eliminate_regs (old_body, 0, replace ? insn : NULL_RTX);
if (new_body != old_body)
{
/* If we aren't replacing things permanently and we changed something,
@@ -3616,7 +3609,7 @@ eliminate_regs_in_insn (insn, replace)
of spill registers to be needed in the final reload pass than in
the pre-passes. */
if (val && REG_NOTES (insn) != 0)
- REG_NOTES (insn) = eliminate_regs (REG_NOTES (insn), 0, REG_NOTES (insn), 0);
+ REG_NOTES (insn) = eliminate_regs (REG_NOTES (insn), 0, REG_NOTES (insn));
if (! replace)
pop_obstacks ();
@@ -4090,7 +4083,7 @@ reload_as_needed (first, live_known)
XEXP (XEXP (PATTERN (insn), 0), 0)
= eliminate_regs (XEXP (XEXP (PATTERN (insn), 0), 0),
GET_MODE (XEXP (PATTERN (insn), 0)),
- NULL_RTX, 0);
+ NULL_RTX);
/* If we need to do register elimination processing, do so.
This might delete the insn, in which case we are done. */
Index: sdbout.c
===================================================================
RCS file: /cvs/cvsfiles/egcs/gcc/sdbout.c,v
retrieving revision 1.3
diff -u -p -d -r1.3 sdbout.c
--- sdbout.c 1997/11/02 21:18:05 1.3
+++ sdbout.c 1997/12/11 06:23:33
@@ -789,7 +789,7 @@ sdbout_symbol (decl, local)
if (DECL_RTL (decl) == 0)
return;
- DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX, 0);
+ DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
leaf_renumber_regs_insn (DECL_RTL (decl));
@@ -1289,8 +1289,8 @@ sdbout_parms (parms)
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
DECL_INCOMING_RTL (parms)
- = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX, 0);
- DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX, 0);
+ = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
+ DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
if (PARM_PASSED_IN_MEMORY (parms))
{
More information about the Gcc-bugs
mailing list