-/* Initialize a tree_partition_associator object using MAP. */
-
-static tpa_p
-tpa_init (var_map map)
-{
- tpa_p tpa;
- int num_partitions = num_var_partitions (map);
- int x;
-
- if (num_partitions == 0)
- return NULL;
-
- tpa = (tpa_p) xmalloc (sizeof (struct tree_partition_associator_d));
- tpa->num_trees = 0;
- tpa->uncompressed_num = -1;
- tpa->map = map;
- tpa->next_partition = (int *)xmalloc (num_partitions * sizeof (int));
- memset (tpa->next_partition, TPA_NONE, num_partitions * sizeof (int));
-
- tpa->partition_to_tree_map = (int *)xmalloc (num_partitions * sizeof (int));
- memset (tpa->partition_to_tree_map, TPA_NONE, num_partitions * sizeof (int));
-
- x = MAX (40, (num_partitions / 20));
- tpa->trees = VEC_alloc (tree, heap, x);
- tpa->first_partition = VEC_alloc (int, heap, x);
-
- return tpa;
-
-}
-
-
-/* Remove PARTITION_INDEX from TREE_INDEX's list in the tpa structure TPA. */
-
-void
-tpa_remove_partition (tpa_p tpa, int tree_index, int partition_index)
-{
- int i;
-
- i = tpa_first_partition (tpa, tree_index);
- if (i == partition_index)
- {
- VEC_replace (int, tpa->first_partition, tree_index,
- tpa->next_partition[i]);
- }
- else
- {
- for ( ; i != TPA_NONE; i = tpa_next_partition (tpa, i))
- {
- if (tpa->next_partition[i] == partition_index)
- {
- tpa->next_partition[i] = tpa->next_partition[partition_index];
- break;
- }
- }
- }
-}
-
-
-/* Free the memory used by tree_partition_associator object TPA. */
-
-void
-tpa_delete (tpa_p tpa)
-{
- if (!tpa)
- 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);
-}
-
-
-/* This function will remove any tree entries from TPA which have only a single
- element. This will help keep the size of the conflict graph down. The
- function returns the number of remaining tree lists. */
-
-int
-tpa_compact (tpa_p tpa)
-{
- int last, x, y, first, swap_i;
- tree swap_t;
-
- /* Find the last list which has more than 1 partition. */
- for (last = tpa->num_trees - 1; last > 0; last--)
- {
- first = tpa_first_partition (tpa, last);
- if (tpa_next_partition (tpa, first) != NO_PARTITION)
- break;
- }
-
- x = 0;
- while (x < last)
- {
- first = tpa_first_partition (tpa, x);
-
- /* If there is not more than one partition, swap with the current end
- of the tree list. */
- if (tpa_next_partition (tpa, first) == NO_PARTITION)
- {
- swap_t = VEC_index (tree, tpa->trees, 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));
- 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);
- 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))
- tpa->partition_to_tree_map[y] = x;
-
- /* Ensure last is a list with more than one partition. */
- last--;
- for (; last > x; last--)
- {
- first = tpa_first_partition (tpa, last);
- if (tpa_next_partition (tpa, first) != NO_PARTITION)
- break;
- }
- }
- x++;
- }
-
- first = tpa_first_partition (tpa, x);
- if (tpa_next_partition (tpa, first) != NO_PARTITION)
- x++;
- tpa->uncompressed_num = tpa->num_trees;
- tpa->num_trees = x;
- return last;
-}
-
-
-/* Initialize a root_var object with SSA partitions from MAP which are based
- on each root variable. */
-
-root_var_p
-root_var_init (var_map map)
-{
- root_var_p rv;
- int num_partitions = num_var_partitions (map);
- int x, p;
- tree t;
- var_ann_t ann;
- sbitmap seen;
-
- rv = tpa_init (map);
- if (!rv)
- return NULL;
-
- seen = sbitmap_alloc (num_partitions);
- sbitmap_zero (seen);
-
- /* Start at the end and work towards the front. This will provide a list
- that is ordered from smallest to largest. */
- for (x = num_partitions - 1; x >= 0; x--)
- {
- t = partition_to_var (map, x);
-
- /* The var map may not be compacted yet, so check for NULL. */
- if (!t)
- continue;
-
- p = var_to_partition (map, t);
-
- gcc_assert (p != NO_PARTITION);
-
- /* Make sure we only put coalesced partitions into the list once. */
- if (TEST_BIT (seen, p))
- continue;
- SET_BIT (seen, p);
- if (TREE_CODE (t) == SSA_NAME)
- t = SSA_NAME_VAR (t);
- ann = var_ann (t);
- if (ann->root_var_processed)
- {
- 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);
- VEC_safe_push (int, heap, rv->first_partition, p);
- }
- rv->partition_to_tree_map[p] = VAR_ANN_ROOT_INDEX (ann);
- }
-
- /* Reset the out_of_ssa_tag flag on each variable for later use. */
- for (x = 0; x < rv->num_trees; x++)
- {
- t = VEC_index (tree, rv->trees, x);
- var_ann (t)->root_var_processed = 0;
- }
-
- sbitmap_free (seen);
- return rv;
-}
-
-
-/* Hash function for 2 integer coalesce pairs. */
-#define COALESCE_HASH_FN(R1, R2) ((R2) * ((R2) - 1) / 2 + (R1))
-
-
-/* Return hash value for partition pair PAIR. */
-
-unsigned int
-partition_pair_map_hash (const void *pair)
-{
- hashval_t a = (hashval_t)(((partition_pair_p)pair)->first_partition);
- hashval_t b = (hashval_t)(((partition_pair_p)pair)->second_partition);
-
- return COALESCE_HASH_FN (a,b);
-}
-
-
-/* Return TRUE if PAIR1 is equivalent to PAIR2. */
-
-int
-partition_pair_map_eq (const void *pair1, const void *pair2)
-{
- partition_pair_p p1 = (partition_pair_p) pair1;
- partition_pair_p p2 = (partition_pair_p) pair2;
-
- return (p1->first_partition == p2->first_partition
- && p1->second_partition == p2->second_partition);
-}
-
-
-/* Create a new coalesce list object from MAP and return it. */
-
-coalesce_list_p
-create_coalesce_list (var_map map)
-{
- coalesce_list_p list;
- unsigned size = num_ssa_names * 3;
-
- if (size < 40)
- size = 40;
-
- list = xmalloc (sizeof (struct coalesce_list_d));
- list->list = htab_create (size, partition_pair_map_hash,
- partition_pair_map_eq, NULL);
-
- list->map = map;
- list->sorted = NULL;
- list->add_mode = true;
- list->num_sorted = 0;
- return list;
-}
-
-
-/* Delete coalesce list CL. */
-
-void
-delete_coalesce_list (coalesce_list_p cl)
-{
- htab_delete (cl->list);
- if (cl->sorted)
- free (cl->sorted);
- gcc_assert (cl->num_sorted == 0);
- free (cl);
-}
-
-
-/* Find a matching coalesce pair object in CL for partitions P1 and P2. If
- one isn't found, return NULL if CREATE is false, otherwise create a new
- coalesce pair object and return it. */
-
-static partition_pair_p
-find_partition_pair (coalesce_list_p cl, int p1, int p2, bool create)
-{
- struct partition_pair p, *pair;
- void **slot;
- unsigned int hash;
-
- /* normalize so that p1 is the smaller value. */
- if (p2 < p1)
- {
- p.first_partition = p2;
- p.second_partition = p1;
- }
- else
- {
- p.first_partition = p1;
- p.second_partition = p2;
- }
-
-
- hash = partition_pair_map_hash (&p);
- pair = (struct partition_pair *) htab_find_with_hash (cl->list, &p, hash);
-
- if (create && !pair)
- {
- gcc_assert (cl->add_mode);
- pair = xmalloc (sizeof (struct partition_pair));
- pair->first_partition = p.first_partition;
- pair->second_partition = p.second_partition;
- pair->cost = 0;
- slot = htab_find_slot_with_hash (cl->list, pair, hash, INSERT);
- *(struct partition_pair **)slot = pair;
- }
-
- return pair;
-}
-
-/* Return cost of execution of copy instruction with FREQUENCY
- possibly on CRITICAL edge and in HOT basic block. */
-int
-coalesce_cost (int frequency, bool hot, bool critical)
-{
- /* Base costs on BB frequencies bounded by 1. */
- int cost = frequency;
-
- if (!cost)
- cost = 1;
- if (optimize_size || hot)
- cost = 1;
- /* Inserting copy on critical edge costs more
- than inserting it elsewhere. */
- if (critical)
- cost *= 2;
- return cost;
-}
-
-/* Add a potential coalesce between P1 and P2 in CL with a cost of VALUE. */
-
-void
-add_coalesce (coalesce_list_p cl, int p1, int p2,
- int value)
-{
- partition_pair_p node;
-
- gcc_assert (cl->add_mode);
-
- if (p1 == p2)
- return;
-
- node = find_partition_pair (cl, p1, p2, true);
-
- node->cost += value;
-}
-
-
-/* Comparison function to allow qsort to sort P1 and P2 in Ascending order. */
-
-static
-int compare_pairs (const void *p1, const void *p2)
-{
- return (*(partition_pair_p *)p1)->cost - (*(partition_pair_p *)p2)->cost;
-}
-
-
-static inline int
-num_coalesce_pairs (coalesce_list_p cl)
-{
- return htab_elements (cl->list);
-}
-
-typedef struct
-{
- htab_iterator hti;
-} partition_pair_iterator;
-
-static inline partition_pair_p
-first_partition_pair (coalesce_list_p cl, partition_pair_iterator *iter)
-{
- partition_pair_p pair;
-
- pair = (partition_pair_p) first_htab_element (&(iter->hti), cl->list);
- return pair;
-}
-
-static inline bool
-end_partition_pair_p (partition_pair_iterator *iter)
-{
- return end_htab_p (&(iter->hti));
-}
-
-static inline partition_pair_p
-next_partition_pair (partition_pair_iterator *iter)
-{
- partition_pair_p pair;
-
- pair = (partition_pair_p) next_htab_element (&(iter->hti));
- return pair;
-}
-
-#define FOR_EACH_PARTITION_PAIR(PAIR, ITER, CL) \
- for ((PAIR) = first_partition_pair ((CL), &(ITER)); \
- !end_partition_pair_p (&(ITER)); \
- (PAIR) = next_partition_pair (&(ITER)))
-
-
-/* Prepare CL for removal of preferred pairs. When finished, list element
- 0 has all the coalesce pairs, sorted in order from most important coalesce
- to least important. */
-
-void
-sort_coalesce_list (coalesce_list_p cl)
-{
- unsigned x, num;
- partition_pair_p p;
- partition_pair_iterator ppi;
-
- gcc_assert (cl->add_mode);
-
- cl->add_mode = false;
-
- /* allocate a vector for the pair pointers. */
- num = num_coalesce_pairs (cl);
- cl->num_sorted = num;
- if (num == 0)
- return;
- cl->sorted = XNEWVEC (partition_pair_p, num);
-
- /* Populate the vector with pointers to the partition pairs. */
-
- x = 0;
- FOR_EACH_PARTITION_PAIR (p, ppi, cl)
- cl->sorted[x++] = p;
- gcc_assert (x == num);
-
- if (num == 1)
- return;
-
- if (num == 2)
- {
- if (cl->sorted[0]->cost > cl->sorted[1]->cost)
- {
- p = cl->sorted[0];
- cl->sorted[0] = cl->sorted[1];
- cl->sorted[1] = p;
- }
- return;
- }
-
- /* Only call qsort if there are more than 2 items. */
- if (num > 2)
- qsort (cl->sorted, num, sizeof (partition_pair_p), compare_pairs);
-}
-
-
-/* Retrieve the best remaining pair to coalesce from CL. Returns the 2
- partitions via P1 and P2. Their calculated cost is returned by the function.
- NO_BEST_COALESCE is returned if the coalesce list is empty. */
-
-static int
-pop_best_coalesce (coalesce_list_p cl, int *p1, int *p2)
-{
- partition_pair_p node;
- int ret;
-
- gcc_assert (!cl->add_mode);
-
- if (cl->num_sorted == 0)
- return NO_BEST_COALESCE;
-
- node = cl->sorted[--(cl->num_sorted)];
-
- *p1 = node->first_partition;
- *p2 = node->second_partition;
- ret = node->cost;
- free (node);
-
- return ret;
-}
-
-
-/* If variable VAR is in a partition in MAP, add a conflict in GRAPH between
- VAR and any other live partitions in VEC which are associated via TPA.
- Reset the live bit in VEC. */
-
-static inline void
-add_conflicts_if_valid (tpa_p tpa, conflict_graph graph,
- var_map map, bitmap vec, tree var)
-{
- int p, y, first;
- p = var_to_partition (map, var);
- if (p != NO_PARTITION)
- {
- bitmap_clear_bit (vec, p);
- first = tpa_find_tree (tpa, p);
- /* If find returns nothing, this object isn't interesting. */
- if (first == TPA_NONE)
- return;
- /* Only add interferences between objects in the same list. */
- for (y = tpa_first_partition (tpa, first);
- y != TPA_NONE;
- y = tpa_next_partition (tpa, y))
- {
- if (bitmap_bit_p (vec, y))
- conflict_graph_add (graph, p, y);
- }
- }
-}
-
-
-/* If VAR is in a partition of MAP, set the bit for that partition in VEC. */
-
-static inline void
-set_if_valid (var_map map, bitmap vec, tree var)
-{
- int p = var_to_partition (map, var);
- if (p != NO_PARTITION)
- bitmap_set_bit (vec, p);
-}
-
-/* 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. */
-
-conflict_graph
-build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa,
- coalesce_list_p cl)
-{
- conflict_graph graph;
- var_map map;
- bitmap live;
- unsigned x, y, i;
- basic_block bb;
- int *partition_link, *tpa_nodes;
- VEC(int,heap) *tpa_to_clear;
- unsigned l;
- ssa_op_iter iter;
- bitmap_iterator bi;
-
- map = live_var_map (liveinfo);
- graph = conflict_graph_new (num_var_partitions (map));
-
- if (tpa_num_trees (tpa) == 0)
- return graph;
-
- live = BITMAP_ALLOC (NULL);
-
- 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)
- {
- block_stmt_iterator bsi;
- tree phi;
- int idx;
-
- /* Start with live on exit temporaries. */
- bitmap_copy (live, live_on_exit (liveinfo, bb));
-
- for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
- {
- bool is_a_copy = false;
- tree stmt = bsi_stmt (bsi);
-
- /* A copy between 2 partitions does not introduce an interference
- by itself. If they did, you would never be able to coalesce
- two things which are copied. If the two variables really do
- conflict, they will conflict elsewhere in the program.
-
- This is handled specially here since we may also be interested
- in copies between real variables and SSA_NAME variables. We may
- be interested in trying to coalesce SSA_NAME variables with
- root variables in some cases. */
-
- if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
- {
- tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
- tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
- int p1, p2;
- int bit;
-
- if (DECL_P (lhs) || TREE_CODE (lhs) == SSA_NAME)
- p1 = var_to_partition (map, lhs);
- else
- p1 = NO_PARTITION;
-
- if (DECL_P (rhs) || TREE_CODE (rhs) == SSA_NAME)
- p2 = var_to_partition (map, rhs);
- else
- p2 = NO_PARTITION;
-
- if (p1 != NO_PARTITION && p2 != NO_PARTITION)
- {
- is_a_copy = true;
- bit = bitmap_bit_p (live, p2);
- /* If the RHS is live, make it not live while we add
- the conflicts, then make it live again. */
- if (bit)
- bitmap_clear_bit (live, p2);
- add_conflicts_if_valid (tpa, graph, map, live, lhs);
- if (bit)
- bitmap_set_bit (live, p2);
- if (cl)
- add_coalesce (cl, p1, p2,
- coalesce_cost (bb->frequency,
- maybe_hot_bb_p (bb), false));
- set_if_valid (map, live, rhs);
- }
- }
-
- if (!is_a_copy)
- {
- tree var;
- FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_DEF)
- {
- add_conflicts_if_valid (tpa, graph, map, live, var);
- }
-
- FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
- {
- set_if_valid (map, live, var);
- }
- }
- }
-
- /* If result of a PHI is unused, then the loops over the statements
- will not record any conflicts. However, since the PHI node is
- going to be translated out of SSA form we must record a conflict
- between the result of the PHI and any variables with are live.
- Otherwise the out-of-ssa translation may create incorrect code. */
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- tree result = PHI_RESULT (phi);
- int p = var_to_partition (map, result);
-
- if (p != NO_PARTITION && ! bitmap_bit_p (live, p))
- add_conflicts_if_valid (tpa, graph, map, live, result);
- }
-
- /* Anything which is still live at this point interferes.
- In order to implement this efficiently, only conflicts between
- partitions which have the same TPA root need be added.
- TPA roots which have been seen are tracked in 'tpa_nodes'. A nonzero
- entry points to an index into 'partition_link', which then indexes
- into itself forming a linked list of partitions sharing a tpa root
- which have been seen as live up to this point. Since partitions start
- at index zero, all entries in partition_link are (partition + 1).
-
- Conflicts are added between the current partition and any already seen.
- tpa_clear contains all the tpa_roots processed, and these are the only
- entries which need to be zero'd out for a clean restart. */
-
- EXECUTE_IF_SET_IN_BITMAP (live, 0, x, bi)
- {
- i = tpa_find_tree (tpa, x);
- if (i != (unsigned)TPA_NONE)
- {
- int start = tpa_nodes[i];
- /* If start is 0, a new root reference list is being started.
- Register it to be cleared. */
- if (!start)
- VEC_safe_push (int, heap, tpa_to_clear, i);
-
- /* Add interferences to other tpa members seen. */
- for (y = start; y != 0; y = partition_link[y])
- conflict_graph_add (graph, x, y - 1);
- tpa_nodes[i] = x + 1;
- partition_link[x + 1] = start;
- }
- }
-
- /* Now clear the used tpa root references. */
- for (l = 0; VEC_iterate (int, tpa_to_clear, l, idx); l++)
- tpa_nodes[idx] = 0;
- VEC_truncate (int, tpa_to_clear, 0);
- }
-
- free (tpa_nodes);
- free (partition_link);
- VEC_free (int, heap, tpa_to_clear);
- BITMAP_FREE (live);
- return graph;
-}
-
-
-/* This routine will attempt to coalesce the elements in TPA subject to the
- conflicts found in GRAPH. If optional coalesce_list CL is provided,
- only coalesces specified within the coalesce list are attempted. Otherwise
- an attempt is made to coalesce as many partitions within each TPA grouping
- as possible. If DEBUG is provided, debug output will be sent there. */
-
-void
-coalesce_tpa_members (tpa_p tpa, conflict_graph graph, var_map map,
- coalesce_list_p cl, FILE *debug)
-{
- int x, y, z, w;
- tree var, tmp;
-
- /* Attempt to coalesce any items in a coalesce list. */
- if (cl)
- {
- while (pop_best_coalesce (cl, &x, &y) != NO_BEST_COALESCE)
- {
- if (debug)
- {
- fprintf (debug, "Coalesce list: (%d)", x);
- print_generic_expr (debug, partition_to_var (map, x), TDF_SLIM);
- fprintf (debug, " & (%d)", y);
- print_generic_expr (debug, partition_to_var (map, y), TDF_SLIM);
- }
-
- w = tpa_find_tree (tpa, x);
- z = tpa_find_tree (tpa, y);
- if (w != z || w == TPA_NONE || z == TPA_NONE)
- {
- if (debug)
- {
- if (w != z)
- fprintf (debug, ": Fail, Non-matching TPA's\n");
- if (w == TPA_NONE)
- fprintf (debug, ": Fail %d non TPA.\n", x);
- else
- fprintf (debug, ": Fail %d non TPA.\n", y);
- }
- continue;
- }
- var = partition_to_var (map, x);
- tmp = partition_to_var (map, y);
- x = var_to_partition (map, var);
- y = var_to_partition (map, tmp);
- if (debug)
- fprintf (debug, " [map: %d, %d] ", x, y);
- if (x == y)
- {
- if (debug)
- fprintf (debug, ": Already Coalesced.\n");
- continue;
- }
- if (!conflict_graph_conflict_p (graph, x, y))
- {
- z = var_union (map, var, tmp);
- if (z == NO_PARTITION)
- {
- if (debug)
- fprintf (debug, ": Unable to perform partition union.\n");
- continue;
- }
-
- /* z is the new combined partition. We need to remove the other
- partition from the list. Set x to be that other partition. */
- if (z == x)
- {
- conflict_graph_merge_regs (graph, x, y);
- w = tpa_find_tree (tpa, y);
- tpa_remove_partition (tpa, w, y);
- }
- else
- {
- conflict_graph_merge_regs (graph, y, x);
- w = tpa_find_tree (tpa, x);
- tpa_remove_partition (tpa, w, x);
- }
-
- if (debug)
- fprintf (debug, ": Success -> %d\n", z);
- }
- else
- if (debug)
- fprintf (debug, ": Fail due to conflict\n");
- }
- /* If using a coalesce list, don't try to coalesce anything else. */
- return;
- }
-
- for (x = 0; x < tpa_num_trees (tpa); x++)
- {
- while (tpa_first_partition (tpa, x) != TPA_NONE)
- {
- int p1, p2;
- /* Coalesce first partition with anything that doesn't conflict. */
- y = tpa_first_partition (tpa, x);
- tpa_remove_partition (tpa, x, y);
-
- var = partition_to_var (map, y);
- /* p1 is the partition representative to which y belongs. */
- p1 = var_to_partition (map, var);
-
- for (z = tpa_next_partition (tpa, y);
- z != TPA_NONE;
- z = tpa_next_partition (tpa, z))
- {
- tmp = partition_to_var (map, z);
- /* p2 is the partition representative to which z belongs. */
- p2 = var_to_partition (map, tmp);
- if (debug)
- {
- fprintf (debug, "Coalesce : ");
- print_generic_expr (debug, var, TDF_SLIM);
- fprintf (debug, " &");
- print_generic_expr (debug, tmp, TDF_SLIM);
- fprintf (debug, " (%d ,%d)", p1, p2);
- }
-
- /* If partitions are already merged, don't check for conflict. */
- if (tmp == var)
- {
- tpa_remove_partition (tpa, x, z);
- if (debug)
- fprintf (debug, ": Already coalesced\n");
- }
- else
- if (!conflict_graph_conflict_p (graph, p1, p2))
- {
- int v;
- if (tpa_find_tree (tpa, y) == TPA_NONE
- || tpa_find_tree (tpa, z) == TPA_NONE)
- {
- if (debug)
- fprintf (debug, ": Fail non-TPA member\n");
- continue;
- }
- if ((v = var_union (map, var, tmp)) == NO_PARTITION)
- {
- if (debug)
- fprintf (debug, ": Fail cannot combine partitions\n");
- continue;
- }
-
- tpa_remove_partition (tpa, x, z);
- if (v == p1)
- conflict_graph_merge_regs (graph, v, z);
- else
- {
- /* Update the first partition's representative. */
- conflict_graph_merge_regs (graph, v, y);
- p1 = v;
- }
-
- /* The root variable of the partition may be changed
- now. */
- var = partition_to_var (map, p1);
-
- if (debug)
- fprintf (debug, ": Success -> %d\n", v);
- }
- else
- if (debug)
- fprintf (debug, ": Fail, Conflict\n");
- }
- }
- }
-}
-
-
-/* Send debug info for coalesce list CL to file F. */
-
-void
-dump_coalesce_list (FILE *f, coalesce_list_p cl)
-{
- partition_pair_p node;
- partition_pair_iterator ppi;
- int x;
- tree var;
-
- if (cl->add_mode)
- {
- fprintf (f, "Coalesce List:\n");
- FOR_EACH_PARTITION_PAIR (node, ppi, cl)
- {
- tree var1 = partition_to_var (cl->map, node->first_partition);
- tree var2 = partition_to_var (cl->map, node->second_partition);
- print_generic_expr (f, var1, TDF_SLIM);
- fprintf (f, " <-> ");
- print_generic_expr (f, var2, TDF_SLIM);
- fprintf (f, " (%1d), ", node->cost);
- fprintf (f, "\n");
- }
- }
- else
- {
- fprintf (f, "Sorted Coalesce list:\n");
- for (x = cl->num_sorted - 1 ; x >=0; x--)
- {
- node = cl->sorted[x];
- fprintf (f, "(%d) ", node->cost);
- var = partition_to_var (cl->map, node->first_partition);
- print_generic_expr (f, var, TDF_SLIM);
- fprintf (f, " <-> ");
- var = partition_to_var (cl->map, node->second_partition);
- print_generic_expr (f, var, TDF_SLIM);
- fprintf (f, "\n");
- }
- }
-}
-
-
-/* Output tree_partition_associator object TPA to file F.. */
-
-void
-tpa_dump (FILE *f, tpa_p tpa)
-{
- int x, i;
-
- if (!tpa)
- return;
-
- for (x = 0; x < tpa_num_trees (tpa); x++)
- {
- print_generic_expr (f, tpa_tree (tpa, x), TDF_SLIM);
- fprintf (f, " : (");
- for (i = tpa_first_partition (tpa, x);
- i != TPA_NONE;
- i = tpa_next_partition (tpa, i))
- {
- fprintf (f, "(%d)",i);
- print_generic_expr (f, partition_to_var (tpa->map, i), TDF_SLIM);
- fprintf (f, " ");
-
-#ifdef ENABLE_CHECKING
- if (tpa_find_tree (tpa, i) != x)
- fprintf (f, "**find tree incorrectly set** ");
-#endif
-
- }
- fprintf (f, ")\n");
- }
- fflush (f);
-}
-
-
OSDN Git Service
