This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[new-regalloc-branch] fixes for other languages
- To: <gcc-patches at gcc dot gnu dot org>
- Subject: [new-regalloc-branch] fixes for other languages
- From: Michael Matz <matz at kde dot org>
- Date: Fri, 14 Sep 2001 12:00:54 +0200 (MET DST)
Hi,
the below diff makes the branch bootstrap all languages which are
activated by default on x86 (i.e. f77 and java additionally to C and C++),
and also fixes some regressions for C. There are now 7 FAILs for g77 with
the new allocator (opposed to -fno-new-ra), but I obivously don't know if
they are actual regressions from the previous allocators. I've never
built those languages before. C++ still shows a horrifying number of
failures in tests for exception handling (around 150). I never really had
my eyes on the C++ testsuite, so it might become difficult to point to the
change where these were introduced (or if they were introduced at all).
I'm not yet done analyzing those, but what I have: The version one gets
when checking out with -D "2001-08-08" (this is some time just before a
merge I believe), also has these regressions, but there they can be fixed,
when parts of libgcc (unwind-dw2*) and libsupc++ (eh_throw and
eh_personality) are recompiled with -fno-new-ra. I.e. there they are
simple miscompilations in the new allocator (but also yet unanalyzed).
OTOH with the newer versions there are also similar failures, but it
doesn't help to recompile all libs with -fno-new-ra (it doesn't even help
to deactivate flag_new_regalloc in toplev.c, i.e. bootstrapping the
_whole_ thing without the new allocator), so I suspect something fishy
with the base version. It's not really important right now.
Anyway, what it does: reload() might delete insns under some circumstances
(a used pseudo got no hardreg, but had a REG_EQUIV note, in which case the
setting insn is removed), but doesn't check if that insns might throw. If
it doesn, and it hapens to be the last insn in a block, and that insn
resulted in an EDGE_EH edge, this leads to abort()s in
fixup_abnormal_edges(). For now I paper over the problem by simply not
deleting such things. This is incorrect (as it leaves in insn with a
pseudo), but fixed the only case where I saw this.
store_motion: When called from gcse_main() that might have removed some
code, making some blocks unreachable. df.* barfs in that case, so do a
simple cleanup_cfg(0) beforehand.
The converting of struct web to use bitmembers didn't change users of
those member, leading to unwanted effects. On x86 (or any STACK_REGS
architecture), no pseudo live over an abnormal edge can be in a STACK_REG.
A similar thing applies to pseudos live over EDGE_EH and call_used_regs[]
(not implemented yet, as it made no difference in the C++ testsuite).
For a spill-temp which got no color we now try excessively hard to spill
neighbors, even coalesce targets (which right now makes also all coalesce
sources spill, even if that might not have been necessary in the original
graph. In the future we split such a coalesce again.) We use
emit_move_insn() now instead of emit_insn(gen_move_insn()), because the
former works for Sparc and large stack offsets. Finally
find_basic_blocks() can not be called after cleanup_cfg() in this
scenario, as it leaves label_value_list set, which is not a gc root,
therefore gets collected with the next ggc_collect() in toplev.c, which
leads to SEGVs in the next cleanup_cfg() which tries to free this list
then.
Ciao,
Michael.
--
2001-09-14 Michael Matz <matzmich@cs.tu-berlin.de>
reload1.c (reload): don't delete dead throwing insns.
gcse.c (store_motion): run a cleanup_cfg(0) before anything.
ra.c (NO_REMAT): Define.
(live_over_abnormal, struct curr_use.live_over_abnormal): New.
(live_in): Update it.
(build_web_parts_and_conflicts): Initialize it.
(parts_to_web): Use it to initialize...
(struct web, live_over_abnormal): ... this, new.
(conflicts_between_webs): Use that to handle STACK_REGS.
(init_one_web, select_spill, colorize_one_web): Handle was_spilled
as bitmap, not int.
(combine): Conflict with all hardregs in a multi-word web.
(colorize_one_web): Make three passes to find non-spilled neighbors.
(rewrite_program): Use emit_move_insn() instead emit_insn().
(reg_alloc): Change order of find_basic_blocks() and cleanup_cfg().
Index: reload1.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/reload1.c,v
retrieving revision 1.255.2.7
diff -u -p -c -p -r1.255.2.7 reload1.c
*** reload1.c 2001/08/16 14:49:40 1.255.2.7
--- reload1.c 2001/09/14 08:08:49
*************** reload (first, global)
*** 1067,1072 ****
--- 1067,1082 ----
rtx equiv_insn = XEXP (list, 0);
if (GET_CODE (equiv_insn) == NOTE)
continue;
+ /* RA We can't delete an insn with EH_REGION notes. Those
+ are the source of EH edges, and their sudden absense
+ would confuse fixup_abnormal_edges() below.
+ XXX I believe this only works by chance. If we don't
+ delete the insn, a pseudo could remain without a hardreg.
+ The only case where I saw this deleting of trapping
+ insns was StreamTokenizer.java, and there this
+ fix helped. */
+ if (can_throw_internal (equiv_insn))
+ continue;
if (reg_set_p (regno_reg_rtx[i], PATTERN (equiv_insn)))
delete_dead_insn (equiv_insn);
else
Index: gcse.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/gcse.c,v
retrieving revision 1.113.2.7
diff -u -p -c -p -r1.113.2.7 gcse.c
*** gcse.c 2001/08/28 17:20:25 1.113.2.7
--- gcse.c 2001/09/14 08:08:59
*************** store_motion ()
*** 7076,7081 ****
--- 7076,7088 ----
int i,n;
rtx insn, f;
int update_flow = 0;
+
+ /* We might got called by GCSE itself, which could have removed some basic
+ blocks (it certainly did in the case I saw), and we use later the df.*
+ analyzer, whose precondition includes the non-existence of unreachable
+ code, so do a very simple cleanup_cfg. */
+ cleanup_cfg (0);
+
if (rtl_dump_file)
{
fprintf (rtl_dump_file, "before store motion\n");
Index: ra.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/Attic/ra.c,v
retrieving revision 1.1.2.37
diff -u -p -c -p -r1.1.2.37 ra.c
*** ra.c 2001/08/30 05:56:36 1.1.2.37
--- ra.c 2001/09/14 08:09:02
***************
*** 38,44 ****
#include "ggc.h"
#include "reload.h"
! /*#define NO_REMAT*/
/* The algorithm used is currently Iterated Register Coalescing by
L.A.George, and Appel.
--- 38,44 ----
#include "ggc.h"
#include "reload.h"
! #define NO_REMAT
/* The algorithm used is currently Iterated Register Coalescing by
L.A.George, and Appel.
*************** struct web
*** 172,177 ****
--- 172,179 ----
int crosses_call:1;
int move_related:1; /* Whether the web is move related (IE involved
in a move) */
+ unsigned int live_over_abnormal:1; /* 1 when this web (or parts thereof) are live
+ over an abnormal edge. */
ENUM_BITFIELD(node_type) type:5; /* Current state of the node */
ENUM_BITFIELD(reg_class) regclass:10; /* just used for debugging */
int add_hardregs; /* Additional hard registers needed to be
*************** void reg_alloc PARAMS ((void));
*** 372,377 ****
--- 374,381 ----
#define igraph_index(i, j) ((i) < (j) ? ((j)*((j)-1)/2)+(i) : ((i)*((i)-1)/2)+(j))
static bitmap unbrokengraph;
static sbitmap igraph;
+ static sbitmap live_over_abnormal;
+
/* Uhhuuhu. Don't the hell use two sbitmaps! XXX
(for now I need the sup_igraph to note if there is any conflict between
parts of webs at all. I can't use igraph for this, as there only the real
*************** struct curr_use {
*** 787,792 ****
--- 791,798 ----
/* For easy access. */
unsigned int regno;
rtx x;
+ /* If some bits of this USE are live over an abnormal edge. */
+ unsigned int live_over_abnormal;
};
/* Returns nonzero iff rtx DEF and USE have bits in common (but see below).
*************** live_out_1 (df, use, insn)
*** 1014,1020 ****
(link->ref)]);*/
/* TODO: somehow instead of noting the ID of the LINK
! use the an ID nearer to the root webpart of that LINK.
We can't use the root itself, because we later use the
ID to look at the form (reg or subreg, and if yes,
which subreg) of this conflict. This means, that we
--- 1020,1026 ----
(link->ref)]);*/
/* TODO: somehow instead of noting the ID of the LINK
! use an ID nearer to the root webpart of that LINK.
We can't use the root itself, because we later use the
ID to look at the form (reg or subreg, and if yes,
which subreg) of this conflict. This means, that we
*************** live_in (df, use, insn)
*** 1097,1106 ****
--- 1103,1129 ----
/* All but the last predecessor are handled recursively. */
for (; e->pred_next; e = e->pred_next)
{
+ /* Call used hard regs die over an exception edge, ergo
+ they don't reach the predecessor block, so ignore such
+ uses. And also don't set the live_over_abnormal flag
+ for them. */
+ if ((e->flags & EDGE_EH) && use->regno < FIRST_PSEUDO_REGISTER
+ && call_used_regs[use->regno])
+ continue;
if (live_out (df, use, e->src->end))
live_in (df, use, e->src->end);
+ if (e->flags & EDGE_ABNORMAL)
+ use->live_over_abnormal = 1;
use->undefined = undef;
}
+ /* See above for exception edges. Here we simply want to return,
+ as all predecessors are handled, and the last one is not
+ reached by the current use (because it dies). */
+ if ((e->flags & EDGE_EH) && use->regno < FIRST_PSEUDO_REGISTER
+ && call_used_regs[use->regno])
+ return;
+ if (e->flags & EDGE_ABNORMAL)
+ use->live_over_abnormal = 1;
p = e->src->end;
}
if (live_out (df, use, p))
*************** build_web_parts_and_conflicts (df)
*** 1184,1195 ****
--- 1207,1221 ----
rtx insn = DF_REF_INSN (ref);
use.wp = &web_parts[df->def_id + DF_REF_ID (ref)];
use.x = DF_REF_REG (ref);
+ use.live_over_abnormal = 0;
set_undefined (&use);
visited_pass++;
in_no_conflict_block = 0;
live_in (df, &use, insn);
if (copy_insn_p (insn, NULL, NULL))
remember_move (insn);
+ if (use.live_over_abnormal)
+ SET_BIT (live_over_abnormal, DF_REF_ID (ref));
}
dump_number_seen ();
*************** init_one_web (web, reg)
*** 1425,1434 ****
web->spill_temp = 0;
web->use_my_regs = 0;
web->spill_cost = 0;
! web->was_spilled = -1;
web->is_coalesced = 0;
web->has_sub_conflicts = 0;
web->artificial = 0;
web->num_defs = 0;
web->num_uses = 0;
web->orig_x = reg;
--- 1451,1461 ----
web->spill_temp = 0;
web->use_my_regs = 0;
web->spill_cost = 0;
! web->was_spilled = 0;
web->is_coalesced = 0;
web->has_sub_conflicts = 0;
web->artificial = 0;
+ web->live_over_abnormal = 0;
web->num_defs = 0;
web->num_uses = 0;
web->orig_x = reg;
*************** record_conflict (web1, web2)
*** 1800,1806 ****
SET_BIT (igraph, index);
add_conflict_edge (web1, web2);
add_conflict_edge (web2, web1);
-
}
/* This builds full webs out of web parts, without relating them to each
--- 1827,1832 ----
*************** parts_to_webs (df, part2web)
*** 1877,1886 ****
--- 1903,1915 ----
{
web->num_uses++;
use2web[i - df->def_id] = web;
+ if (TEST_BIT (live_over_abnormal, i - df->def_id))
+ web->live_over_abnormal = 1;
}
}
if (webnum != num_webs)
abort ();
+ sbitmap_free (live_over_abnormal);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (!hardreg2web[i])
*************** conflicts_between_webs (df, part2web)
*** 2065,2070 ****
--- 2094,2112 ----
free (cl);
cl = cl_next;
}
+
+ #ifdef STACK_REGS
+ /* Pseudos can't go in stack regs if they are live at the beginning of
+ a block that is reached by an abnormal edge. */
+ for (i = 0; i < num_webs; i++)
+ {
+ struct web *web = id2web[i];
+ int j;
+ if (web->live_over_abnormal)
+ for (j = FIRST_STACK_REG; j <= LAST_STACK_REG; j++)
+ record_conflict (web, hardreg2web[j]);
+ }
+ #endif
}
/* Remember that a web was spilled. */
*************** alloc_mem (df)
*** 2435,2440 ****
--- 2477,2484 ----
sizeof all_uses_for_web[0]);
all_defs_for_web = (struct ref **) xcalloc (df->def_id,
sizeof all_defs_for_web[0]);
+ live_over_abnormal = sbitmap_alloc (df->use_id);
+ sbitmap_zero (live_over_abnormal);
}
/* Free the memory used by the register allocator. */
*************** combine (u, v)
*** 3001,3012 ****
if (pweb->type != SELECT && pweb->type != COALESCED)
{
if (wl->sub == NULL)
! record_conflict (pweb, web);
else
{
struct sub_conflict *sl;
for (sl = wl->sub; sl; sl = sl->next)
! record_conflict (u, sl->t);
}
}
}
--- 3045,3056 ----
if (pweb->type != SELECT && pweb->type != COALESCED)
{
if (wl->sub == NULL)
! record_conflict (web, pweb);
else
{
struct sub_conflict *sl;
for (sl = wl->sub; sl; sl = sl->next)
! record_conflict (web, sl->t);
}
}
}
*************** select_spill (void)
*** 3206,3212 ****
abort ();
remove_list (bestd, &spill_wl);
! DLIST_WEB (bestd)->was_spilled = best; /* Note the potential spill. */
put_web (DLIST_WEB (bestd), SIMPLIFY);
freeze_moves (DLIST_WEB (bestd));
debug_msg (0, " potential spill web %3d, conflicts = %d\n",
--- 3250,3256 ----
abort ();
remove_list (bestd, &spill_wl);
! DLIST_WEB (bestd)->was_spilled = 1; /* Note the potential spill. */
put_web (DLIST_WEB (bestd), SIMPLIFY);
freeze_moves (DLIST_WEB (bestd));
debug_msg (0, " potential spill web %3d, conflicts = %d\n",
*************** colorize_one_web (web, hard)
*** 3392,3398 ****
SET_HARD_REG_BIT (conflict_colors, c1);
}
}
! else if (ptarget->was_spilled < 0
&& find_web_for_subweb (w)->type != COALESCED
&& w->add_hardregs >= neighbor_needs)
{
--- 3436,3442 ----
SET_HARD_REG_BIT (conflict_colors, c1);
}
}
! else if (!ptarget->was_spilled
&& find_web_for_subweb (w)->type != COALESCED
&& w->add_hardregs >= neighbor_needs)
{
*************** colorize_one_web (web, hard)
*** 3508,3514 ****
break;
}
debug_msg (0, " --> got %d", c < 0 ? bestc : c);
! if (bestc >= 0 && c < 0 && web->was_spilled < 0)
{
/* This is a non-potential-spill web, which got a color, which did
destroy a hardreg block for one of it's neighbors. We color
--- 3552,3558 ----
break;
}
debug_msg (0, " --> got %d", c < 0 ? bestc : c);
! if (bestc >= 0 && c < 0 && !web->was_spilled)
{
/* This is a non-potential-spill web, which got a color, which did
destroy a hardreg block for one of it's neighbors. We color
*************** colorize_one_web (web, hard)
*** 3539,3545 ****
if (DLIST_WEB (d)->was_spilled < 0)
abort (); */
! if (hard && (web->was_spilled < 0 || web->spill_temp))
{
unsigned int loop;
struct web *try = NULL;
--- 3583,3589 ----
if (DLIST_WEB (d)->was_spilled < 0)
abort (); */
! if (hard && (!web->was_spilled || web->spill_temp))
{
unsigned int loop;
struct web *try = NULL;
*************** colorize_one_web (web, hard)
*** 3549,3567 ****
/* We make two passes over our conflicts, first trying to
spill those webs, which only got a color by chance, but
were potential spill ones, and if that isn't enough, in a second
! pass also to spill normal colored webs. */
! for (loop = 0; (try == NULL && loop < 2); loop++)
for (wl = web->conflict_list; wl; wl = wl->next)
{
! /* Normally we would have w=alias(wl->t), to get to all
! conflicts. But we can't simply spill webs which are
! involved in coalescing anyway. The premise for combining
! webs was, that the final one will get a color. One reason
! is, that the code inserting the spill insns can't cope
! with aliased webs (yet, may be, we should extend that). */
struct web *w = wl->t;
! if (w->type == COLORED && !w->spill_temp && !w->is_coalesced
! && (w->was_spilled > 0 || loop > 0)
/*&& w->add_hardregs >= web->add_hardregs
&& w->span_insns > web->span_insns*/)
{
--- 3593,3619 ----
/* We make two passes over our conflicts, first trying to
spill those webs, which only got a color by chance, but
were potential spill ones, and if that isn't enough, in a second
! pass also to spill normal colored webs. If we still didn't find
! a candidate, but we are a spill-temp, we make a third pass
! and include also webs, which were targets for coalescing, and
! spill those. */
! for (loop = 0; (try == NULL && loop < 3); loop++)
for (wl = web->conflict_list; wl; wl = wl->next)
{
! /* We check that it's indeed a colored web (this rules
! out webs which are coalesced into others, but not targets
! for coalescing). If we are a spill-temp, and haven't
! found a candidate in the first two passes, we also look
! at targets of coalescing to spill. This later probably
! leads to more spill insertions than necessary (it would
! be better to split the coalesce again), but spill-temps
! _must_ get a color. This is in difference to normal
! non-spill webs, which we can also spill, that's why we
! don't include coalesce targets also there. */
struct web *w = wl->t;
! if (w->type == COLORED && !w->spill_temp
! && (!w->is_coalesced || (loop > 1 && web->spill_temp))
! && (w->was_spilled || loop > 0)
/*&& w->add_hardregs >= web->add_hardregs
&& w->span_insns > web->span_insns*/)
{
*************** colorize_one_web (web, hard)
*** 3593,3599 ****
{
debug_msg (0, " to spill %d was a good idea\n", try->id);
remove_list (try->dlink, &spilled_nodes);
! if (try->was_spilled > 0)
colorize_one_web (try, 0);
else
colorize_one_web (try, hard - 1);
--- 3645,3651 ----
{
debug_msg (0, " to spill %d was a good idea\n", try->id);
remove_list (try->dlink, &spilled_nodes);
! if (try->was_spilled)
colorize_one_web (try, 0);
else
colorize_one_web (try, hard - 1);
*************** rewrite_program (void)
*** 3772,3778 ****
dest = gen_rtx_MEM (GET_MODE (source),
plus_constant (XEXP (dest, 0),
SUBREG_BYTE (source)));
! emit_insn (gen_move_insn (dest, source));
}
else
{
--- 3824,3830 ----
dest = gen_rtx_MEM (GET_MODE (source),
plus_constant (XEXP (dest, 0),
SUBREG_BYTE (source)));
! emit_move_insn (dest, source);
}
else
{
*************** rewrite_program (void)
*** 3781,3787 ****
reg, 0))
emit_insn (gen_move_insn (dest, reg));
else*/
! emit_insn (gen_move_insn (dest, source));
}
insns = get_insns ();
--- 3833,3839 ----
reg, 0))
emit_insn (gen_move_insn (dest, reg));
else*/
! emit_move_insn (dest, source);
}
insns = get_insns ();
*************** rewrite_program (void)
*** 3824,3832 ****
rtx reg = gen_reg_rtx (GET_MODE (SET_DEST (pat)));
start_sequence ();
if (validate_change (insn, DF_REF_LOC (web->uses[j]), reg, 0))
! emit_insn (gen_move_insn (reg, SET_SRC (pat)));
else
! emit_insn (gen_move_insn (SET_DEST (pat), SET_SRC (pat)));
/* emit_insn (PATTERN (DF_REF_INSN
(DF_REF_CHAIN (web->uses[j])->ref))); */
insns = get_insns ();
--- 3876,3884 ----
rtx reg = gen_reg_rtx (GET_MODE (SET_DEST (pat)));
start_sequence ();
if (validate_change (insn, DF_REF_LOC (web->uses[j]), reg, 0))
! emit_move_insn (reg, SET_SRC (pat));
else
! emit_move_insn (SET_DEST (pat), SET_SRC (pat));
/* emit_insn (PATTERN (DF_REF_INSN
(DF_REF_CHAIN (web->uses[j])->ref))); */
insns = get_insns ();
*************** rewrite_program (void)
*** 3864,3870 ****
source = gen_rtx_MEM (GET_MODE (target),
plus_constant (XEXP (source, 0),
SUBREG_BYTE (target)));
! emit_insn (gen_move_insn (target, source));
}
else
{
--- 3916,3922 ----
source = gen_rtx_MEM (GET_MODE (target),
plus_constant (XEXP (source, 0),
SUBREG_BYTE (target)));
! emit_move_insn (target, source);
}
else
{
*************** rewrite_program (void)
*** 3874,3880 ****
reg, 0))
emit_insn (gen_move_insn (reg ,source));
else*/
! emit_insn (gen_move_insn (target, source));
}
insns = get_insns ();
--- 3926,3932 ----
reg, 0))
emit_insn (gen_move_insn (reg ,source));
else*/
! emit_move_insn (target, source);
}
insns = get_insns ();
*************** reg_alloc (void)
*** 4860,4871 ****
compute_bb_for_insn (get_max_uid ());
store_motion ();
no_new_pseudos = 1;
compute_bb_for_insn (get_max_uid ());
clear_log_links (get_insns ());
- cleanup_cfg (CLEANUP_EXPENSIVE);
- find_basic_blocks (get_insns (), max_reg_num (), rtl_dump_file);
life_analysis (get_insns (), rtl_dump_file,
PROP_DEATH_NOTES | PROP_LOG_LINKS | PROP_REG_INFO);
recompute_reg_usage (get_insns (), TRUE);
/* XXX: reg_scan screws up reg_renumber, and without reg_scan, we can't do
regclass. */
--- 4912,4923 ----
compute_bb_for_insn (get_max_uid ());
store_motion ();
no_new_pseudos = 1;
+ find_basic_blocks (get_insns (), max_reg_num (), rtl_dump_file);
compute_bb_for_insn (get_max_uid ());
clear_log_links (get_insns ());
life_analysis (get_insns (), rtl_dump_file,
PROP_DEATH_NOTES | PROP_LOG_LINKS | PROP_REG_INFO);
+ cleanup_cfg (CLEANUP_EXPENSIVE);
recompute_reg_usage (get_insns (), TRUE);
/* XXX: reg_scan screws up reg_renumber, and without reg_scan, we can't do
regclass. */