/* SSA-PRE for trees.
Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dan@dberlin.org> and Steven Bosscher
- <stevenb@suse.de>
+ <stevenb@suse.de>
This file is part of GCC.
#include "cfgloop.h"
/* TODO:
-
+
1. Avail sets can be shared by making an avail_find_leader that
walks up the dominator tree and looks in those avail sets.
This might affect code optimality, it's unclear right now.
any store in a block, instead of loads that occur before
stores that affect them. This is relatively more expensive, and
it's not clear how much more it will buy us.
-*/
+*/
/* For ease of terminology, "expression node" in the below refers to
every expression node but MODIFY_EXPR, because MODIFY_EXPR's represent
we cache the value number by putting it in the expression. */
/* Basic algorithm
-
+
First we walk the statements to generate the AVAIL sets, the
EXP_GEN sets, and the tmp_gen sets. EXP_GEN sets represent the
generation of values/expressions by a given block. We use them
fixpoint iteration, in order to calculate the AVAIL sets. In
traditional parlance, AVAIL sets tell us the downsafety of the
expressions/values.
-
+
Next, we generate the ANTIC sets. These sets represent the
anticipatable expressions. ANTIC is a backwards dataflow
problem.An expression is anticipatable in a given block if it could
unique number for each value number in use. This allows
expressions with SSA_NAMES replaced by value handles to still be
pretty printed in a sane way. They simply print as "value.3 *
- value.5", etc.
+ value.5", etc.
Expression nodes have value handles associated with them as a
cache. Otherwise, we'd have to look them up again in the hash
some test cases. They can be thrown away after the pass is
finished. */
-/* Representation of expressions on value numbers:
+/* Representation of expressions on value numbers:
In some portions of this code, you will notice we allocate "fake"
analogues to the expression we are value numbering, and replace the
operands with the values of the expression. Since we work on
values, and not just names, we canonicalize expressions to value
- expressions for use in the ANTIC sets, the EXP_GEN set, etc.
+ expressions for use in the ANTIC sets, the EXP_GEN set, etc.
This is theoretically unnecessary, it just saves a bunch of
repeated get_value_handle and find_leader calls in the remainder of
the code, trading off temporary memory usage for speed. The tree
nodes aren't actually creating more garbage, since they are
allocated in a special pools which are thrown away at the end of
- this pass.
+ this pass.
All of this also means that if you print the EXP_GEN or ANTIC sets,
you will see "value.5 + value.7" in the set, instead of "a_55 +
and thus, are simply represented as two bitmaps, one that keeps
track of values present in the set, and one that keeps track of
expressions present in the set.
-
+
The other sets are represented as doubly linked lists kept in topological
order, with an optional supporting bitmap of values present in the
set. The sets represent values, and the elements can be values or
necessary to keep the set in topologically sorted order because
of how the set is built. */
value_set_node_t tail;
-
+
/* The length of the list. */
size_t length;
-
+
/* True if the set is indexed, which means it contains a backing
bitmap for quick determination of whether certain values exist in the
set. */
bool indexed;
-
+
/* The bitmap of values that exist in the set. May be NULL in an
empty or non-indexed set. */
bitmap values;
-
+
} *value_set_t;
/* The number of new PHI nodes added by PRE. */
int phis;
-
+
/* The number of values found constant. */
int constified;
-
+
} pre_stats;
basic_block b2 = ve2->pred;
int i;
tree vuse1;
-
+
/* If they are not translations for the same basic block, they can't
be equal. */
if (b1 != b2)
/* If they are for the same basic block, determine if the
- expressions are equal. */
+ expressions are equal. */
if (!expressions_equal_p (ve1->e, ve2->e))
return false;
/* Make sure the vuses are equivalent. */
if (ve1->vuses == ve2->vuses)
return true;
-
+
if (VEC_length (tree, ve1->vuses) != VEC_length (tree, ve2->vuses))
return false;
/* Create a new bitmap set and return it. */
-static bitmap_set_t
+static bitmap_set_t
bitmap_set_new (void)
{
bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
/* XXX: For now, we only let SSA_NAMES into the bitmap sets. */
gcc_assert (TREE_CODE (expr) == SSA_NAME);
val = get_value_handle (expr);
-
+
gcc_assert (val);
if (!is_gimple_min_invariant (val))
{
value_set_node_t newnode = (value_set_node_t) pool_alloc (value_set_node_pool);
tree val = get_value_handle (expr);
gcc_assert (val);
-
+
if (is_gimple_min_invariant (val))
return;
set_copy (value_set_t dest, value_set_t orig)
{
value_set_node_t node;
-
+
if (!orig || !orig->head)
return;
value_set_node_t node, prev;
/* Remove the value of EXPR from the bitmap, decrement the set
- length, and remove it from the actual double linked list. */
+ length, and remove it from the actual double linked list. */
value_remove_from_set_bitmap (set, get_value_handle (expr));
set->length--;
prev = NULL;
- for (node = set->head;
- node != NULL;
+ for (node = set->head;
+ node != NULL;
prev = node, node = node->next)
{
if (node->expr == expr)
set->head = node->next;
else
prev->next= node->next;
-
+
if (node == set->tail)
set->tail = prev;
pool_free (value_set_node_pool, node);
/* All constants are in every set. */
if (is_gimple_min_invariant (val))
return true;
-
+
if (!set || set->length == 0)
return false;
-
+
return value_exists_in_set_bitmap (set, val);
}
return bitmap_bit_p (set->expressions, SSA_NAME_VERSION (expr));
}
-
+
/* Return true if bitmapped set SET contains the value VAL. */
static bool
if (is_gimple_min_invariant (val))
return;
-
+
if (!bitmap_set_contains_value (set, val))
bitmap_insert_into_set (set, expr);
}
fprintf (outfile, ", ");
first = false;
print_generic_expr (outfile, ssa_name (i), 0);
-
+
fprintf (outfile, " (");
print_generic_expr (outfile, get_value_handle (ssa_name (i)), 0);
fprintf (outfile, ") ");
node = node->next)
{
print_generic_expr (outfile, node->expr, 0);
-
+
fprintf (outfile, " (");
print_generic_expr (outfile, get_value_handle (node->expr), 0);
fprintf (outfile, ") ");
-
+
if (node->next)
fprintf (outfile, ", ");
}
print_value_expressions (stderr, val);
}
-
+
void debug_value_set (value_set_t, const char *, int);
void
}
/* Return the folded version of T if T, when folded, is a gimple
- min_invariant. Otherwise, return T. */
+ min_invariant. Otherwise, return T. */
static tree
fully_constant_expression (tree t)
-{
+{
tree folded;
folded = fold (t);
if (folded && is_gimple_min_invariant (folded))
}
/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
- For example, this can copy a list made of TREE_LIST nodes.
+ For example, this can copy a list made of TREE_LIST nodes.
Allocates the nodes in list_node_pool*/
static tree
if (list == 0)
return 0;
head = (tree) pool_alloc (list_node_pool);
-
+
memcpy (head, list, tree_size (list));
prev = head;
-
+
next = TREE_CHAIN (list);
while (next)
{
if (phitrans)
return phitrans;
-
+
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case tcc_expression:
as one value number, because that doesn't make much
sense, and just breaks the support functions we call,
which expect TREE_OPERAND (call_expr, 2) to be a
- TREE_LIST. */
-
+ TREE_LIST. */
+
newop0 = phi_translate (find_leader (set, oldop0),
set, pred, phiblock);
if (newop0 == NULL)
}
/* phi translate the argument list piece by piece.
-
+
We could actually build the list piece by piece here,
but it's likely to not be worth the memory we will save,
unless you have millions of call arguments. */
newarglist = pool_copy_list (oldarglist);
for (oldwalker = oldarglist, newwalker = newarglist;
oldwalker && newwalker;
- oldwalker = TREE_CHAIN (oldwalker),
+ oldwalker = TREE_CHAIN (oldwalker),
newwalker = TREE_CHAIN (newwalker))
{
-
+
tree oldval = TREE_VALUE (oldwalker);
tree newval;
if (oldval)
}
if (listchanged)
vn_lookup_or_add (newarglist, NULL);
-
+
tvuses = translate_vuses_through_block (vuses, pred);
if (listchanged || (newop0 != oldop0) || (oldop2 != newop2)
TREE_OPERAND (newexpr, 0) = newop0 == oldop0 ? oldop0 : get_value_handle (newop0);
TREE_OPERAND (newexpr, 1) = listchanged ? newarglist : oldarglist;
TREE_OPERAND (newexpr, 2) = newop2 == oldop2 ? oldop2 : get_value_handle (newop2);
- create_tree_ann (newexpr);
+ create_tree_ann (newexpr);
vn_lookup_or_add_with_vuses (newexpr, tvuses);
expr = newexpr;
phi_trans_add (oldexpr, newexpr, pred, tvuses);
set, pred, phiblock);
if (newop0 == NULL)
return NULL;
-
+
if (TREE_CODE (expr) == ARRAY_REF)
{
oldop1 = TREE_OPERAND (expr, 1);
newop1 = phi_translate (find_leader (set, oldop1),
set, pred, phiblock);
-
+
if (newop1 == NULL)
return NULL;
oldop2 = TREE_OPERAND (expr, 2);
{
newop2 = phi_translate (find_leader (set, oldop2),
set, pred, phiblock);
-
+
if (newop2 == NULL)
return NULL;
}
{
newop3 = phi_translate (find_leader (set, oldop3),
set, pred, phiblock);
-
+
if (newop3 == NULL)
return NULL;
}
oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr));
if (oldvuses)
newvuses = translate_vuses_through_block (oldvuses, pred);
-
+
if (newop0 != oldop0 || newvuses != oldvuses
- || newop1 != oldop1
- || newop2 != oldop2
+ || newop1 != oldop1
+ || newop2 != oldop2
|| newop3 != oldop3)
{
tree t;
tree newop1;
tree newop2;
tree newexpr;
-
+
newop1 = phi_translate (find_leader (set, oldop1),
set, pred, phiblock);
if (newop1 == NULL)
}
else
{
- create_tree_ann (newexpr);
+ create_tree_ann (newexpr);
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
}
else
{
- create_tree_ann (newexpr);
+ create_tree_ann (newexpr);
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
phi = SSA_NAME_DEF_STMT (expr);
else
return expr;
-
+
e = find_edge (pred, bb_for_stmt (phi));
if (e)
{
node = node->next)
{
tree translated;
-
+
translated = phi_translate (node->expr, set, pred, phiblock);
/* Don't add constants or empty translations to the cache, since
{
tree vh = get_value_handle (translated);
VEC (tree, gc) *vuses;
-
+
/* The value handle itself may also be an invariant, in
which case, it has no vuses. */
vuses = !is_gimple_min_invariant (vh)
if (translated != NULL)
value_insert_into_set (dest, translated);
- }
+ }
}
/* Find the leader for a value (i.e., the name representing that
{
if (val == NULL)
return NULL;
-
+
if (is_gimple_min_invariant (val))
return val;
if (bitmap_set_contains_value (set, val))
large testcases, doing it this way is roughly 5-10x faster
than walking the bitmap.
If this is somehow a significant lose for some cases, we can
- choose which set to walk based on which set is smaller. */
+ choose which set to walk based on which set is smaller. */
value_set_t exprset;
value_set_node_t node;
exprset = VALUE_HANDLE_EXPR_SET (val);
{
if (TREE_CODE (node->expr) == SSA_NAME)
{
- if (bitmap_bit_p (set->expressions,
+ if (bitmap_bit_p (set->expressions,
SSA_NAME_VERSION (node->expr)))
return node->expr;
}
return NULL;
}
-
+
/* Find the leader for a value (i.e., the name representing that
value) in a given set, and return it. Return NULL if no leader is
found. */
if (set->length == 0)
return NULL;
-
+
if (value_exists_in_set_bitmap (set, val))
{
for (node = set->head;
/* Determine if the expression EXPR is valid in SET. This means that
we have a leader for each part of the expression (if it consists of
- values), or the expression is an SSA_NAME.
+ values), or the expression is an SSA_NAME.
NB: We never should run into a case where we have SSA_NAME +
SSA_NAME or SSA_NAME + value. The sets valid_in_set is called on,
tree op1 = TREE_OPERAND (expr, 0);
return set_contains_value (set, op1);
}
-
+
case tcc_expression:
{
if (TREE_CODE (expr) == CALL_EXPR)
}
return false;
}
-
+
case tcc_reference:
{
- if (TREE_CODE (expr) == INDIRECT_REF
+ if (TREE_CODE (expr) == INDIRECT_REF
|| TREE_CODE (expr) == COMPONENT_REF
|| TREE_CODE (expr) == ARRAY_REF)
{
default:
/* No other cases should be encountered. */
- gcc_unreachable ();
+ gcc_unreachable ();
}
}
while (node)
{
next = node->next;
- if (!valid_in_set (set, node->expr, block))
+ if (!valid_in_set (set, node->expr, block))
set_remove (set, node->expr);
node = next;
}
S = bitmap_set_subtract_from_value_set (ANTIC_OUT, TMP_GEN (block), false);
/* Start ANTIC_IN with EXP_GEN - TMP_GEN */
- ANTIC_IN (block) = bitmap_set_subtract_from_value_set (EXP_GEN (block),
+ ANTIC_IN (block) = bitmap_set_subtract_from_value_set (EXP_GEN (block),
TMP_GEN (block),
true);
print_value_set (dump_file, ANTIC_OUT, "ANTIC_OUT", block->index);
if (ANTIC_SAFE_LOADS (block))
- print_value_set (dump_file, ANTIC_SAFE_LOADS (block),
+ print_value_set (dump_file, ANTIC_SAFE_LOADS (block),
"ANTIC_SAFE_LOADS", block->index);
print_value_set (dump_file, ANTIC_IN (block), "ANTIC_IN", block->index);
uses, and virtual uses *do* actually die, this ends up being faster
in most cases than continually walking the virtual use/def chains
to determine whether we are inside a block where a given virtual is
- still available to be used.
+ still available to be used.
ANTIC_SAFE_LOADS are those loads that actually occur before any kill to
their vuses in the block,and thus, are safe at the top of the
- block.
+ block.
An example:
b = *a
*a = 9
<block end>
-
+
b = *a is an antic safe load because it still safe to consider it
ANTIC at the top of the block.
unsigned int *first_store_uid;
first_store_uid = xcalloc (n_basic_blocks, sizeof (unsigned int));
-
+
compute_vuse_representatives ();
FOR_ALL_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
-
- if (first_store_uid[bb->index] == 0
- && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VMAYDEF
+
+ if (first_store_uid[bb->index] == 0
+ && !ZERO_SSA_OPERANDS (stmt, SSA_OP_VMAYUSE | SSA_OP_VMAYDEF
| SSA_OP_VMUSTDEF | SSA_OP_VMUSTKILL))
{
first_store_uid[bb->index] = stmt_ann (stmt)->uid;
}
-
+
FOR_EACH_SSA_USE_OPERAND (usep, stmt, iter, SSA_OP_VIRTUAL_KILLS
| SSA_OP_VMAYUSE)
}
FOR_EACH_BB (bb)
- {
+ {
value_set_node_t node;
if (bitmap_empty_p (RVUSE_KILL (bb)))
continue;
-
+
for (node = EXP_GEN (bb)->head; node; node = node->next)
{
if (REFERENCE_CLASS_P (node->expr))
{
tree vh = get_value_handle (node->expr);
tree maybe = bitmap_find_leader (AVAIL_OUT (bb), vh);
-
+
if (maybe)
{
tree def = SSA_NAME_DEF_STMT (maybe);
if (bb_for_stmt (def) != bb)
continue;
-
+
if (TREE_CODE (def) == PHI_NODE
|| stmt_ann (def)->uid < first_store_uid[bb->index])
{
if (ANTIC_SAFE_LOADS (bb) == NULL)
ANTIC_SAFE_LOADS (bb) = set_new (true);
- value_insert_into_set (ANTIC_SAFE_LOADS (bb),
+ value_insert_into_set (ANTIC_SAFE_LOADS (bb),
node->expr);
}
}
Thus, this routine doesn't create temporaries, it just builds a
single access expression for the array, calling
find_or_generate_expression to build the innermost pieces.
-
+
This function is a subroutine of create_expression_by_pieces, and
should not be called on it's own unless you really know what you
are doing.
if (found)
return found;
}
-
+
if (TREE_CODE (genop) == VALUE_HANDLE)
genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
{
tree op0;
tree op1, op2, op3;
- op0 = create_component_ref_by_pieces (block,
+ op0 = create_component_ref_by_pieces (block,
TREE_OPERAND (genop, 0),
stmts);
op1 = TREE_OPERAND (genop, 1);
op3 = TREE_OPERAND (genop, 3);
if (op3 && TREE_CODE (op3) == VALUE_HANDLE)
op3 = find_or_generate_expression (block, op3, stmts);
- folded = build4 (ARRAY_REF, TREE_TYPE (genop), op0, op1,
+ folded = build4 (ARRAY_REF, TREE_TYPE (genop), op0, op1,
op2, op3);
return folded;
}
{
tree op0;
tree op1;
- op0 = create_component_ref_by_pieces (block,
+ op0 = create_component_ref_by_pieces (block,
TREE_OPERAND (genop, 0),
stmts);
op1 = VALUE_HANDLE_EXPR_SET (TREE_OPERAND (genop, 1))->head->expr;
- folded = fold_build3 (COMPONENT_REF, TREE_TYPE (genop), op0, op1,
+ folded = fold_build3 (COMPONENT_REF, TREE_TYPE (genop), op0, op1,
NULL_TREE);
return folded;
}
{
tree op1 = TREE_OPERAND (genop, 0);
tree genop1 = find_or_generate_expression (block, op1, stmts);
-
+
folded = fold_build1 (TREE_CODE (genop), TREE_TYPE (genop),
genop1);
return folded;
case STRING_CST:
return genop;
default:
- gcc_unreachable ();
+ gcc_unreachable ();
}
return NULL_TREE;
/* Find a leader for an expression, or generate one using
create_expression_by_pieces if it's ANTIC but
- complex.
+ complex.
BLOCK is the basic_block we are looking for leaders in.
- EXPR is the expression to find a leader or generate for.
+ EXPR is the expression to find a leader or generate for.
STMTS is the statement list to put the inserted expressions on.
Returns the SSA_NAME of the LHS of the generated expression or the
leader. */
return genop;
}
-#define NECESSARY(stmt) stmt->common.asm_written_flag
+#define NECESSARY(stmt) stmt->common.asm_written_flag
/* Create an expression in pieces, so that we can handle very complex
- expressions that may be ANTIC, but not necessary GIMPLE.
+ expressions that may be ANTIC, but not necessary GIMPLE.
BLOCK is the basic block the expression will be inserted into,
EXPR is the expression to insert (in value form)
STMTS is a statement list to append the necessary insertions into.
tree genop0, genop2;
tree genarglist;
tree walker, genwalker;
-
+
gcc_assert (TREE_CODE (expr) == CALL_EXPR);
genop2 = NULL;
-
+
op0 = TREE_OPERAND (expr, 0);
arglist = TREE_OPERAND (expr, 1);
op2 = TREE_OPERAND (expr, 2);
-
+
genop0 = find_or_generate_expression (block, op0, stmts);
genarglist = copy_list (arglist);
for (walker = arglist, genwalker = genarglist;
stmts);
}
- if (op2)
+ if (op2)
genop2 = find_or_generate_expression (block, op2, stmts);
folded = fold_build3 (TREE_CODE (expr), TREE_TYPE (expr),
genop0, genarglist, genop2);
break;
-
-
+
+
}
break;
case tcc_reference:
{
tree op1 = TREE_OPERAND (expr, 0);
tree genop1 = find_or_generate_expression (block, op1, stmts);
-
+
folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
genop1);
}
break;
}
-
+
case tcc_binary:
case tcc_comparison:
{
tree op2 = TREE_OPERAND (expr, 1);
tree genop1 = find_or_generate_expression (block, op1, stmts);
tree genop2 = find_or_generate_expression (block, op2, stmts);
- folded = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr),
+ folded = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr),
genop1, genop2);
break;
}
{
tree op1 = TREE_OPERAND (expr, 0);
tree genop1 = find_or_generate_expression (block, op1, stmts);
- folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
+ folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
genop1);
break;
}
statements.
We have to call unshare_expr because force_gimple_operand may
modify the tree we pass to it. */
- newexpr = force_gimple_operand (unshare_expr (folded), &forced_stmts,
+ newexpr = force_gimple_operand (unshare_expr (folded), &forced_stmts,
false, NULL);
/* If we have any intermediate expressions to the value sets, add them
tree forcedname = TREE_OPERAND (stmt, 0);
tree forcedexpr = TREE_OPERAND (stmt, 1);
tree val = vn_lookup_or_add (forcedexpr, NULL);
-
+
VEC_safe_push (tree, heap, inserted_exprs, stmt);
vn_add (forcedname, val);
bitmap_value_replace_in_set (NEW_SETS (block), forcedname);
here. */
v = get_value_handle (expr);
vn_add (name, v);
- bitmap_value_replace_in_set (NEW_SETS (block), name);
+ bitmap_value_replace_in_set (NEW_SETS (block), name);
bitmap_value_replace_in_set (AVAIL_OUT (block), name);
pre_stats.insertions++;
if (dump_file && (dump_flags & TDF_DETAILS))
- {
+ {
fprintf (dump_file, "Inserted ");
print_generic_expr (dump_file, newexpr, 0);
fprintf (dump_file, " in predecessor %d\n", block->index);
edge_iterator ei;
tree type = TREE_TYPE (avail[EDGE_PRED (block, 0)->src->index]);
tree temp;
-
+
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Found partial redundancy for expression ");
{
bool firstinsideloop = false;
bool secondinsideloop = false;
- firstinsideloop = flow_bb_inside_loop_p (block->loop_father,
+ firstinsideloop = flow_bb_inside_loop_p (block->loop_father,
EDGE_PRED (block, 0)->src);
secondinsideloop = flow_bb_inside_loop_p (block->loop_father,
EDGE_PRED (block, 1)->src);
nophi = true;
}
}
-
+
/* Make the necessary insertions. */
FOR_EACH_EDGE (pred, ei, block->preds)
tree vh;
/* eprime may be an invariant. */
- vh = TREE_CODE (eprime) == VALUE_HANDLE
+ vh = TREE_CODE (eprime) == VALUE_HANDLE
? eprime
: get_value_handle (eprime);
bsi_insert_on_edge (pred, stmts);
avail[bprime->index] = builtexpr;
insertions = true;
- }
+ }
}
/* If we didn't want a phi node, and we made insertions, we still have
inserted new stuff, and thus return true. If we didn't want a phi node,
DECL_COMPLEX_GIMPLE_REG_P (temp) = 1;
temp = create_phi_node (temp, block);
- NECESSARY (temp) = 0;
+ NECESSARY (temp) = 0;
VEC_safe_push (tree, heap, inserted_exprs, temp);
FOR_EACH_EDGE (pred, ei, block->preds)
add_phi_arg (temp, avail[pred->src->index], pred);
-
+
vn_add (PHI_RESULT (temp), val);
-
+
/* The value should *not* exist in PHI_GEN, or else we wouldn't be doing
this insertion, since we test for the existence of this value in PHI_GEN
before proceeding with the partial redundancy checks in insert_aux.
-
+
The value may exist in AVAIL_OUT, in particular, it could be represented
by the expression we are trying to eliminate, in which case we want the
replacement to occur. If it's not existing in AVAIL_OUT, we want it
inserted there.
-
+
Similarly, to the PHI_GEN case, the value should not exist in NEW_SETS of
this block, because if it did, it would have existed in our dominator's
AVAIL_OUT, and would have been skipped due to the full redundancy check.
bitmap_insert_into_set (PHI_GEN (block),
PHI_RESULT (temp));
- bitmap_value_replace_in_set (AVAIL_OUT (block),
+ bitmap_value_replace_in_set (AVAIL_OUT (block),
PHI_RESULT (temp));
bitmap_insert_into_set (NEW_SETS (block),
PHI_RESULT (temp));
-
+
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Created phi ");
}
-
+
/* Perform insertion of partially redundant values.
For BLOCK, do the following:
1. Propagate the NEW_SETS of the dominator into the current block.
- If the block has multiple predecessors,
+ If the block has multiple predecessors,
2a. Iterate over the ANTIC expressions for the block to see if
any of them are partially redundant.
2b. If so, insert them into the necessary predecessors to make
the expression fully redundant.
2c. Insert a new PHI merging the values of the predecessors.
2d. Insert the new PHI, and the new expressions, into the
- NEW_SETS set.
+ NEW_SETS set.
3. Recursively call ourselves on the dominator children of BLOCK.
*/
val = get_value_handle (node->expr);
if (bitmap_set_contains_value (PHI_GEN (block), val))
- continue;
+ continue;
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Found fully redundant value\n");
continue;
}
-
+
avail = XCNEWVEC (tree, last_basic_block);
FOR_EACH_EDGE (pred, ei, block->preds)
{
else
{
avail[bprime->index] = edoubleprime;
- by_some = true;
+ by_some = true;
if (first_s == NULL)
first_s = edoubleprime;
else if (!operand_equal_p (first_s, edoubleprime,
/* If all edges produce the same value and that value is
an invariant, then the PHI has the same value on all
edges. Note this. */
- else if (!cant_insert && all_same && eprime
+ else if (!cant_insert && all_same && eprime
&& is_gimple_min_invariant (eprime)
&& !is_gimple_min_invariant (val))
{
for (node = exprset->head; node; node = node->next)
{
if (TREE_CODE (node->expr) == SSA_NAME)
- {
+ {
vn_add (node->expr, eprime);
pre_stats.constified++;
}
bool new_stuff = true;
basic_block bb;
int num_iterations = 0;
-
+
FOR_ALL_BB (bb)
NEW_SETS (bb) = bitmap_set_new ();
-
+
while (new_stuff)
{
num_iterations++;
gcc_assert (code == TREE_LIST);
pool = list_node_pool;
}
- else
+ else
{
gcc_assert (code == CALL_EXPR);
pool = expression_node_pool;
vexpr = (tree) pool_alloc (pool);
memcpy (vexpr, expr, tree_size (expr));
-
+
/* This case is only for TREE_LIST's that appear as part of
CALL_EXPR's. Anything else is a bug, but we can't easily verify
this, hence this comment. TREE_LIST is not handled by the
tree op = NULL_TREE;
tree temp = NULL_TREE;
if (TREE_CHAIN (vexpr))
- temp = create_value_expr_from (TREE_CHAIN (vexpr), block, stmt);
+ temp = create_value_expr_from (TREE_CHAIN (vexpr), block, stmt);
TREE_CHAIN (vexpr) = temp ? temp : TREE_CHAIN (vexpr);
-
+
/* Recursively value-numberize reference ops. */
if (REFERENCE_CLASS_P (TREE_VALUE (vexpr)))
op = TREE_VALUE (vexpr);
tempop = create_value_expr_from (op, block, stmt);
op = tempop ? tempop : op;
-
+
TREE_VALUE (vexpr) = vn_lookup_or_add (op, stmt);
}
else
for (i = 0; i < TREE_CODE_LENGTH (code); i++)
{
tree val, op;
-
+
op = TREE_OPERAND (expr, i);
if (op == NULL_TREE)
continue;
else if (TREE_CODE (op) == TREE_LIST)
{
tree tempop;
-
+
gcc_assert (TREE_CODE (expr) == CALL_EXPR);
tempop = create_value_expr_from (op, block, stmt);
-
+
op = tempop ? tempop : op;
vn_lookup_or_add (op, NULL);
/* Unlike everywhere else, we do *not* want to replace the
functions we call will blow up. */
val = op;
}
- else
+ else
/* Create a value handle for OP and add it to VEXPR. */
val = vn_lookup_or_add (op, NULL);
static void
insert_extra_phis (basic_block block, basic_block dom)
{
-
+
if (!single_pred_p (block))
{
edge e;
get_var_ann (mergephitemp);
}
temp = mergephitemp;
-
+
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Creating phi ");
add_referenced_var (temp);
temp = create_phi_node (temp, block);
- NECESSARY (temp) = 0;
+ NECESSARY (temp) = 0;
VEC_safe_push (tree, heap, inserted_exprs, temp);
FOR_EACH_EDGE (e, ei, block->preds)
{
tree leader = bitmap_find_leader (AVAIL_OUT (e->src), val);
-
+
gcc_assert (leader);
add_phi_arg (temp, leader, e);
}
vn_add (PHI_RESULT (temp), val);
-
+
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\n");
}
|| TREE_CODE (rhs) == ADDR_EXPR
|| TREE_INVARIANT (rhs))
{
-
+
/* Yay! Compute a value number for the RHS of the statement and
add its value to the AVAIL_OUT set for the block. Add the LHS
to TMP_GEN. */
/* Mark the temp variable as referenced */
add_referenced_var (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
- /* Put the new statement in GC memory, fix up the
+ /* Put the new statement in GC memory, fix up the
SSA_NAME_DEF_STMT on it, and then put it in place of
the old statement before the store in the IR stream
as a plain ssa name copy. */
block. The AVAIL sets are built from information we glean while doing
this value numbering, since the AVAIL sets contain only one entry per
value.
-
+
AVAIL_IN[BLOCK] = AVAIL_OUT[dom(BLOCK)].
AVAIL_OUT[BLOCK] = AVAIL_IN[BLOCK] U PHI_GEN[BLOCK] U TMP_GEN[BLOCK]. */
stmt = bsi_stmt (bsi);
ann = stmt_ann (stmt);
-
+
ann->uid = stmt_uid++;
/* For regular value numbering, we are only interested in
/* Compute a value number for the RHS of the statement
and add its value to the AVAIL_OUT set for the block.
Add the LHS to TMP_GEN. */
- add_to_sets (lhs, rhs, stmt, TMP_GEN (block),
+ add_to_sets (lhs, rhs, stmt, TMP_GEN (block),
AVAIL_OUT (block));
-
+
if (TREE_CODE (rhs) == SSA_NAME
&& !is_undefined_value (rhs))
value_insert_into_set (EXP_GEN (block), rhs);
continue;
- }
+ }
}
/* For any other statement that we don't recognize, simply
FOR_EACH_BB (b)
{
block_stmt_iterator i;
-
+
for (i = bsi_start (b); !bsi_end_p (i); bsi_next (&i))
{
tree stmt = bsi_stmt (i);
sprime = bitmap_find_leader (AVAIL_OUT (b),
vn_lookup (lhs, NULL));
- if (sprime
+ if (sprime
&& sprime != lhs
&& (TREE_CODE (*rhs_p) != SSA_NAME
|| may_propagate_copy (*rhs_p, sprime)))
fprintf (dump_file, " in ");
print_generic_stmt (dump_file, stmt, 0);
}
-
- if (TREE_CODE (sprime) == SSA_NAME)
+
+ if (TREE_CODE (sprime) == SSA_NAME)
NECESSARY (SSA_NAME_DEF_STMT (sprime)) = 1;
/* We need to make sure the new and old types actually match,
which may require adding a simple cast, which fold_convert
&& !tree_ssa_useless_type_conversion_1 (TREE_TYPE (*rhs_p),
TREE_TYPE (sprime)))
sprime = fold_convert (TREE_TYPE (*rhs_p), sprime);
-
+
pre_stats.eliminations++;
propagate_tree_value (rhs_p, sprime);
update_stmt (stmt);
/* If OP's defining statement has not already been determined to be necessary,
mark that statement necessary. Return the stmt, if it is newly
- necessary. */
+ necessary. */
static inline tree
mark_operand_necessary (tree op)
else
{
/* Propagate through the operands. Examine all the USE, VUSE and
- V_MAY_DEF operands in this statement. Mark all the statements
+ V_MAY_DEF operands in this statement. Mark all the statements
which feed this statement's uses as necessary. */
ssa_op_iter iter;
tree use;
/* The operands of V_MAY_DEF expressions are also needed as they
represent potential definitions that may reach this
- statement (V_MAY_DEF operands allow us to follow def-def
+ statement (V_MAY_DEF operands allow us to follow def-def
links). */
FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
init_pre (bool do_fre)
{
basic_block bb;
-
+
in_fre = do_fre;
inserted_exprs = NULL;
expression_node_pool = create_alloc_pool ("Expression tree nodes",
tree_code_size (CALL_EXPR), 30);
list_node_pool = create_alloc_pool ("List tree nodes",
- tree_code_size (TREE_LIST), 30);
+ tree_code_size (TREE_LIST), 30);
comparison_node_pool = create_alloc_pool ("Comparison tree nodes",
tree_code_size (EQ_EXPR), 30);
modify_expr_node_pool = create_alloc_pool ("MODIFY_EXPR nodes",
FOR_ALL_BB (bb)
{
print_value_set (dump_file, EXP_GEN (bb), "exp_gen", bb->index);
- bitmap_print_value_set (dump_file, TMP_GEN (bb), "tmp_gen",
+ bitmap_print_value_set (dump_file, TMP_GEN (bb), "tmp_gen",
bb->index);
- bitmap_print_value_set (dump_file, AVAIL_OUT (bb), "avail_out",
+ bitmap_print_value_set (dump_file, AVAIL_OUT (bb), "avail_out",
bb->index);
}
}
fprintf (dump_file, "Eliminated: %d\n", pre_stats.eliminations);
fprintf (dump_file, "Constified: %d\n", pre_stats.constified);
}
-
+
bsi_commit_edge_inserts ();
if (!do_fre)
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_update_ssa_only_virtuals | TODO_dump_func | TODO_ggc_collect
+ TODO_update_ssa_only_virtuals | TODO_dump_func | TODO_ggc_collect
| TODO_verify_ssa, /* todo_flags_finish */
0 /* letter */
};
TODO_dump_func | TODO_ggc_collect | TODO_verify_ssa, /* todo_flags_finish */
0 /* letter */
};
-
OSDN Git Service
