#include "config.h"
#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "flags.h"
#include "real.h"
#include "insn-config.h"
#include "recog.h"
#include "basic-block.h"
#include "output.h"
#include "tm_p.h"
#include "function.h"
#include "insn-attr.h"
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_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_antinout_edge (antloc, transp, antin, antout)
sbitmap *antloc;
sbitmap *transp;
sbitmap *antin;
sbitmap *antout;
{
basic_block bb;
edge e;
basic_block *worklist, *qin, *qout, *qend;
unsigned int qlen;
qin = qout = worklist
= (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
sbitmap_vector_ones (antin, last_basic_block);
FOR_EACH_BB_REVERSE (bb)
{
*qin++ =bb;
bb->aux = bb;
}
qin = worklist;
qend = &worklist[n_basic_blocks];
qlen = n_basic_blocks;
for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
e->src->aux = EXIT_BLOCK_PTR;
while (qlen)
{
bb = *qout++;
qlen--;
if (qout >= qend)
qout = worklist;
if (bb->aux == EXIT_BLOCK_PTR)
sbitmap_zero (antout[bb->index]);
else
{
bb->aux = NULL;
sbitmap_intersection_of_succs (antout[bb->index], antin, bb->index);
}
if (sbitmap_a_or_b_and_c_cg (antin[bb->index], antloc[bb->index],
transp[bb->index], antout[bb->index]))
for (e = bb->pred; e; e = e->pred_next)
if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
{
*qin++ = e->src;
e->src->aux = e;
qlen++;
if (qin >= qend)
qin = worklist;
}
}
clear_aux_for_edges ();
clear_aux_for_blocks ();
free (worklist);
}
static void
compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest)
struct edge_list *edge_list;
int n_exprs;
sbitmap *antin, *antout, *avout, *kill, *earliest;
{
sbitmap difference, temp_bitmap;
int x, num_edges;
basic_block pred, succ;
num_edges = NUM_EDGES (edge_list);
difference = sbitmap_alloc (n_exprs);
temp_bitmap = sbitmap_alloc (n_exprs);
for (x = 0; x < num_edges; x++)
{
pred = INDEX_EDGE_PRED_BB (edge_list, x);
succ = INDEX_EDGE_SUCC_BB (edge_list, x);
if (pred == ENTRY_BLOCK_PTR)
sbitmap_copy (earliest[x], antin[succ->index]);
else
{
if (succ == EXIT_BLOCK_PTR)
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_free (temp_bitmap);
sbitmap_free (difference);
}
static void
compute_laterin (edge_list, earliest, antloc, later, laterin)
struct edge_list *edge_list;
sbitmap *earliest, *antloc, *later, *laterin;
{
int num_edges, i;
edge e;
basic_block *worklist, *qin, *qout, *qend, bb;
unsigned int qlen;
num_edges = NUM_EDGES (edge_list);
qin = qout = worklist
= (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
for (i = 0; i < num_edges; i++)
INDEX_EDGE (edge_list, i)->aux = (void *) (size_t) i;
sbitmap_vector_ones (later, num_edges);
for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
sbitmap_copy (later[(size_t) e->aux], earliest[(size_t) e->aux]);
FOR_EACH_BB (bb)
{
*qin++ = bb;
bb->aux = bb;
}
qin = worklist;
qend = &worklist[n_basic_blocks];
qlen = n_basic_blocks;
while (qlen)
{
bb = *qout++;
bb->aux = NULL;
qlen--;
if (qout >= qend)
qout = worklist;
sbitmap_ones (laterin[bb->index]);
for (e = bb->pred; e != NULL; e = e->pred_next)
sbitmap_a_and_b (laterin[bb->index], laterin[bb->index], later[(size_t)e->aux]);
for (e = bb->succ; e != NULL; e = e->succ_next)
if (sbitmap_union_of_diff_cg (later[(size_t) e->aux],
earliest[(size_t) e->aux],
laterin[e->src->index],
antloc[e->src->index])
&& e->dest != EXIT_BLOCK_PTR && e->dest->aux == 0)
{
*qin++ = e->dest;
e->dest->aux = e;
qlen++;
if (qin >= qend)
qin = worklist;
}
}
sbitmap_ones (laterin[last_basic_block]);
for (e = EXIT_BLOCK_PTR->pred; e != NULL; e = e->pred_next)
sbitmap_a_and_b (laterin[last_basic_block],
laterin[last_basic_block],
later[(size_t) e->aux]);
clear_aux_for_edges ();
free (worklist);
}
static void
compute_insert_delete (edge_list, antloc, later, laterin,
insert, delete)
struct edge_list *edge_list;
sbitmap *antloc, *later, *laterin, *insert, *delete;
{
int x;
basic_block bb;
FOR_EACH_BB (bb)
sbitmap_difference (delete[bb->index], antloc[bb->index], laterin[bb->index]);
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[last_basic_block]);
else
sbitmap_difference (insert[x], later[x], laterin[b->index]);
}
}
struct edge_list *
pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete)
FILE *file ATTRIBUTE_UNUSED;
int n_exprs;
sbitmap *transp;
sbitmap *avloc;
sbitmap *antloc;
sbitmap *kill;
sbitmap **insert;
sbitmap **delete;
{
sbitmap *antin, *antout, *earliest;
sbitmap *avin, *avout;
sbitmap *later, *laterin;
struct edge_list *edge_list;
int num_edges;
edge_list = create_edge_list ();
num_edges = NUM_EDGES (edge_list);
#ifdef LCM_DEBUG_INFO
if (file)
{
fprintf (file, "Edge List:\n");
verify_edge_list (file, edge_list);
print_edge_list (file, edge_list);
dump_sbitmap_vector (file, "transp", "", transp, last_basic_block);
dump_sbitmap_vector (file, "antloc", "", antloc, last_basic_block);
dump_sbitmap_vector (file, "avloc", "", avloc, last_basic_block);
dump_sbitmap_vector (file, "kill", "", kill, last_basic_block);
}
#endif
avin = sbitmap_vector_alloc (last_basic_block, n_exprs);
avout = sbitmap_vector_alloc (last_basic_block, n_exprs);
compute_available (avloc, kill, avout, avin);
sbitmap_vector_free (avin);
antin = sbitmap_vector_alloc (last_basic_block, n_exprs);
antout = sbitmap_vector_alloc (last_basic_block, n_exprs);
compute_antinout_edge (antloc, transp, antin, antout);
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "antin", "", antin, last_basic_block);
dump_sbitmap_vector (file, "antout", "", antout, last_basic_block);
}
#endif
earliest = sbitmap_vector_alloc (num_edges, n_exprs);
compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest);
#ifdef LCM_DEBUG_INFO
if (file)
dump_sbitmap_vector (file, "earliest", "", earliest, num_edges);
#endif
sbitmap_vector_free (antout);
sbitmap_vector_free (antin);
sbitmap_vector_free (avout);
later = sbitmap_vector_alloc (num_edges, n_exprs);
laterin = sbitmap_vector_alloc (last_basic_block + 1, n_exprs);
compute_laterin (edge_list, earliest, antloc, later, laterin);
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "laterin", "", laterin, last_basic_block + 1);
dump_sbitmap_vector (file, "later", "", later, num_edges);
}
#endif
sbitmap_vector_free (earliest);
*insert = sbitmap_vector_alloc (num_edges, n_exprs);
*delete = sbitmap_vector_alloc (last_basic_block, n_exprs);
compute_insert_delete (edge_list, antloc, later, laterin, *insert, *delete);
sbitmap_vector_free (laterin);
sbitmap_vector_free (later);
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
dump_sbitmap_vector (file, "pre_delete_map", "", *delete,
last_basic_block);
}
#endif
return edge_list;
}
void
compute_available (avloc, kill, avout, avin)
sbitmap *avloc, *kill, *avout, *avin;
{
edge e;
basic_block *worklist, *qin, *qout, *qend, bb;
unsigned int qlen;
qin = qout = worklist
= (basic_block *) xmalloc (sizeof (basic_block) * n_basic_blocks);
sbitmap_vector_ones (avout, last_basic_block);
FOR_EACH_BB (bb)
{
*qin++ = bb;
bb->aux = bb;
}
qin = worklist;
qend = &worklist[n_basic_blocks];
qlen = n_basic_blocks;
for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
e->dest->aux = ENTRY_BLOCK_PTR;
while (qlen)
{
bb = *qout++;
qlen--;
if (qout >= qend)
qout = worklist;
if (bb->aux == ENTRY_BLOCK_PTR)
sbitmap_zero (avin[bb->index]);
else
{
bb->aux = NULL;
sbitmap_intersection_of_preds (avin[bb->index], avout, bb->index);
}
if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index], avin[bb->index], kill[bb->index]))
for (e = bb->succ; e; e = e->succ_next)
if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
{
*qin++ = e->dest;
e->dest->aux = e;
qlen++;
if (qin >= qend)
qin = worklist;
}
}
clear_aux_for_edges ();
clear_aux_for_blocks ();
free (worklist);
}
static void
compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
kill, farthest)
struct edge_list *edge_list;
int n_exprs;
sbitmap *st_avout, *st_avin, *st_antin, *kill, *farthest;
{
sbitmap difference, temp_bitmap;
int x, num_edges;
basic_block pred, succ;
num_edges = NUM_EDGES (edge_list);
difference = sbitmap_alloc (n_exprs);
temp_bitmap = sbitmap_alloc (n_exprs);
for (x = 0; x < num_edges; x++)
{
pred = INDEX_EDGE_PRED_BB (edge_list, x);
succ = INDEX_EDGE_SUCC_BB (edge_list, x);
if (succ == EXIT_BLOCK_PTR)
sbitmap_copy (farthest[x], st_avout[pred->index]);
else
{
if (pred == ENTRY_BLOCK_PTR)
sbitmap_zero (farthest[x]);
else
{
sbitmap_difference (difference, st_avout[pred->index],
st_antin[succ->index]);
sbitmap_not (temp_bitmap, st_avin[succ->index]);
sbitmap_a_and_b_or_c (farthest[x], difference,
kill[succ->index], temp_bitmap);
}
}
}
sbitmap_free (temp_bitmap);
sbitmap_free (difference);
}
static void
compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout)
struct edge_list *edge_list;
sbitmap *farthest, *st_avloc, *nearer, *nearerout;
{
int num_edges, i;
edge e;
basic_block *worklist, *tos, bb;
num_edges = NUM_EDGES (edge_list);
tos = worklist
= (basic_block *) xmalloc (sizeof (basic_block) * (n_basic_blocks + 1));
for (i = 0; i < num_edges; i++)
INDEX_EDGE (edge_list, i)->aux = (void *) (size_t) i;
sbitmap_vector_ones (nearer, num_edges);
for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
sbitmap_copy (nearer[(size_t)e->aux], farthest[(size_t)e->aux]);
FOR_EACH_BB (bb)
{
*tos++ = bb;
bb->aux = bb;
}
while (tos != worklist)
{
bb = *--tos;
bb->aux = NULL;
sbitmap_ones (nearerout[bb->index]);
for (e = bb->succ; e != NULL; e = e->succ_next)
sbitmap_a_and_b (nearerout[bb->index], nearerout[bb->index],
nearer[(size_t) e->aux]);
for (e = bb->pred; e != NULL; e = e->pred_next)
if (sbitmap_union_of_diff_cg (nearer[(size_t) e->aux],
farthest[(size_t) e->aux],
nearerout[e->dest->index],
st_avloc[e->dest->index])
&& e->src != ENTRY_BLOCK_PTR && e->src->aux == 0)
{
*tos++ = e->src;
e->src->aux = e;
}
}
sbitmap_ones (nearerout[last_basic_block]);
for (e = ENTRY_BLOCK_PTR->succ; e != NULL; e = e->succ_next)
sbitmap_a_and_b (nearerout[last_basic_block],
nearerout[last_basic_block],
nearer[(size_t) e->aux]);
clear_aux_for_edges ();
free (tos);
}
static void
compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
insert, delete)
struct edge_list *edge_list;
sbitmap *st_avloc, *nearer, *nearerout, *insert, *delete;
{
int x;
basic_block bb;
FOR_EACH_BB (bb)
sbitmap_difference (delete[bb->index], st_avloc[bb->index], nearerout[bb->index]);
for (x = 0; x < NUM_EDGES (edge_list); x++)
{
basic_block b = INDEX_EDGE_PRED_BB (edge_list, x);
if (b == ENTRY_BLOCK_PTR)
sbitmap_difference (insert[x], nearer[x], nearerout[last_basic_block]);
else
sbitmap_difference (insert[x], nearer[x], nearerout[b->index]);
}
}
struct edge_list *
pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill,
insert, delete)
FILE *file ATTRIBUTE_UNUSED;
int n_exprs;
sbitmap *transp;
sbitmap *st_avloc;
sbitmap *st_antloc;
sbitmap *kill;
sbitmap **insert;
sbitmap **delete;
{
sbitmap *st_antin, *st_antout;
sbitmap *st_avout, *st_avin, *farthest;
sbitmap *nearer, *nearerout;
struct edge_list *edge_list;
int num_edges;
edge_list = create_edge_list ();
num_edges = NUM_EDGES (edge_list);
st_antin = (sbitmap *) sbitmap_vector_alloc (last_basic_block, n_exprs);
st_antout = (sbitmap *) sbitmap_vector_alloc (last_basic_block, n_exprs);
sbitmap_vector_zero (st_antin, last_basic_block);
sbitmap_vector_zero (st_antout, last_basic_block);
compute_antinout_edge (st_antloc, transp, st_antin, st_antout);
st_avout = sbitmap_vector_alloc (last_basic_block, n_exprs);
st_avin = sbitmap_vector_alloc (last_basic_block, n_exprs);
compute_available (st_avloc, kill, st_avout, st_avin);
#ifdef LCM_DEBUG_INFO
if (file)
{
fprintf (file, "Edge List:\n");
verify_edge_list (file, edge_list);
print_edge_list (file, edge_list);
dump_sbitmap_vector (file, "transp", "", transp, last_basic_block);
dump_sbitmap_vector (file, "st_avloc", "", st_avloc, last_basic_block);
dump_sbitmap_vector (file, "st_antloc", "", st_antloc, last_basic_block);
dump_sbitmap_vector (file, "st_antin", "", st_antin, last_basic_block);
dump_sbitmap_vector (file, "st_antout", "", st_antout, last_basic_block);
dump_sbitmap_vector (file, "st_kill", "", kill, last_basic_block);
}
#endif
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "st_avout", "", st_avout, last_basic_block);
dump_sbitmap_vector (file, "st_avin", "", st_avin, last_basic_block);
}
#endif
farthest = sbitmap_vector_alloc (num_edges, n_exprs);
compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
kill, farthest);
#ifdef LCM_DEBUG_INFO
if (file)
dump_sbitmap_vector (file, "farthest", "", farthest, num_edges);
#endif
sbitmap_vector_free (st_antin);
sbitmap_vector_free (st_antout);
sbitmap_vector_free (st_avin);
sbitmap_vector_free (st_avout);
nearer = sbitmap_vector_alloc (num_edges, n_exprs);
nearerout = sbitmap_vector_alloc (last_basic_block + 1, n_exprs);
compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout);
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "nearerout", "", nearerout,
last_basic_block + 1);
dump_sbitmap_vector (file, "nearer", "", nearer, num_edges);
}
#endif
sbitmap_vector_free (farthest);
*insert = sbitmap_vector_alloc (num_edges, n_exprs);
*delete = sbitmap_vector_alloc (last_basic_block, n_exprs);
compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
*insert, *delete);
sbitmap_vector_free (nearerout);
sbitmap_vector_free (nearer);
#ifdef LCM_DEBUG_INFO
if (file)
{
dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
dump_sbitmap_vector (file, "pre_delete_map", "", *delete,
last_basic_block);
}
#endif
return edge_list;
}
struct seginfo
{
int mode;
rtx insn_ptr;
int bbnum;
struct seginfo *next;
HARD_REG_SET regs_live;
};
struct bb_info
{
struct seginfo *seginfo;
int computing;
};
#ifdef OPTIMIZE_MODE_SWITCHING
static sbitmap *antic;
static sbitmap *transp;
static sbitmap *comp;
static sbitmap *delete;
static sbitmap *insert;
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 *));
static void make_preds_opaque PARAMS ((basic_block, int));
#endif
#ifdef OPTIMIZE_MODE_SWITCHING
static struct seginfo *
new_seginfo (mode, insn, bb, regs_live)
int mode;
rtx insn;
int bb;
HARD_REG_SET regs_live;
{
struct seginfo *ptr;
ptr = xmalloc (sizeof (struct seginfo));
ptr->mode = mode;
ptr->insn_ptr = insn;
ptr->bbnum = bb;
ptr->next = NULL;
COPY_HARD_REG_SET (ptr->regs_live, regs_live);
return ptr;
}
static void
add_seginfo (head, info)
struct bb_info *head;
struct seginfo *info;
{
struct seginfo *ptr;
if (head->seginfo == NULL)
head->seginfo = info;
else
{
ptr = head->seginfo;
while (ptr->next != NULL)
ptr = ptr->next;
ptr->next = info;
}
}
static void
make_preds_opaque (b, j)
basic_block b;
int j;
{
edge e;
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);
}
}
static void
reg_dies (reg, live)
rtx reg;
HARD_REG_SET live;
{
int regno, nregs;
if (GET_CODE (reg) != REG)
return;
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
nregs--)
CLEAR_HARD_REG_BIT (live, regno + nregs);
}
static void
reg_becomes_live (reg, setter, live)
rtx reg;
rtx setter ATTRIBUTE_UNUSED;
void *live;
{
int regno, nregs;
if (GET_CODE (reg) == SUBREG)
reg = SUBREG_REG (reg);
if (GET_CODE (reg) != REG)
return;
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
nregs--)
SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
}
int
optimize_mode_switching (file)
FILE *file;
{
rtx insn;
int e;
basic_block bb;
int need_commit = 0;
sbitmap *kill;
struct edge_list *edge_list;
static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
#define N_ENTITIES ARRAY_SIZE (num_modes)
int entity_map[N_ENTITIES];
struct bb_info *bb_info[N_ENTITIES];
int i, j;
int n_entities;
int max_num_modes = 0;
bool emited = false;
basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED;
clear_bb_flags ();
for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
if (OPTIMIZE_MODE_SWITCHING (e))
{
int entry_exit_extra = 0;
#ifdef NORMAL_MODE
entry_exit_extra = 2;
#endif
bb_info[n_entities]
= (struct bb_info *) xcalloc (last_basic_block + entry_exit_extra,
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 0;
#ifdef NORMAL_MODE
{
edge eg;
post_entry = split_edge (ENTRY_BLOCK_PTR->succ);
for (pre_exit = 0, eg = EXIT_BLOCK_PTR->pred; eg; eg = eg->pred_next)
if (eg->flags & EDGE_FALLTHRU)
{
regset live_at_end = eg->src->global_live_at_end;
if (pre_exit)
abort ();
pre_exit = split_edge (eg);
COPY_REG_SET (pre_exit->global_live_at_start, live_at_end);
COPY_REG_SET (pre_exit->global_live_at_end, live_at_end);
}
}
#endif
antic = sbitmap_vector_alloc (last_basic_block, n_entities);
transp = sbitmap_vector_alloc (last_basic_block, n_entities);
comp = sbitmap_vector_alloc (last_basic_block, n_entities);
sbitmap_vector_ones (transp, last_basic_block);
for (j = n_entities - 1; j >= 0; j--)
{
int e = entity_map[j];
int no_mode = num_modes[e];
struct bb_info *info = bb_info[j];
FOR_EACH_BB (bb)
{
struct seginfo *ptr;
int last_mode = no_mode;
HARD_REG_SET live_now;
REG_SET_TO_HARD_REG_SET (live_now,
bb->global_live_at_start);
for (insn = bb->head;
insn != NULL && insn != NEXT_INSN (bb->end);
insn = NEXT_INSN (insn))
{
if (INSN_P (insn))
{
int mode = MODE_NEEDED (e, insn);
rtx link;
if (mode != no_mode && mode != last_mode)
{
last_mode = mode;
ptr = new_seginfo (mode, insn, bb->index, live_now);
add_seginfo (info + bb->index, ptr);
RESET_BIT (transp[bb->index], j);
}
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);
}
}
info[bb->index].computing = last_mode;
if (last_mode == no_mode)
{
ptr = new_seginfo (no_mode, bb->end, bb->index, live_now);
add_seginfo (info + bb->index, ptr);
}
}
#ifdef NORMAL_MODE
{
int mode = NORMAL_MODE (e);
if (mode != no_mode)
{
bb = post_entry;
RESET_BIT (transp[bb->index], j);
info[bb->index].computing = mode;
if (pre_exit)
info[pre_exit->index].seginfo->mode = mode;
}
}
#endif
}
kill = sbitmap_vector_alloc (last_basic_block, n_entities);
for (i = 0; i < max_num_modes; i++)
{
int current_mode[N_ENTITIES];
sbitmap_vector_zero (antic, last_basic_block);
sbitmap_vector_zero (comp, last_basic_block);
for (j = n_entities - 1; j >= 0; j--)
{
int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i);
struct bb_info *info = bb_info[j];
FOR_EACH_BB (bb)
{
if (info[bb->index].seginfo->mode == m)
SET_BIT (antic[bb->index], j);
if (info[bb->index].computing == m)
SET_BIT (comp[bb->index], j);
}
}
FOR_EACH_BB (bb)
sbitmap_not (kill[bb->index], transp[bb->index]);
edge_list = pre_edge_lcm (file, 1, transp, comp, antic,
kill, &insert, &delete);
for (j = n_entities - 1; j >= 0; j--)
{
int no_mode = num_modes[entity_map[j]];
for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--)
{
edge eg = INDEX_EDGE (edge_list, e);
int mode;
basic_block src_bb;
HARD_REG_SET live_at_edge;
rtx mode_set;
eg->aux = 0;
if (! TEST_BIT (insert[e], j))
continue;
eg->aux = (void *)1;
mode = current_mode[j];
src_bb = eg->src;
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 = get_insns ();
end_sequence ();
if (mode_set == NULL_RTX)
continue;
if (eg->flags & EDGE_ABNORMAL)
{
emited = true;
if (GET_CODE (src_bb->end) == JUMP_INSN)
emit_insn_before (mode_set, src_bb->end);
else if (GET_CODE (src_bb->end) == INSN)
emit_insn_after (mode_set, src_bb->end);
else
abort ();
bb_info[j][src_bb->index].computing = mode;
RESET_BIT (transp[src_bb->index], j);
}
else
{
need_commit = 1;
insert_insn_on_edge (mode_set, eg);
}
}
FOR_EACH_BB_REVERSE (bb)
if (TEST_BIT (delete[bb->index], j))
{
make_preds_opaque (bb, j);
bb_info[j][bb->index].seginfo->mode = no_mode;
}
}
clear_aux_for_edges ();
free_edge_list (edge_list);
}
for (j = n_entities - 1; j >= 0; j--)
{
int no_mode = num_modes[entity_map[j]];
FOR_EACH_BB_REVERSE (bb)
{
struct seginfo *ptr, *next;
for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
{
next = ptr->next;
if (ptr->mode != no_mode)
{
rtx mode_set;
start_sequence ();
EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live);
mode_set = get_insns ();
end_sequence ();
if (mode_set == NULL_RTX)
continue;
emited = true;
if (GET_CODE (ptr->insn_ptr) == NOTE
&& (NOTE_LINE_NUMBER (ptr->insn_ptr)
== NOTE_INSN_BASIC_BLOCK))
emit_insn_after (mode_set, ptr->insn_ptr);
else
emit_insn_before (mode_set, ptr->insn_ptr);
}
free (ptr);
}
}
free (bb_info[j]);
}
sbitmap_vector_free (kill);
sbitmap_vector_free (antic);
sbitmap_vector_free (transp);
sbitmap_vector_free (comp);
sbitmap_vector_free (delete);
sbitmap_vector_free (insert);
if (need_commit)
commit_edge_insertions ();
#ifdef NORMAL_MODE
cleanup_cfg (CLEANUP_NO_INSN_DEL);
#else
if (!need_commit && !emited)
return 0;
#endif
max_regno = max_reg_num ();
allocate_reg_info (max_regno, FALSE, FALSE);
update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
(PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
| PROP_SCAN_DEAD_CODE));
return 1;
}
#endif