-/* Generic partial redundancy elimination with lazy code motion
- support.
+/* Generic partial redundancy elimination with lazy code motion support.
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "config.h"
#include "system.h"
-
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "recog.h"
#include "basic-block.h"
#include "tm_p.h"
+
/* We want target macros for the mode switching code to be able to refer
to instruction attribute values. */
#include "insn-attr.h"
/* Edge based LCM routines. */
-static void compute_antinout_edge PARAMS ((sbitmap *, sbitmap *,
- sbitmap *, sbitmap *));
-static void compute_earliest PARAMS ((struct edge_list *, int, sbitmap *,
- sbitmap *, sbitmap *, sbitmap *,
- sbitmap *));
-static void compute_laterin PARAMS ((struct edge_list *, sbitmap *,
- sbitmap *, sbitmap *, sbitmap *));
-static void compute_insert_delete PARAMS ((struct edge_list *edge_list,
- sbitmap *, sbitmap *, sbitmap *,
- sbitmap *, sbitmap *));
+static void compute_antinout_edge PARAMS ((sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *));
+static void compute_earliest PARAMS ((struct edge_list *, int,
+ sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *,
+ sbitmap *));
+static void compute_laterin PARAMS ((struct edge_list *, sbitmap *,
+ sbitmap *, sbitmap *,
+ sbitmap *));
+static void compute_insert_delete PARAMS ((struct edge_list *edge_list,
+ sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *,
+ sbitmap *));
/* Edge based LCM routines on a reverse flowgraph. */
-static void compute_farthest PARAMS ((struct edge_list *, int, sbitmap *,
- sbitmap *, sbitmap*, sbitmap *,
- sbitmap *));
-static void compute_nearerout PARAMS ((struct edge_list *, sbitmap *,
- sbitmap *, sbitmap *, sbitmap *));
-static void compute_rev_insert_delete PARAMS ((struct edge_list *edge_list,
- sbitmap *, sbitmap *, sbitmap *,
- sbitmap *, sbitmap *));
-
+static void compute_farthest PARAMS ((struct edge_list *, int,
+ sbitmap *, sbitmap *,
+ sbitmap*, sbitmap *,
+ sbitmap *));
+static void compute_nearerout PARAMS ((struct edge_list *, sbitmap *,
+ sbitmap *, sbitmap *,
+ sbitmap *));
+static void compute_rev_insert_delete PARAMS ((struct edge_list *edge_list,
+ sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *,
+ sbitmap *));
\f
/* Edge based lcm routines. */
{
int bb;
edge e;
- basic_block *worklist, *tos;
+ basic_block *worklist, *qin, *qout, *qend;
+ unsigned int qlen;
/* Allocate a worklist array/queue. Entries are only added to the
list if they were not already on the list. So the size is
bounded by the number of basic blocks. */
- tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
- * n_basic_blocks);
+ qin = qout = worklist
+ = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
/* We want a maximal solution, so make an optimistic initialization of
ANTIN. */
/* Put every block on the worklist; this is necessary because of the
optimistic initialization of ANTIN above. */
- for (bb = 0; bb < n_basic_blocks; bb++)
+ for (bb = n_basic_blocks - 1; bb >= 0; bb--)
{
- *tos++ = BASIC_BLOCK (bb);
+ *qin++ = BASIC_BLOCK (bb);
BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
}
+
+ qin = worklist;
+ qend = &worklist[n_basic_blocks];
+ qlen = n_basic_blocks;
/* Mark blocks which are predecessors of the exit block so that we
can easily identify them below. */
e->src->aux = EXIT_BLOCK_PTR;
/* Iterate until the worklist is empty. */
- while (tos != worklist)
+ while (qlen)
{
/* Take the first entry off the worklist. */
- basic_block b = *--tos;
+ basic_block b = *qout++;
bb = b->index;
+ qlen--;
+
+ if (qout >= qend)
+ qout = worklist;
if (b->aux == EXIT_BLOCK_PTR)
- {
- /* Do not clear the aux field for blocks which are
- predecessors of the EXIT block. That way we never
- add then to the worklist again. */
- sbitmap_zero (antout[bb]);
- }
+ /* Do not clear the aux field for blocks which are predecessors of
+ the EXIT block. That way we never add then to the worklist
+ again. */
+ sbitmap_zero (antout[bb]);
else
{
/* Clear the aux field of this block so that it can be added to
}
if (sbitmap_a_or_b_and_c (antin[bb], antloc[bb], transp[bb], antout[bb]))
- {
- /* If the in state of this block changed, then we need
- to add the predecessors of this block to the worklist
- if they are not already on the worklist. */
- for (e = b->pred; e; e = e->pred_next)
+ /* If the in state of this block changed, then we need
+ to add the predecessors of this block to the worklist
+ if they are not already on the worklist. */
+ for (e = b->pred; e; e = e->pred_next)
+ if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
{
- if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
- {
- *tos++ = e->src;
- e->src->aux = e;
- }
+ *qin++ = e->src;
+ e->src->aux = e;
+ qlen++;
+ if (qin >= qend)
+ qin = worklist;
}
- }
}
- free (tos);
+
+ free (worklist);
}
/* Compute the earliest vector for edge based lcm. */
+
static void
compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest)
struct edge_list *edge_list;
else
{
if (succ == EXIT_BLOCK_PTR)
- {
- sbitmap_zero (earliest[x]);
- }
+ sbitmap_zero (earliest[x]);
else
{
sbitmap_difference (difference, antin[succ->index],
avout[pred->index]);
sbitmap_not (temp_bitmap, antout[pred->index]);
- sbitmap_a_and_b_or_c (earliest[x], difference, kill[pred->index],
- temp_bitmap);
+ sbitmap_a_and_b_or_c (earliest[x], difference,
+ kill[pred->index], temp_bitmap);
}
}
}
+
free (temp_bitmap);
free (difference);
}
{
int bb, num_edges, i;
edge e;
- basic_block *worklist, *tos;
+ basic_block *worklist, *qin, *qout, *qend;
+ unsigned int qlen;
num_edges = NUM_EDGES (edge_list);
/* Allocate a worklist array/queue. Entries are only added to the
list if they were not already on the list. So the size is
bounded by the number of basic blocks. */
- tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
- * (n_basic_blocks + 1));
+ qin = qout = worklist
+ = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
/* Initialize a mapping from each edge to its index. */
for (i = 0; i < num_edges; i++)
the entry block. That edge should always have a LATER value the
same as EARLIEST for that edge. */
for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
- sbitmap_copy (later[(size_t)e->aux], earliest[(size_t)e->aux]);
+ sbitmap_copy (later[(size_t) e->aux], earliest[(size_t) e->aux]);
/* Add all the blocks to the worklist. This prevents an early exit from
the loop given our optimistic initialization of LATER above. */
- for (bb = n_basic_blocks - 1; bb >= 0; bb--)
+ for (bb = 0; bb < n_basic_blocks; bb++)
{
basic_block b = BASIC_BLOCK (bb);
- *tos++ = b;
+ *qin++ = b;
b->aux = b;
}
+ qin = worklist;
+ /* Note that we do not use the last allocated element for our queue,
+ as EXIT_BLOCK is never inserted into it. In fact the above allocation
+ of n_basic_blocks + 1 elements is not encessary. */
+ qend = &worklist[n_basic_blocks];
+ qlen = n_basic_blocks;
/* Iterate until the worklist is empty. */
- while (tos != worklist)
+ while (qlen)
{
/* Take the first entry off the worklist. */
- basic_block b = *--tos;
+ basic_block b = *qout++;
b->aux = NULL;
+ qlen--;
+ if (qout >= qend)
+ qout = worklist;
/* Compute the intersection of LATERIN for each incoming edge to B. */
bb = b->index;
/* Calculate LATER for all outgoing edges. */
for (e = b->succ; e != NULL; e = e->succ_next)
- {
- if (sbitmap_union_of_diff (later[(size_t) e->aux],
- earliest[(size_t) e->aux],
- laterin[e->src->index],
- antloc[e->src->index]))
- {
- /* If LATER for an outgoing edge was changed, then we need
- to add the target of the outgoing edge to the worklist. */
- if (e->dest != EXIT_BLOCK_PTR && e->dest->aux == 0)
- {
- *tos++ = e->dest;
- e->dest->aux = e;
- }
- }
- }
+ if (sbitmap_union_of_diff (later[(size_t) e->aux],
+ earliest[(size_t) e->aux],
+ laterin[e->src->index],
+ antloc[e->src->index])
+ /* If LATER for an outgoing edge was changed, then we need
+ to add the target of the outgoing edge to the worklist. */
+ && e->dest != EXIT_BLOCK_PTR && e->dest->aux == 0)
+ {
+ *qin++ = e->dest;
+ e->dest->aux = e;
+ qlen++;
+ if (qin >= qend)
+ qin = worklist;
+ }
}
/* Computation of insertion and deletion points requires computing LATERIN
laterin[n_basic_blocks],
later[(size_t) e->aux]);
- free (tos);
+ free (worklist);
}
/* Compute the insertion and deletion points for edge based LCM. */
+
static void
compute_insert_delete (edge_list, antloc, later, laterin,
insert, delete)
for (x = 0; x < NUM_EDGES (edge_list); x++)
{
basic_block b = INDEX_EDGE_SUCC_BB (edge_list, x);
+
if (b == EXIT_BLOCK_PTR)
sbitmap_difference (insert[x], later[x], laterin[n_basic_blocks]);
else
}
}
-/* Given local properties TRANSP, ANTLOC, AVOUT, KILL return the
- insert and delete vectors for edge based LCM. Returns an
- edgelist which is used to map the insert vector to what edge
- an expression should be inserted on. */
+/* Given local properties TRANSP, ANTLOC, AVOUT, KILL return the insert and
+ delete vectors for edge based LCM. Returns an edgelist which is used to
+ map the insert vector to what edge an expression should be inserted on. */
struct edge_list *
pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete)
avin = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
avout = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
compute_available (avloc, kill, avout, avin);
-
-
free (avin);
/* Compute global anticipatability. */
free (avout);
later = sbitmap_vector_alloc (num_edges, n_exprs);
+
/* Allocate an extra element for the exit block in the laterin vector. */
laterin = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs);
compute_laterin (edge_list, earliest, antloc, later, laterin);
-
#ifdef LCM_DEBUG_INFO
if (file)
{
if (file)
{
dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
- dump_sbitmap_vector (file, "pre_delete_map", "", *delete, n_basic_blocks);
+ dump_sbitmap_vector (file, "pre_delete_map", "", *delete,
+ n_basic_blocks);
}
#endif
/* Compute the AVIN and AVOUT vectors from the AVLOC and KILL vectors.
Return the number of passes we performed to iterate to a solution. */
+
void
compute_available (avloc, kill, avout, avin)
sbitmap *avloc, *kill, *avout, *avin;
{
int bb;
edge e;
- basic_block *worklist, *tos;
+ basic_block *worklist, *qin, *qout, *qend;
+ unsigned int qlen;
/* Allocate a worklist array/queue. Entries are only added to the
list if they were not already on the list. So the size is
bounded by the number of basic blocks. */
- tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
- * n_basic_blocks);
+ qin = qout = worklist
+ = (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
/* We want a maximal solution. */
sbitmap_vector_ones (avout, n_basic_blocks);
/* Put every block on the worklist; this is necessary because of the
optimistic initialization of AVOUT above. */
- for (bb = n_basic_blocks - 1; bb >= 0; bb--)
+ for (bb = 0; bb < n_basic_blocks; bb++)
{
- *tos++ = BASIC_BLOCK (bb);
+ *qin++ = BASIC_BLOCK (bb);
BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
}
+
+ qin = worklist;
+ qend = &worklist[n_basic_blocks];
+ qlen = n_basic_blocks;
/* Mark blocks which are successors of the entry block so that we
can easily identify them below. */
e->dest->aux = ENTRY_BLOCK_PTR;
/* Iterate until the worklist is empty. */
- while (tos != worklist)
+ while (qlen)
{
/* Take the first entry off the worklist. */
- basic_block b = *--tos;
+ basic_block b = *qout++;
bb = b->index;
+ qlen--;
+
+ if (qout >= qend)
+ qout = worklist;
/* If one of the predecessor blocks is the ENTRY block, then the
intersection of avouts is the null set. We can identify such blocks
by the special value in the AUX field in the block structure. */
if (b->aux == ENTRY_BLOCK_PTR)
- {
- /* Do not clear the aux field for blocks which are
- successors of the ENTRY block. That way we never
- add then to the worklist again. */
- sbitmap_zero (avin[bb]);
- }
+ /* Do not clear the aux field for blocks which are successors of the
+ ENTRY block. That way we never add then to the worklist again. */
+ sbitmap_zero (avin[bb]);
else
{
/* Clear the aux field of this block so that it can be added to
}
if (sbitmap_union_of_diff (avout[bb], avloc[bb], avin[bb], kill[bb]))
- {
- /* If the out state of this block changed, then we need
- to add the successors of this block to the worklist
- if they are not already on the worklist. */
- for (e = b->succ; e; e = e->succ_next)
+ /* If the out state of this block changed, then we need
+ to add the successors of this block to the worklist
+ if they are not already on the worklist. */
+ for (e = b->succ; e; e = e->succ_next)
+ if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
{
- if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
- {
- *tos++ = e->dest;
- e->dest->aux = e;
- }
+ *qin++ = e->dest;
+ e->dest->aux = e;
+ qlen++;
+
+ if (qin >= qend)
+ qin = worklist;
}
- }
}
- free (tos);
+
+ free (worklist);
}
/* Compute the farthest vector for edge based lcm. */
+
static void
compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
kill, farthest)
else
{
if (pred == ENTRY_BLOCK_PTR)
- {
- sbitmap_zero (farthest[x]);
- }
+ sbitmap_zero (farthest[x]);
else
{
sbitmap_difference (difference, st_avout[pred->index],
}
}
}
+
free (temp_bitmap);
free (difference);
}
/* Allocate a worklist array/queue. Entries are only added to the
list if they were not already on the list. So the size is
bounded by the number of basic blocks. */
- tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
- * (n_basic_blocks + 1));
+ tos = worklist
+ = (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
/* Initialize NEARER for each edge and build a mapping from an edge to
its index. */
/* Calculate NEARER for all incoming edges. */
for (e = b->pred; e != NULL; e = e->pred_next)
- {
- if (sbitmap_union_of_diff (nearer[(size_t) e->aux],
- farthest[(size_t) e->aux],
- nearerout[e->dest->index],
- st_avloc[e->dest->index]))
- {
- /* If NEARER for an incoming edge was changed, then we need
- to add the source of the incoming edge to the worklist. */
- if (e->src != ENTRY_BLOCK_PTR && e->src->aux == 0)
- {
- *tos++ = e->src;
- e->src->aux = e;
- }
- }
- }
+ if (sbitmap_union_of_diff (nearer[(size_t) e->aux],
+ farthest[(size_t) e->aux],
+ nearerout[e->dest->index],
+ st_avloc[e->dest->index])
+ /* If NEARER for an incoming edge was changed, then we need
+ to add the source of the incoming edge to the worklist. */
+ && e->src != ENTRY_BLOCK_PTR && e->src->aux == 0)
+ {
+ *tos++ = e->src;
+ e->src->aux = e;
+ }
}
/* Computation of insertion and deletion points requires computing NEAREROUT
}
/* Compute the insertion and deletion points for edge based LCM. */
+
static void
compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
insert, delete)
free (st_avout);
nearer = sbitmap_vector_alloc (num_edges, n_exprs);
+
/* Allocate an extra element for the entry block. */
nearerout = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs);
compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout);
*insert = sbitmap_vector_alloc (num_edges, n_exprs);
*delete = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
- compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout, *insert, *delete);
+ compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
+ *insert, *delete);
free (nearerout);
free (nearer);
if (file)
{
dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
- dump_sbitmap_vector (file, "pre_delete_map", "", *delete, n_basic_blocks);
+ dump_sbitmap_vector (file, "pre_delete_map", "", *delete,
+ n_basic_blocks);
}
#endif
return edge_list;
}
-/* MODE SWITCHING */
-/* The algorithm for setting the modes consists of scanning the insn list
+/* Mode switching:
+
+ The algorithm for setting the modes consists of scanning the insn list
and finding all the insns which require a specific mode. Each insn gets
a unique struct seginfo element. These structures are inserted into a list
for each basic block. For each entity, there is an array of bb_info over
static sbitmap *delete;
static sbitmap *insert;
-static struct seginfo * new_seginfo PARAMS ((int, rtx, int, HARD_REG_SET));;
+static struct seginfo * new_seginfo PARAMS ((int, rtx, int, HARD_REG_SET));
static void add_seginfo PARAMS ((struct bb_info *, struct seginfo *));
static void reg_dies PARAMS ((rtx, HARD_REG_SET));
static void reg_becomes_live PARAMS ((rtx, rtx, void *));
#ifdef OPTIMIZE_MODE_SWITCHING
/* This function will allocate a new BBINFO structure, initialized
- with the FP_MODE, INSN, and basic block BB parameters. */
+ with the MODE, INSN, and basic block BB parameters. */
static struct seginfo *
new_seginfo (mode, insn, bb, regs_live)
for (e = b->pred; e; e = e->pred_next)
{
basic_block pb = e->src;
+
if (e->aux || ! TEST_BIT (transp[pb->index], j))
continue;
+
RESET_BIT (transp[pb->index], j);
make_preds_opaque (pb, j);
}
rtx reg;
HARD_REG_SET live;
{
- int regno;
+ int regno, nregs;
if (GET_CODE (reg) != REG)
return;
+
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
- {
- int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
-
- for (; --nregs >=0; nregs--, regno++)
- CLEAR_HARD_REG_BIT (live, regno);
- }
+ for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
+ nregs--)
+ CLEAR_HARD_REG_BIT (live, regno + nregs);
}
/* Record in LIVE that register REG became live.
rtx setter ATTRIBUTE_UNUSED;
void *live;
{
- int regno;
+ int regno, nregs;
if (GET_CODE (reg) == SUBREG)
reg = SUBREG_REG (reg);
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
- {
- int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
-
- for (; nregs-- > 0; regno++)
- SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno);
- }
+ for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
+ nregs--)
+ SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
}
-#endif
-/* Find all insns that need a particular mode
- setting, and insert the necessary mode switches. */
-void
+/* Find all insns that need a particular mode setting, and insert the
+ necessary mode switches. Return true if we did work. */
+
+int
optimize_mode_switching (file)
- FILE *file ATTRIBUTE_UNUSED;
+ FILE *file;
{
-#ifdef OPTIMIZE_MODE_SWITCHING
rtx insn;
int bb, e;
edge eg;
int max_num_modes = 0;
for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
- {
- if (OPTIMIZE_MODE_SWITCHING (e))
- {
- /* Create the list of segments within each basic block. */
- bb_info[n_entities]
- = (struct bb_info *) xcalloc (n_basic_blocks, sizeof **bb_info);
- entity_map[n_entities++] = e;
- if (num_modes[e] > max_num_modes)
- max_num_modes = num_modes[e];
- }
- }
- if (! n_entities)
- return;
-
-#ifdef MODE_USES_IN_EXIT_BLOCK
- /* For some ABIs a particular mode setting is required at function exit. */
+ if (OPTIMIZE_MODE_SWITCHING (e))
+ {
+ /* Create the list of segments within each basic block. */
+ bb_info[n_entities]
+ = (struct bb_info *) xcalloc (n_basic_blocks, sizeof **bb_info);
+ entity_map[n_entities++] = e;
+ if (num_modes[e] > max_num_modes)
+ max_num_modes = num_modes[e];
+ }
- for (eg = EXIT_BLOCK_PTR->pred; eg; eg = eg->pred_next)
- {
- int bb = eg->src->index;
-
- rtx insn = BLOCK_END (bb);
- rtx use = MODE_USES_IN_EXIT_BLOCK;
-
- /* If the block ends with the use of the return value
- and / or a return, insert the new use(s) in front of them. */
- while ((GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE)
- || GET_CODE (insn) == JUMP_INSN)
- insn = PREV_INSN (insn);
- use = emit_insn_after (use, insn);
- if (insn == BLOCK_END (bb))
- BLOCK_END (bb) = use;
- else if (NEXT_INSN (use) == BLOCK_HEAD (bb))
- BLOCK_HEAD (bb) = NEXT_INSN (insn);
- }
-#endif
+ if (! n_entities)
+ return 0;
/* Create the bitmap vectors. */
struct bb_info *info = bb_info[j];
/* Determine what the first use (if any) need for a mode of entity E is.
- This will be th mode that is anticipatable for this block.
+ This will be the mode that is anticipatable for this block.
Also compute the initial transparency settings. */
for (bb = 0 ; bb < n_basic_blocks; bb++)
{
insn != NULL && insn != NEXT_INSN (BLOCK_END (bb));
insn = NEXT_INSN (insn))
{
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ if (INSN_P (insn))
{
int mode = MODE_NEEDED (e, insn);
rtx link;
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_DEAD)
reg_dies (XEXP (link, 0), live_now);
+
note_stores (PATTERN (insn), reg_becomes_live, &live_now);
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_UNUSED)
reg_dies (XEXP (link, 0), live_now);
}
}
+
+ /* If this is a predecessor of the exit block, and we must
+ force a mode on exit, make note of that. */
+#ifdef NORMAL_MODE
+ if (NORMAL_MODE (e) != no_mode && last_mode != NORMAL_MODE (e))
+ for (eg = BASIC_BLOCK (bb)->succ; eg; eg = eg->succ_next)
+ if (eg->dest == EXIT_BLOCK_PTR)
+ {
+ rtx insn = BLOCK_END (bb);
+
+ /* Find the last insn before a USE and/or JUMP. */
+ while ((GET_CODE (insn) == INSN
+ && GET_CODE (PATTERN (insn)) == USE)
+ || GET_CODE (insn) == JUMP_INSN)
+ insn = PREV_INSN (insn);
+ if (insn != BLOCK_END (bb) && NEXT_INSN (insn))
+ insn = NEXT_INSN (insn);
+ last_mode = NORMAL_MODE (e);
+ add_seginfo (info + bb,
+ new_seginfo (last_mode, insn, bb, live_now));
+ RESET_BIT (transp[bb], j);
+ }
+#endif
+
info[bb].computing = last_mode;
/* Check for blocks without ANY mode requirements. */
if (last_mode == no_mode)
add_seginfo (info + bb, ptr);
}
}
-#ifdef MODE_AT_ENTRY
+#ifdef NORMAL_MODE
{
- int mode = MODE_AT_ENTRY (e);
+ int mode = NORMAL_MODE (e);
+
if (mode != no_mode)
{
for (eg = ENTRY_BLOCK_PTR->succ; eg; eg = eg->succ_next)
has none (because we don't need to set it),
but retain whatever mode it computes. */
if (info[bb].seginfo->mode == mode)
- {
- info[bb].seginfo->mode = no_mode;
- }
- /* Insert a fake computing definition of MODE into entry blocks
- which compute no mode. This represents the mode on entry. */
+ info[bb].seginfo->mode = no_mode;
+
+ /* Insert a fake computing definition of MODE into entry
+ blocks which compute no mode. This represents the mode on
+ entry. */
else if (info[bb].computing == no_mode)
{
info[bb].computing = mode;
}
}
}
-#endif /* MODE_AT_ENTRY */
+#endif /* NORMAL_MODE */
}
kill = sbitmap_vector_alloc (n_basic_blocks, n_entities);
for (bb = 0 ; bb < n_basic_blocks; bb++)
{
-
if (info[bb].seginfo->mode == m)
SET_BIT (antic[bb], j);
edge_list = pre_edge_lcm (file, 1, transp, comp, antic,
kill, &insert, &delete);
- for (j = n_entities - 1; j >=0; j--)
+ for (j = n_entities - 1; j >= 0; j--)
{
/* Insert all mode sets that have been inserted by lcm. */
int no_mode = num_modes[entity_map[j]];
+
/* Wherever we have moved a mode setting upwards in the flow graph,
the blocks between the new setting site and the now redundant
computation ceases to be transparent for any lower-priority
mode = current_mode[j];
src_bb = eg->src;
- REG_SET_TO_HARD_REG_SET (live_at_edge, src_bb->global_live_at_end);
+ REG_SET_TO_HARD_REG_SET (live_at_edge,
+ src_bb->global_live_at_end);
+
start_sequence ();
EMIT_MODE_SET (entity_map[j], mode, live_at_edge);
mode_set = gen_sequence ();
previous block. */
if (eg->flags & EDGE_ABNORMAL)
{
-
src_bb->end = emit_insn_after (mode_set, src_bb->end);
bb_info[j][src_bb->index].computing = mode;
RESET_BIT (transp[src_bb->index], j);
need_commit = 1;
insert_insn_on_edge (mode_set, eg);
}
-
}
for (bb = n_basic_blocks - 1; bb >= 0; bb--)
- {
- if (TEST_BIT (delete[bb], j))
- {
- make_preds_opaque (BASIC_BLOCK (bb), j);
- /* Cancel the 'deleted' mode set. */
- bb_info[j][bb].seginfo->mode = no_mode;
- }
- }
+ if (TEST_BIT (delete[bb], j))
+ {
+ make_preds_opaque (BASIC_BLOCK (bb), j);
+ /* Cancel the 'deleted' mode set. */
+ bb_info[j][bb].seginfo->mode = no_mode;
+ }
}
+
free_edge_list (edge_list);
}
/* Now output the remaining mode sets in all the segments. */
for (j = n_entities - 1; j >= 0; j--)
{
+ int no_mode = num_modes[entity_map[j]];
+
for (bb = n_basic_blocks - 1; bb >= 0; bb--)
{
struct seginfo *ptr, *next;
for (ptr = bb_info[j][bb].seginfo; ptr; ptr = next)
{
next = ptr->next;
- if (ptr->mode != FP_MODE_NONE)
+ if (ptr->mode != no_mode)
{
rtx mode_set;
mode_set = gen_sequence ();
end_sequence ();
- emit_block_insn_before (mode_set, ptr->insn_ptr,
- BASIC_BLOCK (ptr->bbnum));
+ if (NOTE_LINE_NUMBER (ptr->insn_ptr) == NOTE_INSN_BASIC_BLOCK)
+ emit_block_insn_after (mode_set, ptr->insn_ptr,
+ BASIC_BLOCK (ptr->bbnum));
+ else
+ emit_block_insn_before (mode_set, ptr->insn_ptr,
+ BASIC_BLOCK (ptr->bbnum));
}
+
free (ptr);
}
}
+
free (bb_info[j]);
}
if (need_commit)
commit_edge_insertions ();
-#endif /* OPTIMIZE_MODE_SWITCHING */
+
+ /* Ideally we'd figure out what blocks were affected and start from
+ there, but this is enormously complicated by commit_edge_insertions,
+ which would screw up any indicies we'd collected, and also need to
+ be involved in the update. Bail and recompute global life info for
+ everything. */
+
+ allocate_reg_life_data ();
+ update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
+ (PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
+ | PROP_SCAN_DEAD_CODE | PROP_REG_INFO));
+
+ return 1;
}
+#endif /* OPTIMIZE_MODE_SWITCHING */
OSDN Git Service
