Skip to content

R
riscv-gcc-1
Commit b9c5e484 by Eric Christopher
Options

Fix whitespace. 

From-SVN: r115190
parent a25bf5b3
Showing with 171 additions and 172 deletions
gcc/tree-ssa-pre.c
/* 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.
......@@ -45,7 +45,7 @@ Boston, MA 02110-1301, USA. */
#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.
......@@ -58,7 +58,7 @@ Boston, MA 02110-1301, USA. */
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
......@@ -66,7 +66,7 @@ Boston, MA 02110-1301, USA. */
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
......@@ -77,7 +77,7 @@ Boston, MA 02110-1301, USA. */
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
......@@ -124,7 +124,7 @@ Boston, MA 02110-1301, USA. */
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
......@@ -132,20 +132,20 @@ Boston, MA 02110-1301, USA. */
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 +
......@@ -163,7 +163,7 @@ Boston, MA 02110-1301, USA. */
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
......@@ -205,19 +205,19 @@ typedef struct value_set
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;
......@@ -294,10 +294,10 @@ static struct
/* The number of new PHI nodes added by PRE. */
int phis;
/* The number of values found constant. */
int constified;
} pre_stats;
......@@ -393,7 +393,7 @@ expr_pred_trans_eq (const void *p1, const void *p2)
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)
......@@ -401,14 +401,14 @@ expr_pred_trans_eq (const void *p1, const void *p2)
/* 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;
......@@ -524,7 +524,7 @@ value_insert_into_set_bitmap (value_set_t set, tree v)
/* 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);
......@@ -556,7 +556,7 @@ bitmap_insert_into_set (bitmap_set_t set, tree expr)
/* 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))
{
......@@ -573,7 +573,7 @@ insert_into_set (value_set_t set, tree expr)
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;
......@@ -661,7 +661,7 @@ static void
set_copy (value_set_t dest, value_set_t orig)
{
value_set_node_t node;
if (!orig || !orig->head)
return;
......@@ -681,12 +681,12 @@ set_remove (value_set_t set, tree expr)
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)
......@@ -695,7 +695,7 @@ set_remove (value_set_t set, tree expr)
set->head = node->next;
else
prev->next= node->next;
if (node == set->tail)
set->tail = prev;
pool_free (value_set_node_pool, node);
......@@ -712,10 +712,10 @@ set_contains_value (value_set_t set, tree val)
/* 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);
}
......@@ -733,7 +733,7 @@ bitmap_set_contains (bitmap_set_t set, tree expr)
return bitmap_bit_p (set->expressions, SSA_NAME_VERSION (expr));
}
/* Return true if bitmapped set SET contains the value VAL. */
static bool
......@@ -840,7 +840,7 @@ bitmap_value_insert_into_set (bitmap_set_t set, tree expr)
if (is_gimple_min_invariant (val))
return;
if (!bitmap_set_contains_value (set, val))
bitmap_insert_into_set (set, expr);
}
......@@ -881,7 +881,7 @@ bitmap_print_value_set (FILE *outfile, bitmap_set_t set,
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, ") ");
......@@ -904,11 +904,11 @@ print_value_set (FILE *outfile, value_set_t set,
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, ", ");
}
......@@ -937,7 +937,7 @@ debug_value_expressions (tree val)
print_value_expressions (stderr, val);
}
void debug_value_set (value_set_t, const char *, int);
void
......@@ -947,11 +947,11 @@ debug_value_set (value_set_t set, const char *setname, int blockindex)
}
/* 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))
......@@ -960,7 +960,7 @@ fully_constant_expression (tree t)
}
/* 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
......@@ -972,10 +972,10 @@ pool_copy_list (tree list)
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)
{
......@@ -1055,7 +1055,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
if (phitrans)
return phitrans;
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case tcc_expression:
......@@ -1083,8 +1083,8 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
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)
......@@ -1098,7 +1098,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
}
/* 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. */
......@@ -1106,10 +1106,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
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)
......@@ -1139,7 +1139,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
}
if (listchanged)
vn_lookup_or_add (newarglist, NULL);
tvuses = translate_vuses_through_block (vuses, pred);
if (listchanged || (newop0 != oldop0) || (oldop2 != newop2)
......@@ -1150,7 +1150,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
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);
......@@ -1198,13 +1198,13 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
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);
......@@ -1212,7 +1212,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
{
newop2 = phi_translate (find_leader (set, oldop2),
set, pred, phiblock);
if (newop2 == NULL)
return NULL;
}
......@@ -1221,7 +1221,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
{
newop3 = phi_translate (find_leader (set, oldop3),
set, pred, phiblock);
if (newop3 == NULL)
return NULL;
}
......@@ -1230,10 +1230,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
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;
......@@ -1277,7 +1277,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
tree newop1;
tree newop2;
tree newexpr;
newop1 = phi_translate (find_leader (set, oldop1),
set, pred, phiblock);
if (newop1 == NULL)
......@@ -1301,7 +1301,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
}
else
{
create_tree_ann (newexpr);
create_tree_ann (newexpr);
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
......@@ -1334,7 +1334,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
}
else
{
create_tree_ann (newexpr);
create_tree_ann (newexpr);
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
......@@ -1352,7 +1352,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
phi = SSA_NAME_DEF_STMT (expr);
else
return expr;
e = find_edge (pred, bb_for_stmt (phi));
if (e)
{
......@@ -1383,7 +1383,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
node = node->next)
{
tree translated;
translated = phi_translate (node->expr, set, pred, phiblock);
/* Don't add constants or empty translations to the cache, since
......@@ -1392,7 +1392,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
{
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)
......@@ -1402,7 +1402,7 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
if (translated != NULL)
value_insert_into_set (dest, translated);
}
}
}
/* Find the leader for a value (i.e., the name representing that
......@@ -1414,7 +1414,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
{
if (val == NULL)
return NULL;
if (is_gimple_min_invariant (val))
return val;
if (bitmap_set_contains_value (set, val))
......@@ -1429,7 +1429,7 @@ bitmap_find_leader (bitmap_set_t set, tree 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);
......@@ -1437,7 +1437,7 @@ bitmap_find_leader (bitmap_set_t set, tree 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;
}
......@@ -1446,7 +1446,7 @@ bitmap_find_leader (bitmap_set_t set, tree val)
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. */
......@@ -1465,7 +1465,7 @@ find_leader (value_set_t set, tree val)
if (set->length == 0)
return NULL;
if (value_exists_in_set_bitmap (set, val))
{
for (node = set->head;
......@@ -1517,7 +1517,7 @@ vuses_dies_in_block_x (VEC (tree, gc) *vuses, basic_block block)
/* 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,
......@@ -1543,7 +1543,7 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
tree op1 = TREE_OPERAND (expr, 0);
return set_contains_value (set, op1);
}
case tcc_expression:
{
if (TREE_CODE (expr) == CALL_EXPR)
......@@ -1567,10 +1567,10 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
}
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)
{
......@@ -1616,7 +1616,7 @@ valid_in_set (value_set_t set, tree expr, basic_block block)
default:
/* No other cases should be encountered. */
gcc_unreachable ();
gcc_unreachable ();
}
}
......@@ -1633,7 +1633,7 @@ clean (value_set_t set, basic_block block)
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;
}
......@@ -1721,7 +1721,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
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);
......@@ -1741,7 +1741,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
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);
......@@ -1904,11 +1904,11 @@ compute_vuse_representatives (void)
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:
......@@ -1916,7 +1916,7 @@ compute_vuse_representatives (void)
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.
......@@ -1939,7 +1939,7 @@ compute_rvuse_and_antic_safe (void)
unsigned int *first_store_uid;
first_store_uid = xcalloc (n_basic_blocks, sizeof (unsigned int));
compute_vuse_representatives ();
FOR_ALL_BB (bb)
......@@ -1976,14 +1976,14 @@ compute_rvuse_and_antic_safe (void)
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)
......@@ -2079,31 +2079,31 @@ compute_rvuse_and_antic_safe (void)
}
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);
}
}
......@@ -2176,7 +2176,7 @@ static VEC(tree, heap) *need_creation;
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.
......@@ -2193,7 +2193,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
if (found)
return found;
}
if (TREE_CODE (genop) == VALUE_HANDLE)
genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
......@@ -2203,7 +2203,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
{
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);
......@@ -2215,7 +2215,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
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;
}
......@@ -2223,11 +2223,11 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
{
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;
}
......@@ -2236,7 +2236,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
{
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;
......@@ -2249,7 +2249,7 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
case STRING_CST:
return genop;
default:
gcc_unreachable ();
gcc_unreachable ();
}
return NULL_TREE;
......@@ -2257,9 +2257,9 @@ create_component_ref_by_pieces (basic_block block, tree expr, tree stmts)
/* 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. */
......@@ -2281,9 +2281,9 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
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.
......@@ -2313,14 +2313,14 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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;
......@@ -2332,13 +2332,13 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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:
......@@ -2352,13 +2352,13 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
{
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:
{
......@@ -2366,7 +2366,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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;
}
......@@ -2375,7 +2375,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
{
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;
}
......@@ -2388,7 +2388,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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
......@@ -2402,7 +2402,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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);
......@@ -2444,12 +2444,12 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
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);
......@@ -2476,7 +2476,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
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 ");
......@@ -2493,7 +2493,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
{
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);
......@@ -2505,7 +2505,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
nophi = true;
}
}
/* Make the necessary insertions. */
FOR_EACH_EDGE (pred, ei, block->preds)
......@@ -2521,7 +2521,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
tree vh;
/* eprime may be an invariant. */
vh = TREE_CODE (eprime) == VALUE_HANDLE
vh = TREE_CODE (eprime) == VALUE_HANDLE
? eprime
: get_value_handle (eprime);
......@@ -2546,7 +2546,7 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
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,
......@@ -2571,22 +2571,22 @@ insert_into_preds_of_block (basic_block block, value_set_node_t 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.
......@@ -2594,11 +2594,11 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
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 ");
......@@ -2610,18 +2610,18 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
}
/* 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.
*/
......@@ -2676,14 +2676,14 @@ insert_aux (basic_block 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)
{
......@@ -2731,7 +2731,7 @@ insert_aux (basic_block block)
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,
......@@ -2751,7 +2751,7 @@ insert_aux (basic_block block)
/* 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))
{
......@@ -2761,7 +2761,7 @@ insert_aux (basic_block block)
for (node = exprset->head; node; node = node->next)
{
if (TREE_CODE (node->expr) == SSA_NAME)
{
{
vn_add (node->expr, eprime);
pre_stats.constified++;
}
......@@ -2791,10 +2791,10 @@ insert (void)
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++;
......@@ -2882,7 +2882,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
gcc_assert (code == TREE_LIST);
pool = list_node_pool;
}
else
else
{
gcc_assert (code == CALL_EXPR);
pool = expression_node_pool;
......@@ -2890,7 +2890,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
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
......@@ -2903,9 +2903,9 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
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)))
......@@ -2914,7 +2914,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
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
......@@ -2933,7 +2933,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
for (i = 0; i < TREE_CODE_LENGTH (code); i++)
{
tree val, op;
op = TREE_OPERAND (expr, i);
if (op == NULL_TREE)
continue;
......@@ -2948,10 +2948,10 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
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
......@@ -2959,7 +2959,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
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);
......@@ -2984,7 +2984,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
static void
insert_extra_phis (basic_block block, basic_block dom)
{
if (!single_pred_p (block))
{
edge e;
......@@ -3032,7 +3032,7 @@ insert_extra_phis (basic_block block, basic_block dom)
get_var_ann (mergephitemp);
}
temp = mergephitemp;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Creating phi ");
......@@ -3042,13 +3042,13 @@ insert_extra_phis (basic_block block, basic_block dom)
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);
......@@ -3060,7 +3060,7 @@ insert_extra_phis (basic_block block, basic_block dom)
}
vn_add (PHI_RESULT (temp), val);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\n");
}
......@@ -3125,7 +3125,7 @@ try_look_through_load (tree lhs, tree mem_ref, tree stmt, basic_block block)
|| 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. */
......@@ -3290,7 +3290,7 @@ realify_fake_stores (void)
/* 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. */
......@@ -3357,7 +3357,7 @@ try_combine_conversion (tree *expr_p)
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]. */
......@@ -3444,7 +3444,7 @@ compute_avail (void)
stmt = bsi_stmt (bsi);
ann = stmt_ann (stmt);
ann->uid = stmt_uid++;
/* For regular value numbering, we are only interested in
......@@ -3500,14 +3500,14 @@ compute_avail (void)
/* 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
......@@ -3542,7 +3542,7 @@ eliminate (void)
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);
......@@ -3562,7 +3562,7 @@ eliminate (void)
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)))
......@@ -3578,8 +3578,8 @@ eliminate (void)
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
......@@ -3588,7 +3588,7 @@ eliminate (void)
&& !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);
......@@ -3614,7 +3614,7 @@ eliminate (void)
/* 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)
......@@ -3681,14 +3681,14 @@ remove_dead_inserted_code (void)
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)
......@@ -3733,7 +3733,7 @@ static void
init_pre (bool do_fre)
{
basic_block bb;
in_fre = do_fre;
inserted_exprs = NULL;
......@@ -3784,7 +3784,7 @@ init_pre (bool do_fre)
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",
......@@ -3886,9 +3886,9 @@ execute_pre (bool do_fre)
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);
}
}
......@@ -3918,7 +3918,7 @@ execute_pre (bool do_fre)
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)
......@@ -3960,7 +3960,7 @@ struct tree_opt_pass pass_pre =
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 */
};
......@@ -3997,4 +3997,3 @@ struct tree_opt_pass pass_fre =
TODO_dump_func | TODO_ggc_collect | TODO_verify_ssa, /* todo_flags_finish */
0 /* letter */
};
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment