2002-02-01 18:16:02 +00:00
|
|
|
|
/* Generic partial redundancy elimination with lazy code motion support.
|
2007-05-19 01:19:51 +00:00
|
|
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
|
2004-07-28 03:11:36 +00:00
|
|
|
|
Free Software Foundation, Inc.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
This file is part of GCC.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
|
|
|
version.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
|
for more details.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2002-02-01 18:16:02 +00:00
|
|
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
2007-05-19 01:19:51 +00:00
|
|
|
|
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
|
02110-1301, USA. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
/* These routines are meant to be used by various optimization
|
2002-02-01 18:16:02 +00:00
|
|
|
|
passes which can be modeled as lazy code motion problems.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
Including, but not limited to:
|
|
|
|
|
|
|
|
|
|
* Traditional partial redundancy elimination.
|
|
|
|
|
|
|
|
|
|
* Placement of caller/caller register save/restores.
|
|
|
|
|
|
|
|
|
|
* Load/store motion.
|
|
|
|
|
|
|
|
|
|
* Copy motion.
|
|
|
|
|
|
|
|
|
|
* Conversion of flat register files to a stacked register
|
|
|
|
|
model.
|
|
|
|
|
|
|
|
|
|
* Dead load/store elimination.
|
|
|
|
|
|
|
|
|
|
These routines accept as input:
|
|
|
|
|
|
|
|
|
|
* Basic block information (number of blocks, lists of
|
|
|
|
|
predecessors and successors). Note the granularity
|
|
|
|
|
does not need to be basic block, they could be statements
|
|
|
|
|
or functions.
|
|
|
|
|
|
|
|
|
|
* Bitmaps of local properties (computed, transparent and
|
|
|
|
|
anticipatable expressions).
|
|
|
|
|
|
|
|
|
|
The output of these routines is bitmap of redundant computations
|
|
|
|
|
and a bitmap of optimal placement points. */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
#include "system.h"
|
2004-07-28 03:11:36 +00:00
|
|
|
|
#include "coretypes.h"
|
|
|
|
|
#include "tm.h"
|
1999-10-16 06:09:09 +00:00
|
|
|
|
#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"
|
2003-07-11 03:40:53 +00:00
|
|
|
|
#include "output.h"
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#include "tm_p.h"
|
2004-07-28 03:11:36 +00:00
|
|
|
|
#include "function.h"
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void compute_antinout_edge (sbitmap *, sbitmap *, sbitmap *, sbitmap *);
|
|
|
|
|
static void compute_earliest (struct edge_list *, int, sbitmap *, sbitmap *,
|
|
|
|
|
sbitmap *, sbitmap *, sbitmap *);
|
|
|
|
|
static void compute_laterin (struct edge_list *, sbitmap *, sbitmap *,
|
|
|
|
|
sbitmap *, sbitmap *);
|
|
|
|
|
static void compute_insert_delete (struct edge_list *edge_list, sbitmap *,
|
|
|
|
|
sbitmap *, sbitmap *, sbitmap *, sbitmap *);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Edge based LCM routines on a reverse flowgraph. */
|
2004-07-28 03:11:36 +00:00
|
|
|
|
static void compute_farthest (struct edge_list *, int, sbitmap *, sbitmap *,
|
|
|
|
|
sbitmap*, sbitmap *, sbitmap *);
|
|
|
|
|
static void compute_nearerout (struct edge_list *, sbitmap *, sbitmap *,
|
|
|
|
|
sbitmap *, sbitmap *);
|
|
|
|
|
static void compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *,
|
|
|
|
|
sbitmap *, sbitmap *, sbitmap *,
|
|
|
|
|
sbitmap *);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Edge based lcm routines. */
|
|
|
|
|
|
|
|
|
|
/* Compute expression anticipatability at entrance and exit of each block.
|
|
|
|
|
This is done based on the flow graph, and not on the pred-succ lists.
|
|
|
|
|
Other than that, its pretty much identical to compute_antinout. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_antinout_edge (sbitmap *antloc, sbitmap *transp, sbitmap *antin,
|
|
|
|
|
sbitmap *antout)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
edge e;
|
|
|
|
|
basic_block *worklist, *qin, *qout, *qend;
|
|
|
|
|
unsigned int qlen;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
edge_iterator ei;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
qin = qout = worklist = XNEWVEC (basic_block, n_basic_blocks);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* We want a maximal solution, so make an optimistic initialization of
|
|
|
|
|
ANTIN. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_vector_ones (antin, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Put every block on the worklist; this is necessary because of the
|
|
|
|
|
optimistic initialization of ANTIN above. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB_REVERSE (bb)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2004-07-28 03:11:36 +00:00
|
|
|
|
*qin++ = bb;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb->aux = bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
qin = worklist;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS];
|
|
|
|
|
qlen = n_basic_blocks - NUM_FIXED_BLOCKS;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Mark blocks which are predecessors of the exit block so that we
|
|
|
|
|
can easily identify them below. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
e->src->aux = EXIT_BLOCK_PTR;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Iterate until the worklist is empty. */
|
|
|
|
|
while (qlen)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Take the first entry off the worklist. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb = *qout++;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
qlen--;
|
|
|
|
|
|
|
|
|
|
if (qout >= qend)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
qout = worklist;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (bb->aux == EXIT_BLOCK_PTR)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_zero (antout[bb->index]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Clear the aux field of this block so that it can be added to
|
|
|
|
|
the worklist again if necessary. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb->aux = NULL;
|
|
|
|
|
sbitmap_intersection_of_succs (antout[bb->index], antin, bb->index);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (sbitmap_a_or_b_and_c_cg (antin[bb->index], antloc[bb->index],
|
|
|
|
|
transp[bb->index], antout[bb->index]))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
*qin++ = e->src;
|
|
|
|
|
e->src->aux = e;
|
|
|
|
|
qlen++;
|
|
|
|
|
if (qin >= qend)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
qin = worklist;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
clear_aux_for_edges ();
|
|
|
|
|
clear_aux_for_blocks ();
|
|
|
|
|
free (worklist);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Compute the earliest vector for edge based lcm. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_earliest (struct edge_list *edge_list, int n_exprs, sbitmap *antin,
|
|
|
|
|
sbitmap *antout, sbitmap *avout, sbitmap *kill,
|
|
|
|
|
sbitmap *earliest)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
sbitmap difference, temp_bitmap;
|
|
|
|
|
int x, num_edges;
|
|
|
|
|
basic_block pred, succ;
|
|
|
|
|
|
|
|
|
|
num_edges = NUM_EDGES (edge_list);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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
|
2003-07-11 03:40:53 +00:00
|
|
|
|
{
|
|
|
|
|
if (succ == EXIT_BLOCK_PTR)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_zero (earliest[x]);
|
|
|
|
|
else
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
sbitmap_free (temp_bitmap);
|
|
|
|
|
sbitmap_free (difference);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* later(p,s) is dependent on the calculation of laterin(p).
|
|
|
|
|
laterin(p) is dependent on the calculation of later(p2,p).
|
|
|
|
|
|
|
|
|
|
laterin(ENTRY) is defined as all 0's
|
|
|
|
|
later(ENTRY, succs(ENTRY)) are defined using laterin(ENTRY)
|
|
|
|
|
laterin(succs(ENTRY)) is defined by later(ENTRY, succs(ENTRY)).
|
|
|
|
|
|
|
|
|
|
If we progress in this manner, starting with all basic blocks
|
|
|
|
|
in the work list, anytime we change later(bb), we need to add
|
|
|
|
|
succs(bb) to the worklist if they are not already on the worklist.
|
|
|
|
|
|
|
|
|
|
Boundary conditions:
|
|
|
|
|
|
|
|
|
|
We prime the worklist all the normal basic blocks. The ENTRY block can
|
|
|
|
|
never be added to the worklist since it is never the successor of any
|
|
|
|
|
block. We explicitly prevent the EXIT block from being added to the
|
|
|
|
|
worklist.
|
|
|
|
|
|
|
|
|
|
We optimistically initialize LATER. That is the only time this routine
|
|
|
|
|
will compute LATER for an edge out of the entry block since the entry
|
|
|
|
|
block is never on the worklist. Thus, LATERIN is neither used nor
|
|
|
|
|
computed for the ENTRY block.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
Since the EXIT block is never added to the worklist, we will neither
|
|
|
|
|
use nor compute LATERIN for the exit block. Edges which reach the
|
|
|
|
|
EXIT block are handled in the normal fashion inside the loop. However,
|
|
|
|
|
the insertion/deletion computation needs LATERIN(EXIT), so we have
|
|
|
|
|
to compute it. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_laterin (struct edge_list *edge_list, sbitmap *earliest,
|
|
|
|
|
sbitmap *antloc, sbitmap *later, sbitmap *laterin)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
int num_edges, i;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
edge e;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block *worklist, *qin, *qout, *qend, bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
unsigned int qlen;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
edge_iterator ei;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
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. */
|
|
|
|
|
qin = qout = worklist
|
2007-05-19 01:19:51 +00:00
|
|
|
|
= XNEWVEC (basic_block, n_basic_blocks);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Initialize a mapping from each edge to its index. */
|
|
|
|
|
for (i = 0; i < num_edges; i++)
|
|
|
|
|
INDEX_EDGE (edge_list, i)->aux = (void *) (size_t) i;
|
|
|
|
|
|
|
|
|
|
/* We want a maximal solution, so initially consider LATER true for
|
|
|
|
|
all edges. This allows propagation through a loop since the incoming
|
|
|
|
|
loop edge will have LATER set, so if all the other incoming edges
|
|
|
|
|
to the loop are set, then LATERIN will be set for the head of the
|
|
|
|
|
loop.
|
|
|
|
|
|
|
|
|
|
If the optimistic setting of LATER on that edge was incorrect (for
|
|
|
|
|
example the expression is ANTLOC in a block within the loop) then
|
|
|
|
|
this algorithm will detect it when we process the block at the head
|
|
|
|
|
of the optimistic edge. That will requeue the affected blocks. */
|
|
|
|
|
sbitmap_vector_ones (later, num_edges);
|
|
|
|
|
|
|
|
|
|
/* Note that even though we want an optimistic setting of LATER, we
|
|
|
|
|
do not want to be overly optimistic. Consider an outgoing edge from
|
|
|
|
|
the entry block. That edge should always have a LATER value the
|
|
|
|
|
same as EARLIEST for that edge. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB (bb)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
*qin++ = bb;
|
|
|
|
|
bb->aux = bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
2007-05-19 01:19:51 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Note that we do not use the last allocated element for our queue,
|
2007-05-19 01:19:51 +00:00
|
|
|
|
as EXIT_BLOCK is never inserted into it. */
|
|
|
|
|
qin = worklist;
|
|
|
|
|
qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS];
|
|
|
|
|
qlen = n_basic_blocks - NUM_FIXED_BLOCKS;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Iterate until the worklist is empty. */
|
|
|
|
|
while (qlen)
|
|
|
|
|
{
|
|
|
|
|
/* Take the first entry off the worklist. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb = *qout++;
|
|
|
|
|
bb->aux = NULL;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
qlen--;
|
|
|
|
|
if (qout >= qend)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
qout = worklist;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Compute the intersection of LATERIN for each incoming edge to B. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_ones (laterin[bb->index]);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
|
|
|
|
sbitmap_a_and_b (laterin[bb->index], laterin[bb->index],
|
|
|
|
|
later[(size_t)e->aux]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Calculate LATER for all outgoing edges. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (sbitmap_union_of_diff_cg (later[(size_t) e->aux],
|
|
|
|
|
earliest[(size_t) e->aux],
|
|
|
|
|
laterin[e->src->index],
|
|
|
|
|
antloc[e->src->index])
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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
|
|
|
|
|
for the EXIT block. We allocated an extra entry in the LATERIN array
|
|
|
|
|
for just this purpose. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_ones (laterin[last_basic_block]);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_a_and_b (laterin[last_basic_block],
|
|
|
|
|
laterin[last_basic_block],
|
2002-02-01 18:16:02 +00:00
|
|
|
|
later[(size_t) e->aux]);
|
|
|
|
|
|
|
|
|
|
clear_aux_for_edges ();
|
|
|
|
|
free (worklist);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Compute the insertion and deletion points for edge based LCM. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_insert_delete (struct edge_list *edge_list, sbitmap *antloc,
|
|
|
|
|
sbitmap *later, sbitmap *laterin, sbitmap *insert,
|
|
|
|
|
sbitmap *delete)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
|
|
|
|
int x;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB (bb)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
sbitmap_difference (delete[bb->index], antloc[bb->index],
|
|
|
|
|
laterin[bb->index]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
for (x = 0; x < NUM_EDGES (edge_list); x++)
|
|
|
|
|
{
|
|
|
|
|
basic_block b = INDEX_EDGE_SUCC_BB (edge_list, x);
|
|
|
|
|
|
|
|
|
|
if (b == EXIT_BLOCK_PTR)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_difference (insert[x], later[x], laterin[last_basic_block]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
|
|
|
|
sbitmap_difference (insert[x], later[x], laterin[b->index]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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 *
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pre_edge_lcm (int n_exprs, sbitmap *transp,
|
2004-07-28 03:11:36 +00:00
|
|
|
|
sbitmap *avloc, sbitmap *antloc, sbitmap *kill,
|
|
|
|
|
sbitmap **insert, sbitmap **delete)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap *antin, *antout, *earliest;
|
|
|
|
|
sbitmap *avin, *avout;
|
|
|
|
|
sbitmap *later, *laterin;
|
|
|
|
|
struct edge_list *edge_list;
|
|
|
|
|
int num_edges;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
edge_list = create_edge_list ();
|
|
|
|
|
num_edges = NUM_EDGES (edge_list);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
fprintf (dump_file, "Edge List:\n");
|
|
|
|
|
verify_edge_list (dump_file, edge_list);
|
|
|
|
|
print_edge_list (dump_file, edge_list);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "transp", "", transp, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "antloc", "", antloc, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "avloc", "", avloc, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "kill", "", kill, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute global availability. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
avin = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
|
|
|
|
avout = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_available (avloc, kill, avout, avin);
|
|
|
|
|
sbitmap_vector_free (avin);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute global anticipatability. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
antin = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
|
|
|
|
antout = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_antinout_edge (antloc, transp, antin, antout);
|
|
|
|
|
|
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "antin", "", antin, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "antout", "", antout, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute earliestness. */
|
|
|
|
|
earliest = sbitmap_vector_alloc (num_edges, n_exprs);
|
|
|
|
|
compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
|
|
|
|
dump_sbitmap_vector (dump_file, "earliest", "", earliest, num_edges);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_vector_free (antout);
|
|
|
|
|
sbitmap_vector_free (antin);
|
|
|
|
|
sbitmap_vector_free (avout);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
later = sbitmap_vector_alloc (num_edges, n_exprs);
|
|
|
|
|
|
|
|
|
|
/* Allocate an extra element for the exit block in the laterin vector. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
laterin = sbitmap_vector_alloc (last_basic_block + 1, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_laterin (edge_list, earliest, antloc, later, laterin);
|
|
|
|
|
|
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "laterin", "", laterin, last_basic_block + 1);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "later", "", later, num_edges);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_vector_free (earliest);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
*insert = sbitmap_vector_alloc (num_edges, n_exprs);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
*delete = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_insert_delete (edge_list, antloc, later, laterin, *insert, *delete);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_vector_free (laterin);
|
|
|
|
|
sbitmap_vector_free (later);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "pre_insert_map", "", *insert, num_edges);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "pre_delete_map", "", *delete,
|
2003-07-11 03:40:53 +00:00
|
|
|
|
last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return edge_list;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_available (sbitmap *avloc, sbitmap *kill, sbitmap *avout,
|
|
|
|
|
sbitmap *avin)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
edge e;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block *worklist, *qin, *qout, *qend, bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
unsigned int qlen;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
edge_iterator ei;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
qin = qout = worklist =
|
|
|
|
|
XNEWVEC (basic_block, n_basic_blocks - NUM_FIXED_BLOCKS);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* We want a maximal solution. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_vector_ones (avout, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Put every block on the worklist; this is necessary because of the
|
|
|
|
|
optimistic initialization of AVOUT above. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB (bb)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
*qin++ = bb;
|
|
|
|
|
bb->aux = bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
qin = worklist;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
qend = &worklist[n_basic_blocks - NUM_FIXED_BLOCKS];
|
|
|
|
|
qlen = n_basic_blocks - NUM_FIXED_BLOCKS;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Mark blocks which are successors of the entry block so that we
|
|
|
|
|
can easily identify them below. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
e->dest->aux = ENTRY_BLOCK_PTR;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Iterate until the worklist is empty. */
|
|
|
|
|
while (qlen)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Take the first entry off the worklist. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb = *qout++;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
qlen--;
|
|
|
|
|
|
|
|
|
|
if (qout >= qend)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
qout = worklist;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
if (bb->aux == ENTRY_BLOCK_PTR)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_zero (avin[bb->index]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Clear the aux field of this block so that it can be added to
|
|
|
|
|
the worklist again if necessary. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb->aux = NULL;
|
|
|
|
|
sbitmap_intersection_of_preds (avin[bb->index], avout, bb->index);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (sbitmap_union_of_diff_cg (avout[bb->index], avloc[bb->index],
|
|
|
|
|
avin[bb->index], kill[bb->index]))
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
*qin++ = e->dest;
|
|
|
|
|
e->dest->aux = e;
|
|
|
|
|
qlen++;
|
|
|
|
|
|
|
|
|
|
if (qin >= qend)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
qin = worklist;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
clear_aux_for_edges ();
|
|
|
|
|
clear_aux_for_blocks ();
|
|
|
|
|
free (worklist);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute the farthest vector for edge based lcm. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_farthest (struct edge_list *edge_list, int n_exprs,
|
|
|
|
|
sbitmap *st_avout, sbitmap *st_avin, sbitmap *st_antin,
|
|
|
|
|
sbitmap *kill, sbitmap *farthest)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap difference, temp_bitmap;
|
|
|
|
|
int x, num_edges;
|
|
|
|
|
basic_block pred, succ;
|
|
|
|
|
|
|
|
|
|
num_edges = NUM_EDGES (edge_list);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
difference = sbitmap_alloc (n_exprs);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
temp_bitmap = sbitmap_alloc (n_exprs);
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
for (x = 0; x < num_edges; x++)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_free (temp_bitmap);
|
|
|
|
|
sbitmap_free (difference);
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute nearer and nearerout vectors for edge based lcm.
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
This is the mirror of compute_laterin, additional comments on the
|
|
|
|
|
implementation can be found before compute_laterin. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_nearerout (struct edge_list *edge_list, sbitmap *farthest,
|
|
|
|
|
sbitmap *st_avloc, sbitmap *nearer, sbitmap *nearerout)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
int num_edges, i;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
edge e;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block *worklist, *tos, bb;
|
2007-05-19 01:19:51 +00:00
|
|
|
|
edge_iterator ei;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
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. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
tos = worklist = XNEWVEC (basic_block, n_basic_blocks + 1);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Initialize NEARER for each edge and build a mapping from an edge to
|
|
|
|
|
its index. */
|
|
|
|
|
for (i = 0; i < num_edges; i++)
|
|
|
|
|
INDEX_EDGE (edge_list, i)->aux = (void *) (size_t) i;
|
|
|
|
|
|
|
|
|
|
/* We want a maximal solution. */
|
|
|
|
|
sbitmap_vector_ones (nearer, num_edges);
|
|
|
|
|
|
|
|
|
|
/* Note that even though we want an optimistic setting of NEARER, we
|
|
|
|
|
do not want to be overly optimistic. Consider an incoming edge to
|
|
|
|
|
the exit block. That edge should always have a NEARER value the
|
|
|
|
|
same as FARTHEST for that edge. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_copy (nearer[(size_t)e->aux], farthest[(size_t)e->aux]);
|
|
|
|
|
|
|
|
|
|
/* Add all the blocks to the worklist. This prevents an early exit
|
|
|
|
|
from the loop given our optimistic initialization of NEARER. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB (bb)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2003-07-11 03:40:53 +00:00
|
|
|
|
*tos++ = bb;
|
|
|
|
|
bb->aux = bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Iterate until the worklist is empty. */
|
|
|
|
|
while (tos != worklist)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Take the first entry off the worklist. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
bb = *--tos;
|
|
|
|
|
bb->aux = NULL;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Compute the intersection of NEARER for each outgoing edge from B. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_ones (nearerout[bb->index]);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_a_and_b (nearerout[bb->index], nearerout[bb->index],
|
2002-02-01 18:16:02 +00:00
|
|
|
|
nearer[(size_t) e->aux]);
|
|
|
|
|
|
|
|
|
|
/* Calculate NEARER for all incoming edges. */
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
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])
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* 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;
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
|
|
|
|
/* Computation of insertion and deletion points requires computing NEAREROUT
|
|
|
|
|
for the ENTRY block. We allocated an extra entry in the NEAREROUT array
|
|
|
|
|
for just this purpose. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_ones (nearerout[last_basic_block]);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_a_and_b (nearerout[last_basic_block],
|
|
|
|
|
nearerout[last_basic_block],
|
2002-02-01 18:16:02 +00:00
|
|
|
|
nearer[(size_t) e->aux]);
|
|
|
|
|
|
|
|
|
|
clear_aux_for_edges ();
|
|
|
|
|
free (tos);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute the insertion and deletion points for edge based LCM. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
|
|
|
|
static void
|
2004-07-28 03:11:36 +00:00
|
|
|
|
compute_rev_insert_delete (struct edge_list *edge_list, sbitmap *st_avloc,
|
|
|
|
|
sbitmap *nearer, sbitmap *nearerout,
|
|
|
|
|
sbitmap *insert, sbitmap *delete)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
int x;
|
2003-07-11 03:40:53 +00:00
|
|
|
|
basic_block bb;
|
2002-02-01 18:16:02 +00:00
|
|
|
|
|
2003-07-11 03:40:53 +00:00
|
|
|
|
FOR_EACH_BB (bb)
|
2007-05-19 01:19:51 +00:00
|
|
|
|
sbitmap_difference (delete[bb->index], st_avloc[bb->index],
|
|
|
|
|
nearerout[bb->index]);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
for (x = 0; x < NUM_EDGES (edge_list); x++)
|
|
|
|
|
{
|
|
|
|
|
basic_block b = INDEX_EDGE_PRED_BB (edge_list, x);
|
|
|
|
|
if (b == ENTRY_BLOCK_PTR)
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_difference (insert[x], nearer[x], nearerout[last_basic_block]);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
else
|
|
|
|
|
sbitmap_difference (insert[x], nearer[x], nearerout[b->index]);
|
|
|
|
|
}
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Given local properties TRANSP, ST_AVLOC, ST_ANTLOC, KILL return the
|
|
|
|
|
insert and delete vectors for edge based reverse LCM. Returns an
|
|
|
|
|
edgelist which is used to map the insert vector to what edge
|
|
|
|
|
an expression should be inserted on. */
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
struct edge_list *
|
2007-05-19 01:19:51 +00:00
|
|
|
|
pre_edge_rev_lcm (int n_exprs, sbitmap *transp,
|
2004-07-28 03:11:36 +00:00
|
|
|
|
sbitmap *st_avloc, sbitmap *st_antloc, sbitmap *kill,
|
|
|
|
|
sbitmap **insert, sbitmap **delete)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2002-02-01 18:16:02 +00:00
|
|
|
|
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);
|
|
|
|
|
|
2004-07-28 03:11:36 +00:00
|
|
|
|
st_antin = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
|
|
|
|
st_antout = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
sbitmap_vector_zero (st_antin, last_basic_block);
|
|
|
|
|
sbitmap_vector_zero (st_antout, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_antinout_edge (st_antloc, transp, st_antin, st_antout);
|
|
|
|
|
|
|
|
|
|
/* Compute global anticipatability. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
st_avout = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
|
|
|
|
st_avin = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_available (st_avloc, kill, st_avout, st_avin);
|
|
|
|
|
|
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
fprintf (dump_file, "Edge List:\n");
|
|
|
|
|
verify_edge_list (dump_file, edge_list);
|
|
|
|
|
print_edge_list (dump_file, edge_list);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "transp", "", transp, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_avloc", "", st_avloc, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_antloc", "", st_antloc, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_antin", "", st_antin, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_antout", "", st_antout, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_kill", "", kill, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
2002-02-01 18:16:02 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "st_avout", "", st_avout, last_basic_block);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "st_avin", "", st_avin, last_basic_block);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
}
|
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
/* Compute farthestness. */
|
|
|
|
|
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
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
|
|
|
|
dump_sbitmap_vector (dump_file, "farthest", "", farthest, num_edges);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#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);
|
|
|
|
|
|
|
|
|
|
/* Allocate an extra element for the entry block. */
|
2003-07-11 03:40:53 +00:00
|
|
|
|
nearerout = sbitmap_vector_alloc (last_basic_block + 1, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout);
|
|
|
|
|
|
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "nearerout", "", nearerout,
|
2003-07-11 03:40:53 +00:00
|
|
|
|
last_basic_block + 1);
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "nearer", "", nearer, num_edges);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#endif
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_vector_free (farthest);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
*insert = sbitmap_vector_alloc (num_edges, n_exprs);
|
2003-07-11 03:40:53 +00:00
|
|
|
|
*delete = sbitmap_vector_alloc (last_basic_block, n_exprs);
|
2002-02-01 18:16:02 +00:00
|
|
|
|
compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
|
|
|
|
|
*insert, *delete);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
sbitmap_vector_free (nearerout);
|
|
|
|
|
sbitmap_vector_free (nearer);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#ifdef LCM_DEBUG_INFO
|
2007-05-19 01:19:51 +00:00
|
|
|
|
if (dump_file)
|
1999-10-16 06:09:09 +00:00
|
|
|
|
{
|
2007-05-19 01:19:51 +00:00
|
|
|
|
dump_sbitmap_vector (dump_file, "pre_insert_map", "", *insert, num_edges);
|
|
|
|
|
dump_sbitmap_vector (dump_file, "pre_delete_map", "", *delete,
|
2003-07-11 03:40:53 +00:00
|
|
|
|
last_basic_block);
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
2002-02-01 18:16:02 +00:00
|
|
|
|
#endif
|
|
|
|
|
return edge_list;
|
1999-10-16 06:09:09 +00:00
|
|
|
|
}
|
|
|
|
|
|