#include "tree-dump.h"
#include "tree-ssa-live.h"
#include "toplev.h"
+#include "vecprim.h"
static void live_worklist (tree_live_info_p, int *, int);
static tree_live_info_p new_tree_live_info (var_map);
{
tree t = *tp;
+ if (TREE_CODE (t) == SSA_NAME)
+ t = SSA_NAME_VAR (t);
+
/* Ignore TREE_ORIGINAL for TARGET_MEM_REFS, as well as other
fields that do not contain vars. */
if (TREE_CODE (t) == TARGET_MEM_REF)
walk_tree (expr_p, mark_all_vars_used_1, NULL, NULL);
}
+
+/* Remove local variables that are not referenced in the IL. */
+
+void
+remove_unused_locals (void)
+{
+ basic_block bb;
+ tree t, *cell;
+
+ /* Assume all locals are unused. */
+ for (t = cfun->unexpanded_var_list; t; t = TREE_CHAIN (t))
+ {
+ tree var = TREE_VALUE (t);
+ if (TREE_CODE (var) != FUNCTION_DECL
+ && var_ann (var))
+ var_ann (var)->used = false;
+ }
+
+ /* Walk the CFG marking all referenced symbols. */
+ FOR_EACH_BB (bb)
+ {
+ block_stmt_iterator bsi;
+ tree phi, def;
+
+ /* Walk the statements. */
+ for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+ mark_all_vars_used (bsi_stmt_ptr (bsi));
+
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ {
+ use_operand_p arg_p;
+ ssa_op_iter i;
+
+ /* No point processing globals. */
+ if (is_global_var (SSA_NAME_VAR (PHI_RESULT (phi))))
+ continue;
+
+ def = PHI_RESULT (phi);
+ mark_all_vars_used (&def);
+
+ FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES)
+ {
+ tree arg = USE_FROM_PTR (arg_p);
+ mark_all_vars_used (&arg);
+ }
+ }
+ }
+
+ /* Remove unmarked vars and clear used flag. */
+ for (cell = &cfun->unexpanded_var_list; *cell; )
+ {
+ tree var = TREE_VALUE (*cell);
+ var_ann_t ann;
+
+ if (TREE_CODE (var) != FUNCTION_DECL
+ && (!(ann = var_ann (var))
+ || !ann->used))
+ {
+ *cell = TREE_CHAIN (*cell);
+ continue;
+ }
+
+ cell = &TREE_CHAIN (*cell);
+ }
+}
+
/* This function looks through the program and uses FLAGS to determine what
SSA versioned variables are given entries in a new partition table. This
new partition map is returned. */
FOR_EACH_BB (bb)
{
tree phi, arg;
+
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
int i;
}
}
- stack = xmalloc (sizeof (int) * last_basic_block);
+ stack = XNEWVEC (int, last_basic_block);
EXECUTE_IF_SET_IN_BITMAP (live->global, 0, i, bi)
{
live_worklist (live, stack, i);
x = MAX (40, (num_partitions / 20));
tpa->trees = VEC_alloc (tree, heap, x);
- VARRAY_INT_INIT (tpa->first_partition, x, "first_partition");
+ tpa->first_partition = VEC_alloc (int, heap, x);
return tpa;
i = tpa_first_partition (tpa, tree_index);
if (i == partition_index)
{
- VARRAY_INT (tpa->first_partition, tree_index) = tpa->next_partition[i];
+ VEC_replace (int, tpa->first_partition, tree_index,
+ tpa->next_partition[i]);
}
else
{
return;
VEC_free (tree, heap, tpa->trees);
+ VEC_free (int, heap, tpa->first_partition);
free (tpa->partition_to_tree_map);
free (tpa->next_partition);
free (tpa);
if (tpa_next_partition (tpa, first) == NO_PARTITION)
{
swap_t = VEC_index (tree, tpa->trees, last);
- swap_i = VARRAY_INT (tpa->first_partition, last);
+ swap_i = VEC_index (int, tpa->first_partition, last);
/* Update the last entry. Since it is known to only have one
partition, there is nothing else to update. */
VEC_replace (tree, tpa->trees, last,
VEC_index (tree, tpa->trees, x));
- VARRAY_INT (tpa->first_partition, last)
- = VARRAY_INT (tpa->first_partition, x);
+ VEC_replace (int, tpa->first_partition, last,
+ VEC_index (int, tpa->first_partition, x));
tpa->partition_to_tree_map[tpa_first_partition (tpa, last)] = last;
/* Since this list is known to have more than one partition, update
the list owner entries. */
VEC_replace (tree, tpa->trees, x, swap_t);
- VARRAY_INT (tpa->first_partition, x) = swap_i;
+ VEC_replace (int, tpa->first_partition, x, swap_i);
for (y = tpa_first_partition (tpa, x);
y != NO_PARTITION;
y = tpa_next_partition (tpa, y))
ann = var_ann (t);
if (ann->root_var_processed)
{
- rv->next_partition[p] = VARRAY_INT (rv->first_partition,
- VAR_ANN_ROOT_INDEX (ann));
- VARRAY_INT (rv->first_partition, VAR_ANN_ROOT_INDEX (ann)) = p;
+ rv->next_partition[p] = VEC_index (int, rv->first_partition,
+ VAR_ANN_ROOT_INDEX (ann));
+ VEC_replace (int, rv->first_partition, VAR_ANN_ROOT_INDEX (ann), p);
}
else
{
ann->root_var_processed = 1;
VAR_ANN_ROOT_INDEX (ann) = rv->num_trees++;
VEC_safe_push (tree, heap, rv->trees, t);
- VARRAY_PUSH_INT (rv->first_partition, p);
+ VEC_safe_push (int, heap, rv->first_partition, p);
}
rv->partition_to_tree_map[p] = VAR_ANN_ROOT_INDEX (ann);
}
tree t;
sbitmap seen;
- seen = sbitmap_alloc (num_partitions);
- sbitmap_zero (seen);
-
tv = tpa_init (map);
if (!tv)
return NULL;
+ seen = sbitmap_alloc (num_partitions);
+ sbitmap_zero (seen);
+
for (x = num_partitions - 1; x >= 0; x--)
{
t = partition_to_var (map, x);
{
tv->num_trees++;
VEC_safe_push (tree, heap, tv->trees, t);
- VARRAY_PUSH_INT (tv->first_partition, p);
+ VEC_safe_push (int, heap, tv->first_partition, p);
}
else
{
- tv->next_partition[p] = VARRAY_INT (tv->first_partition, y);
- VARRAY_INT (tv->first_partition, y) = p;
+ tv->next_partition[p] = VEC_index (int, tv->first_partition, y);
+ VEC_replace (int, tv->first_partition, y, p);
}
tv->partition_to_tree_map[p] = y;
}
/* Only call qsort if there are more than 2 items. */
if (num > 2)
{
- list = xmalloc (sizeof (partition_pair_p) * num);
+ list = XNEWVEC (partition_pair_p, num);
count = 0;
for (p = chain; p != NULL; p = p->next)
list[count++] = p;
}
}
-DEF_VEC_I(int);
-DEF_VEC_ALLOC_I(int,heap);
-
/* Return a conflict graph for the information contained in LIVE_INFO. Only
conflicts between items in the same TPA list are added. If optional
coalesce list CL is passed in, any copies encountered are added. */
live = BITMAP_ALLOC (NULL);
- partition_link = xcalloc (num_var_partitions (map) + 1, sizeof (int));
- tpa_nodes = xcalloc (tpa_num_trees (tpa), sizeof (int));
+ partition_link = XCNEWVEC (int, num_var_partitions (map) + 1);
+ tpa_nodes = XCNEWVEC (int, tpa_num_trees (tpa));
tpa_to_clear = VEC_alloc (int, heap, 50);
FOR_EACH_BB (bb)
OSDN Git Service
