}
+/* 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 equivilent 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;
- list = (coalesce_list_p) xmalloc (sizeof (struct coalesce_list_d));
+ 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->list = (partition_pair_p *) xcalloc (num_var_partitions (map),
- sizeof (struct partition_pair_d));
+ list->num_sorted = 0;
return list;
}
void
delete_coalesce_list (coalesce_list_p cl)
{
- free (cl->list);
+ htab_delete (cl->list);
+ if (cl->sorted)
+ free (cl->sorted);
+ gcc_assert (cl->num_sorted == 0);
free (cl);
}
static partition_pair_p
find_partition_pair (coalesce_list_p cl, int p1, int p2, bool create)
{
- partition_pair_p node, tmp;
- int s;
+ struct partition_pair p, *pair;
+ void **slot;
+ unsigned int hash;
- /* Normalize so that p1 is the smaller value. */
+ /* normalize so that p1 is the smaller value. */
if (p2 < p1)
{
- s = p1;
- p1 = p2;
- p2 = s;
+ p.first_partition = p2;
+ p.second_partition = p1;
}
-
- tmp = NULL;
-
- /* The list is sorted such that if we find a value greater than p2,
- p2 is not in the list. */
- for (node = cl->list[p1]; node; node = node->next)
+ else
{
- if (node->second_partition == p2)
- return node;
- else
- if (node->second_partition > p2)
- break;
- tmp = node;
+ 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)
- return NULL;
-
- node = (partition_pair_p) xmalloc (sizeof (struct partition_pair_d));
- node->first_partition = p1;
- node->second_partition = p2;
- node->cost = 0;
-
- if (tmp != NULL)
- {
- node->next = tmp->next;
- tmp->next = node;
- }
- else
+ if (create && !pair)
{
- /* This is now the first node in the list. */
- node->next = cl->list[p1];
- cl->list[p1] = node;
+ 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 node;
+ return pair;
}
/* Return cost of execution of copy instruction with FREQUENCY
}
-/* Comparison function to allow qsort to sort P1 and P2 in descending order. */
+/* Comparison function to allow qsort to sort P1 and P2 in Ascendiong order. */
static
int compare_pairs (const void *p1, const void *p2)
{
- return (*(partition_pair_p *)p2)->cost - (*(partition_pair_p *)p1)->cost;
+ 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
void
sort_coalesce_list (coalesce_list_p cl)
{
- unsigned x, num, count;
- partition_pair_p chain, p;
- partition_pair_p *list;
+ unsigned x, num;
+ partition_pair_p p;
+ partition_pair_iterator ppi;
gcc_assert (cl->add_mode);
cl->add_mode = false;
- /* Compact the array of lists to a single list, and count the elements. */
- num = 0;
- chain = NULL;
- for (x = 0; x < num_var_partitions (cl->map); x++)
- if (cl->list[x] != NULL)
- {
- for (p = cl->list[x]; p->next != NULL; p = p->next)
- num++;
- num++;
- p->next = chain;
- chain = cl->list[x];
- cl->list[x] = NULL;
- }
+ /* 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);
- /* Only call qsort if there are more than 2 items. */
- if (num > 2)
- {
- list = XNEWVEC (partition_pair_p, num);
- count = 0;
- for (p = chain; p != NULL; p = p->next)
- list[count++] = p;
+ /* 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);
- gcc_assert (count == num);
-
- qsort (list, count, sizeof (partition_pair_p), compare_pairs);
+ if (num == 1)
+ return;
- p = list[0];
- for (x = 1; x < num; x++)
- {
- p->next = list[x];
- p = list[x];
- }
- p->next = NULL;
- cl->list[0] = list[0];
- free (list);
- }
- else
+ if (num == 2)
{
- cl->list[0] = chain;
- if (num == 2)
- {
- /* Simply swap the two elements if they are in the wrong order. */
- if (chain->cost < chain->next->cost)
- {
- cl->list[0] = chain->next;
- cl->list[0]->next = chain;
- chain->next = NULL;
- }
+ 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);
}
gcc_assert (!cl->add_mode);
- node = cl->list[0];
- if (!node)
+ if (cl->num_sorted == 0)
return NO_BEST_COALESCE;
- cl->list[0] = node->next;
+ node = cl->sorted[--(cl->num_sorted)];
*p1 = node->first_partition;
*p2 = node->second_partition;
dump_coalesce_list (FILE *f, coalesce_list_p cl)
{
partition_pair_p node;
- int x, num;
+ partition_pair_iterator ppi;
+ int x;
tree var;
if (cl->add_mode)
{
fprintf (f, "Coalesce List:\n");
- num = num_var_partitions (cl->map);
- for (x = 0; x < num; x++)
+ FOR_EACH_PARTITION_PAIR (node, ppi, cl)
{
- node = cl->list[x];
- if (node)
- {
- fprintf (f, "[");
- print_generic_expr (f, partition_to_var (cl->map, x), TDF_SLIM);
- fprintf (f, "] - ");
- for ( ; node; node = node->next)
- {
- var = partition_to_var (cl->map, node->second_partition);
- print_generic_expr (f, var, TDF_SLIM);
- fprintf (f, "(%1d), ", node->cost);
- }
- fprintf (f, "\n");
- }
+ 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 (node = cl->list[0]; node; node = node->next)
+ 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, " : ");
+ fprintf (f, " <-> ");
var = partition_to_var (cl->map, node->second_partition);
print_generic_expr (f, var, TDF_SLIM);
fprintf (f, "\n");
projects / thirdparty / gcc.git / commitdiff
