1 /* Coalesce SSA_NAMES together for the out-of-ssa pass.
2 Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
27 #include "diagnostic.h"
29 #include "tree-flow.h"
31 #include "tree-dump.h"
32 #include "tree-ssa-live.h"
36 /* This set of routines implements a coalesce_list. This is an object which
37 is used to track pairs of ssa_names which are desirable to coalesce
38 together to avoid copies. Costs are associated with each pair, and when
39 all desired information has been collected, the object can be used to
40 order the pairs for processing. */
42 /* This structure defines a pair entry. */
44 typedef struct coalesce_pair
50 typedef const struct coalesce_pair *const_coalesce_pair_p;
52 typedef struct cost_one_pair_d
56 struct cost_one_pair_d *next;
59 /* This structure maintains the list of coalesce pairs. */
61 typedef struct coalesce_list_d
63 htab_t list; /* Hash table. */
64 coalesce_pair_p *sorted; /* List when sorted. */
65 int num_sorted; /* Number in the sorted list. */
66 cost_one_pair_p cost_one_list;/* Single use coalesces with cost 1. */
69 #define NO_BEST_COALESCE -1
70 #define MUST_COALESCE_COST INT_MAX
73 /* Return cost of execution of copy instruction with FREQUENCY
74 possibly on CRITICAL edge and in HOT basic block. */
77 coalesce_cost (int frequency, bool hot, bool critical)
79 /* Base costs on BB frequencies bounded by 1. */
88 /* It is more important to coalesce in HOT blocks. */
92 /* Inserting copy on critical edge costs more than inserting it elsewhere. */
99 /* Return the cost of executing a copy instruction in basic block BB. */
102 coalesce_cost_bb (basic_block bb)
104 return coalesce_cost (bb->frequency, maybe_hot_bb_p (bb), false);
108 /* Return the cost of executing a copy instruction on edge E. */
111 coalesce_cost_edge (edge e)
113 if (e->flags & EDGE_ABNORMAL)
114 return MUST_COALESCE_COST;
116 return coalesce_cost (EDGE_FREQUENCY (e),
117 maybe_hot_bb_p (e->src),
118 EDGE_CRITICAL_P (e));
122 /* Retrieve a pair to coalesce from the cost_one_list in CL. Returns the
123 2 elements via P1 and P2. 1 is returned by the function if there is a pair,
124 NO_BEST_COALESCE is returned if there aren't any. */
127 pop_cost_one_pair (coalesce_list_p cl, int *p1, int *p2)
131 ptr = cl->cost_one_list;
133 return NO_BEST_COALESCE;
135 *p1 = ptr->first_element;
136 *p2 = ptr->second_element;
137 cl->cost_one_list = ptr->next;
144 /* Retrieve the most expensive remaining pair to coalesce from CL. Returns the
145 2 elements via P1 and P2. Their calculated cost is returned by the function.
146 NO_BEST_COALESCE is returned if the coalesce list is empty. */
149 pop_best_coalesce (coalesce_list_p cl, int *p1, int *p2)
151 coalesce_pair_p node;
154 if (cl->sorted == NULL)
155 return pop_cost_one_pair (cl, p1, p2);
157 if (cl->num_sorted == 0)
158 return pop_cost_one_pair (cl, p1, p2);
160 node = cl->sorted[--(cl->num_sorted)];
161 *p1 = node->first_element;
162 *p2 = node->second_element;
170 #define COALESCE_HASH_FN(R1, R2) ((R2) * ((R2) - 1) / 2 + (R1))
172 /* Hash function for coalesce list. Calculate hash for PAIR. */
175 coalesce_pair_map_hash (const void *pair)
177 hashval_t a = (hashval_t)(((const_coalesce_pair_p)pair)->first_element);
178 hashval_t b = (hashval_t)(((const_coalesce_pair_p)pair)->second_element);
180 return COALESCE_HASH_FN (a,b);
184 /* Equality function for coalesce list hash table. Compare PAIR1 and PAIR2,
185 returning TRUE if the two pairs are equivalent. */
188 coalesce_pair_map_eq (const void *pair1, const void *pair2)
190 const_coalesce_pair_p const p1 = (const_coalesce_pair_p) pair1;
191 const_coalesce_pair_p const p2 = (const_coalesce_pair_p) pair2;
193 return (p1->first_element == p2->first_element
194 && p1->second_element == p2->second_element);
198 /* Create a new empty coalesce list object and return it. */
200 static inline coalesce_list_p
201 create_coalesce_list (void)
203 coalesce_list_p list;
204 unsigned size = num_ssa_names * 3;
209 list = (coalesce_list_p) xmalloc (sizeof (struct coalesce_list_d));
210 list->list = htab_create (size, coalesce_pair_map_hash,
211 coalesce_pair_map_eq, NULL);
213 list->num_sorted = 0;
214 list->cost_one_list = NULL;
219 /* Delete coalesce list CL. */
222 delete_coalesce_list (coalesce_list_p cl)
224 gcc_assert (cl->cost_one_list == NULL);
225 htab_delete (cl->list);
228 gcc_assert (cl->num_sorted == 0);
233 /* Find a matching coalesce pair object in CL for the pair P1 and P2. If
234 one isn't found, return NULL if CREATE is false, otherwise create a new
235 coalesce pair object and return it. */
237 static coalesce_pair_p
238 find_coalesce_pair (coalesce_list_p cl, int p1, int p2, bool create)
240 struct coalesce_pair p, *pair;
244 /* Normalize so that p1 is the smaller value. */
247 p.first_element = p2;
248 p.second_element = p1;
252 p.first_element = p1;
253 p.second_element = p2;
257 hash = coalesce_pair_map_hash (&p);
258 pair = (struct coalesce_pair *) htab_find_with_hash (cl->list, &p, hash);
262 gcc_assert (cl->sorted == NULL);
263 pair = XNEW (struct coalesce_pair);
264 pair->first_element = p.first_element;
265 pair->second_element = p.second_element;
267 slot = htab_find_slot_with_hash (cl->list, pair, hash, INSERT);
268 *(struct coalesce_pair **)slot = pair;
275 add_cost_one_coalesce (coalesce_list_p cl, int p1, int p2)
277 cost_one_pair_p pair;
279 pair = XNEW (struct cost_one_pair_d);
280 pair->first_element = p1;
281 pair->second_element = p2;
282 pair->next = cl->cost_one_list;
283 cl->cost_one_list = pair;
287 /* Add a coalesce between P1 and P2 in list CL with a cost of VALUE. */
290 add_coalesce (coalesce_list_p cl, int p1, int p2,
293 coalesce_pair_p node;
295 gcc_assert (cl->sorted == NULL);
299 node = find_coalesce_pair (cl, p1, p2, true);
301 /* Once the value is MUST_COALESCE_COST, leave it that way. */
302 if (node->cost != MUST_COALESCE_COST)
304 if (value == MUST_COALESCE_COST)
312 /* Comparison function to allow qsort to sort P1 and P2 in Ascending order. */
315 compare_pairs (const void *p1, const void *p2)
317 return (*(const_coalesce_pair_p const*)p1)->cost
318 - (*(const_coalesce_pair_p const*)p2)->cost;
322 /* Return the number of unique coalesce pairs in CL. */
325 num_coalesce_pairs (coalesce_list_p cl)
327 return htab_elements (cl->list);
331 /* Iterator over hash table pairs. */
335 } coalesce_pair_iterator;
338 /* Return first partition pair from list CL, initializing iterator ITER. */
340 static inline coalesce_pair_p
341 first_coalesce_pair (coalesce_list_p cl, coalesce_pair_iterator *iter)
343 coalesce_pair_p pair;
345 pair = (coalesce_pair_p) first_htab_element (&(iter->hti), cl->list);
350 /* Return TRUE if there are no more partitions in for ITER to process. */
353 end_coalesce_pair_p (coalesce_pair_iterator *iter)
355 return end_htab_p (&(iter->hti));
359 /* Return the next partition pair to be visited by ITER. */
361 static inline coalesce_pair_p
362 next_coalesce_pair (coalesce_pair_iterator *iter)
364 coalesce_pair_p pair;
366 pair = (coalesce_pair_p) next_htab_element (&(iter->hti));
371 /* Iterate over CL using ITER, returning values in PAIR. */
373 #define FOR_EACH_PARTITION_PAIR(PAIR, ITER, CL) \
374 for ((PAIR) = first_coalesce_pair ((CL), &(ITER)); \
375 !end_coalesce_pair_p (&(ITER)); \
376 (PAIR) = next_coalesce_pair (&(ITER)))
379 /* Prepare CL for removal of preferred pairs. When finished they are sorted
380 in order from most important coalesce to least important. */
383 sort_coalesce_list (coalesce_list_p cl)
387 coalesce_pair_iterator ppi;
389 gcc_assert (cl->sorted == NULL);
391 num = num_coalesce_pairs (cl);
392 cl->num_sorted = num;
396 /* Allocate a vector for the pair pointers. */
397 cl->sorted = XNEWVEC (coalesce_pair_p, num);
399 /* Populate the vector with pointers to the pairs. */
401 FOR_EACH_PARTITION_PAIR (p, ppi, cl)
403 gcc_assert (x == num);
405 /* Already sorted. */
409 /* If there are only 2, just pick swap them if the order isn't correct. */
412 if (cl->sorted[0]->cost > cl->sorted[1]->cost)
415 cl->sorted[0] = cl->sorted[1];
421 /* Only call qsort if there are more than 2 items. */
423 qsort (cl->sorted, num, sizeof (coalesce_pair_p), compare_pairs);
427 /* Send debug info for coalesce list CL to file F. */
430 dump_coalesce_list (FILE *f, coalesce_list_p cl)
432 coalesce_pair_p node;
433 coalesce_pair_iterator ppi;
437 if (cl->sorted == NULL)
439 fprintf (f, "Coalesce List:\n");
440 FOR_EACH_PARTITION_PAIR (node, ppi, cl)
442 tree var1 = ssa_name (node->first_element);
443 tree var2 = ssa_name (node->second_element);
444 print_generic_expr (f, var1, TDF_SLIM);
445 fprintf (f, " <-> ");
446 print_generic_expr (f, var2, TDF_SLIM);
447 fprintf (f, " (%1d), ", node->cost);
453 fprintf (f, "Sorted Coalesce list:\n");
454 for (x = cl->num_sorted - 1 ; x >=0; x--)
456 node = cl->sorted[x];
457 fprintf (f, "(%d) ", node->cost);
458 var = ssa_name (node->first_element);
459 print_generic_expr (f, var, TDF_SLIM);
460 fprintf (f, " <-> ");
461 var = ssa_name (node->second_element);
462 print_generic_expr (f, var, TDF_SLIM);
469 /* This represents a conflict graph. Implemented as an array of bitmaps.
470 A full matrix is used for conflicts rather than just upper triangular form.
471 this make sit much simpler and faster to perform conflict merges. */
473 typedef struct ssa_conflicts_d
480 /* Return an empty new conflict graph for SIZE elements. */
482 static inline ssa_conflicts_p
483 ssa_conflicts_new (unsigned size)
487 ptr = XNEW (struct ssa_conflicts_d);
488 ptr->conflicts = XCNEWVEC (bitmap, size);
494 /* Free storage for conflict graph PTR. */
497 ssa_conflicts_delete (ssa_conflicts_p ptr)
500 for (x = 0; x < ptr->size; x++)
501 if (ptr->conflicts[x])
502 BITMAP_FREE (ptr->conflicts[x]);
504 free (ptr->conflicts);
509 /* Test if elements X and Y conflict in graph PTR. */
512 ssa_conflicts_test_p (ssa_conflicts_p ptr, unsigned x, unsigned y)
516 #ifdef ENABLE_CHECKING
517 gcc_assert (x < ptr->size);
518 gcc_assert (y < ptr->size);
522 b = ptr->conflicts[x];
524 /* Avoid the lookup if Y has no conflicts. */
525 return ptr->conflicts[y] ? bitmap_bit_p (b, y) : false;
531 /* Add a conflict with Y to the bitmap for X in graph PTR. */
534 ssa_conflicts_add_one (ssa_conflicts_p ptr, unsigned x, unsigned y)
536 /* If there are no conflicts yet, allocate the bitmap and set bit. */
537 if (!ptr->conflicts[x])
538 ptr->conflicts[x] = BITMAP_ALLOC (NULL);
539 bitmap_set_bit (ptr->conflicts[x], y);
543 /* Add conflicts between X and Y in graph PTR. */
546 ssa_conflicts_add (ssa_conflicts_p ptr, unsigned x, unsigned y)
548 #ifdef ENABLE_CHECKING
549 gcc_assert (x < ptr->size);
550 gcc_assert (y < ptr->size);
553 ssa_conflicts_add_one (ptr, x, y);
554 ssa_conflicts_add_one (ptr, y, x);
558 /* Merge all Y's conflict into X in graph PTR. */
561 ssa_conflicts_merge (ssa_conflicts_p ptr, unsigned x, unsigned y)
567 if (!(ptr->conflicts[y]))
570 /* Add a conflict between X and every one Y has. If the bitmap doesn't
571 exist, then it has already been coalesced, and we dont need to add a
573 EXECUTE_IF_SET_IN_BITMAP (ptr->conflicts[y], 0, z, bi)
574 if (ptr->conflicts[z])
575 bitmap_set_bit (ptr->conflicts[z], x);
577 if (ptr->conflicts[x])
579 /* If X has conflicts, add Y's to X. */
580 bitmap_ior_into (ptr->conflicts[x], ptr->conflicts[y]);
581 BITMAP_FREE (ptr->conflicts[y]);
585 /* If X has no conflicts, simply use Y's. */
586 ptr->conflicts[x] = ptr->conflicts[y];
587 ptr->conflicts[y] = NULL;
592 /* This structure is used to efficiently record the current status of live
593 SSA_NAMES when building a conflict graph.
594 LIVE_BASE_VAR has a bit set for each base variable which has at least one
596 LIVE_BASE_PARTITIONS is an array of bitmaps using the basevar table as an
597 index, and is used to track what partitions of each base variable are
598 live. This makes it easy to add conflicts between just live partitions
599 with the same base variable.
600 The values in LIVE_BASE_PARTITIONS are only valid if the base variable is
601 marked as being live. This delays clearing of these bitmaps until
602 they are actually needed again. */
604 typedef struct live_track_d
606 bitmap live_base_var; /* Indicates if a basevar is live. */
607 bitmap *live_base_partitions; /* Live partitions for each basevar. */
608 var_map map; /* Var_map being used for partition mapping. */
612 /* This routine will create a new live track structure based on the partitions
616 new_live_track (var_map map)
621 /* Make sure there is a partition view in place. */
622 gcc_assert (map->partition_to_base_index != NULL);
624 ptr = (live_track_p) xmalloc (sizeof (struct live_track_d));
626 lim = num_basevars (map);
627 ptr->live_base_partitions = (bitmap *) xmalloc(sizeof (bitmap *) * lim);
628 ptr->live_base_var = BITMAP_ALLOC (NULL);
629 for (x = 0; x < lim; x++)
630 ptr->live_base_partitions[x] = BITMAP_ALLOC (NULL);
635 /* This routine will free the memory associated with PTR. */
638 delete_live_track (live_track_p ptr)
642 lim = num_basevars (ptr->map);
643 for (x = 0; x < lim; x++)
644 BITMAP_FREE (ptr->live_base_partitions[x]);
645 BITMAP_FREE (ptr->live_base_var);
646 free (ptr->live_base_partitions);
651 /* This function will remove PARTITION from the live list in PTR. */
654 live_track_remove_partition (live_track_p ptr, int partition)
658 root = basevar_index (ptr->map, partition);
659 bitmap_clear_bit (ptr->live_base_partitions[root], partition);
660 /* If the element list is empty, make the base variable not live either. */
661 if (bitmap_empty_p (ptr->live_base_partitions[root]))
662 bitmap_clear_bit (ptr->live_base_var, root);
666 /* This function will adds PARTITION to the live list in PTR. */
669 live_track_add_partition (live_track_p ptr, int partition)
673 root = basevar_index (ptr->map, partition);
674 /* If this base var wasn't live before, it is now. Clear the element list
675 since it was delayed until needed. */
676 if (!bitmap_bit_p (ptr->live_base_var, root))
678 bitmap_set_bit (ptr->live_base_var, root);
679 bitmap_clear (ptr->live_base_partitions[root]);
681 bitmap_set_bit (ptr->live_base_partitions[root], partition);
686 /* Clear the live bit for VAR in PTR. */
689 live_track_clear_var (live_track_p ptr, tree var)
693 p = var_to_partition (ptr->map, var);
694 if (p != NO_PARTITION)
695 live_track_remove_partition (ptr, p);
699 /* Return TRUE if VAR is live in PTR. */
702 live_track_live_p (live_track_p ptr, tree var)
706 p = var_to_partition (ptr->map, var);
707 if (p != NO_PARTITION)
709 root = basevar_index (ptr->map, p);
710 if (bitmap_bit_p (ptr->live_base_var, root))
711 return bitmap_bit_p (ptr->live_base_partitions[root], p);
717 /* This routine will add USE to PTR. USE will be marked as live in both the
718 ssa live map and the live bitmap for the root of USE. */
721 live_track_process_use (live_track_p ptr, tree use)
725 p = var_to_partition (ptr->map, use);
726 if (p == NO_PARTITION)
729 /* Mark as live in the appropriate live list. */
730 live_track_add_partition (ptr, p);
734 /* This routine will process a DEF in PTR. DEF will be removed from the live
735 lists, and if there are any other live partitions with the same base
736 variable, conflicts will be added to GRAPH. */
739 live_track_process_def (live_track_p ptr, tree def, ssa_conflicts_p graph)
746 p = var_to_partition (ptr->map, def);
747 if (p == NO_PARTITION)
750 /* Clear the liveness bit. */
751 live_track_remove_partition (ptr, p);
753 /* If the bitmap isn't empty now, conflicts need to be added. */
754 root = basevar_index (ptr->map, p);
755 if (bitmap_bit_p (ptr->live_base_var, root))
757 b = ptr->live_base_partitions[root];
758 EXECUTE_IF_SET_IN_BITMAP (b, 0, x, bi)
759 ssa_conflicts_add (graph, p, x);
764 /* Initialize PTR with the partitions set in INIT. */
767 live_track_init (live_track_p ptr, bitmap init)
772 /* Mark all live on exit partitions. */
773 EXECUTE_IF_SET_IN_BITMAP (init, 0, p, bi)
774 live_track_add_partition (ptr, p);
778 /* This routine will clear all live partitions in PTR. */
781 live_track_clear_base_vars (live_track_p ptr)
783 /* Simply clear the live base list. Anything marked as live in the element
784 lists will be cleared later if/when the base variable ever comes alive
786 bitmap_clear (ptr->live_base_var);
790 /* Build a conflict graph based on LIVEINFO. Any partitions which are in the
791 partition view of the var_map liveinfo is based on get entries in the
792 conflict graph. Only conflicts between ssa_name partitions with the same
793 base variable are added. */
795 static ssa_conflicts_p
796 build_ssa_conflict_graph (tree_live_info_p liveinfo)
798 ssa_conflicts_p graph;
804 map = live_var_map (liveinfo);
805 graph = ssa_conflicts_new (num_var_partitions (map));
807 live = new_live_track (map);
811 block_stmt_iterator bsi;
814 /* Start with live on exit temporaries. */
815 live_track_init (live, live_on_exit (liveinfo, bb));
817 for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
820 tree stmt = bsi_stmt (bsi);
822 /* A copy between 2 partitions does not introduce an interference
823 by itself. If they did, you would never be able to coalesce
824 two things which are copied. If the two variables really do
825 conflict, they will conflict elsewhere in the program.
827 This is handled by simply removing the SRC of the copy from the
828 live list, and processing the stmt normally. */
829 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
831 tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
832 tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
833 if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME)
834 live_track_clear_var (live, rhs);
837 FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_DEF)
838 live_track_process_def (live, var, graph);
840 FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
841 live_track_process_use (live, var);
844 /* If result of a PHI is unused, looping over the statements will not
845 record any conflicts since the def was never live. Since the PHI node
846 is going to be translated out of SSA form, it will insert a copy.
847 There must be a conflict recorded between the result of the PHI and
848 any variables that are live. Otherwise the out-of-ssa translation
849 may create incorrect code. */
850 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
852 tree result = PHI_RESULT (phi);
853 if (live_track_live_p (live, result))
854 live_track_process_def (live, result, graph);
857 live_track_clear_base_vars (live);
860 delete_live_track (live);
865 /* Shortcut routine to print messages to file F of the form:
866 "STR1 EXPR1 STR2 EXPR2 STR3." */
869 print_exprs (FILE *f, const char *str1, tree expr1, const char *str2,
870 tree expr2, const char *str3)
872 fprintf (f, "%s", str1);
873 print_generic_expr (f, expr1, TDF_SLIM);
874 fprintf (f, "%s", str2);
875 print_generic_expr (f, expr2, TDF_SLIM);
876 fprintf (f, "%s", str3);
880 /* Called if a coalesce across and abnormal edge cannot be performed. PHI is
881 the phi node at fault, I is the argument index at fault. A message is
882 printed and compilation is then terminated. */
885 abnormal_corrupt (tree phi, int i)
887 edge e = PHI_ARG_EDGE (phi, i);
888 tree res = PHI_RESULT (phi);
889 tree arg = PHI_ARG_DEF (phi, i);
891 fprintf (stderr, " Corrupt SSA across abnormal edge BB%d->BB%d\n",
892 e->src->index, e->dest->index);
893 fprintf (stderr, "Argument %d (", i);
894 print_generic_expr (stderr, arg, TDF_SLIM);
895 if (TREE_CODE (arg) != SSA_NAME)
896 fprintf (stderr, ") is not an SSA_NAME.\n");
899 gcc_assert (SSA_NAME_VAR (res) != SSA_NAME_VAR (arg));
900 fprintf (stderr, ") does not have the same base variable as the result ");
901 print_generic_stmt (stderr, res, TDF_SLIM);
904 internal_error ("SSA corruption");
908 /* Print a failure to coalesce a MUST_COALESCE pair X and Y. */
911 fail_abnormal_edge_coalesce (int x, int y)
913 fprintf (stderr, "\nUnable to coalesce ssa_names %d and %d",x, y);
914 fprintf (stderr, " which are marked as MUST COALESCE.\n");
915 print_generic_expr (stderr, ssa_name (x), TDF_SLIM);
916 fprintf (stderr, " and ");
917 print_generic_stmt (stderr, ssa_name (y), TDF_SLIM);
919 internal_error ("SSA corruption");
923 /* This function creates a var_map for the current function as well as creating
924 a coalesce list for use later in the out of ssa process. */
927 create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy)
929 block_stmt_iterator bsi;
939 #ifdef ENABLE_CHECKING
940 bitmap used_in_real_ops;
941 bitmap used_in_virtual_ops;
943 used_in_real_ops = BITMAP_ALLOC (NULL);
944 used_in_virtual_ops = BITMAP_ALLOC (NULL);
947 map = init_var_map (num_ssa_names + 1);
953 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
958 bool saw_copy = false;
960 res = PHI_RESULT (phi);
961 ver = SSA_NAME_VERSION (res);
962 register_ssa_partition (map, res);
964 /* Register ssa_names and coalesces between the args and the result
966 for (i = 0; i < PHI_NUM_ARGS (phi); i++)
968 edge e = PHI_ARG_EDGE (phi, i);
969 arg = PHI_ARG_DEF (phi, i);
970 if (TREE_CODE (arg) == SSA_NAME)
971 register_ssa_partition (map, arg);
972 if (TREE_CODE (arg) == SSA_NAME
973 && SSA_NAME_VAR (arg) == SSA_NAME_VAR (res))
976 bitmap_set_bit (used_in_copy, SSA_NAME_VERSION (arg));
977 if ((e->flags & EDGE_ABNORMAL) == 0)
979 int cost = coalesce_cost_edge (e);
980 if (cost == 1 && has_single_use (arg))
981 add_cost_one_coalesce (cl, ver, SSA_NAME_VERSION (arg));
983 add_coalesce (cl, ver, SSA_NAME_VERSION (arg), cost);
987 if (e->flags & EDGE_ABNORMAL)
988 abnormal_corrupt (phi, i);
991 bitmap_set_bit (used_in_copy, ver);
994 for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
996 stmt = bsi_stmt (bsi);
998 /* Register USE and DEF operands in each statement. */
999 FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, (SSA_OP_DEF|SSA_OP_USE))
1000 register_ssa_partition (map, var);
1002 /* Check for copy coalesces. */
1003 switch (TREE_CODE (stmt))
1005 case GIMPLE_MODIFY_STMT:
1007 tree op1 = GIMPLE_STMT_OPERAND (stmt, 0);
1008 tree op2 = GIMPLE_STMT_OPERAND (stmt, 1);
1009 if (TREE_CODE (op1) == SSA_NAME
1010 && TREE_CODE (op2) == SSA_NAME
1011 && SSA_NAME_VAR (op1) == SSA_NAME_VAR (op2))
1013 v1 = SSA_NAME_VERSION (op1);
1014 v2 = SSA_NAME_VERSION (op2);
1015 cost = coalesce_cost_bb (bb);
1016 add_coalesce (cl, v1, v2, cost);
1017 bitmap_set_bit (used_in_copy, v1);
1018 bitmap_set_bit (used_in_copy, v2);
1025 unsigned long noutputs, i;
1026 tree *outputs, link;
1027 noutputs = list_length (ASM_OUTPUTS (stmt));
1028 outputs = (tree *) alloca (noutputs * sizeof (tree));
1029 for (i = 0, link = ASM_OUTPUTS (stmt); link;
1030 ++i, link = TREE_CHAIN (link))
1031 outputs[i] = TREE_VALUE (link);
1033 for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
1035 const char *constraint
1036 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1037 tree input = TREE_VALUE (link);
1039 unsigned long match;
1041 if (TREE_CODE (input) != SSA_NAME)
1044 match = strtoul (constraint, &end, 10);
1045 if (match >= noutputs || end == constraint)
1048 if (TREE_CODE (outputs[match]) != SSA_NAME)
1051 v1 = SSA_NAME_VERSION (outputs[match]);
1052 v2 = SSA_NAME_VERSION (input);
1054 if (SSA_NAME_VAR (outputs[match]) == SSA_NAME_VAR (input))
1056 cost = coalesce_cost (REG_BR_PROB_BASE,
1057 maybe_hot_bb_p (bb),
1059 add_coalesce (cl, v1, v2, cost);
1060 bitmap_set_bit (used_in_copy, v1);
1061 bitmap_set_bit (used_in_copy, v2);
1071 #ifdef ENABLE_CHECKING
1072 /* Mark real uses and defs. */
1073 FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, (SSA_OP_DEF|SSA_OP_USE))
1074 bitmap_set_bit (used_in_real_ops, DECL_UID (SSA_NAME_VAR (var)));
1076 /* Validate that virtual ops don't get used in funny ways. */
1077 FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_VIRTUALS)
1079 bitmap_set_bit (used_in_virtual_ops,
1080 DECL_UID (SSA_NAME_VAR (var)));
1083 #endif /* ENABLE_CHECKING */
1087 /* Now process result decls and live on entry variables for entry into
1088 the coalesce list. */
1090 for (i = 1; i < num_ssa_names; i++)
1092 var = map->partition_to_var[i];
1093 if (var != NULL_TREE)
1095 /* Add coalesces between all the result decls. */
1096 if (TREE_CODE (SSA_NAME_VAR (var)) == RESULT_DECL)
1098 if (first == NULL_TREE)
1102 gcc_assert (SSA_NAME_VAR (var) == SSA_NAME_VAR (first));
1103 v1 = SSA_NAME_VERSION (first);
1104 v2 = SSA_NAME_VERSION (var);
1105 bitmap_set_bit (used_in_copy, v1);
1106 bitmap_set_bit (used_in_copy, v2);
1107 cost = coalesce_cost_bb (EXIT_BLOCK_PTR);
1108 add_coalesce (cl, v1, v2, cost);
1111 /* Mark any default_def variables as being in the coalesce list
1112 since they will have to be coalesced with the base variable. If
1113 not marked as present, they won't be in the coalesce view. */
1114 if (gimple_default_def (cfun, SSA_NAME_VAR (var)) == var)
1115 bitmap_set_bit (used_in_copy, SSA_NAME_VERSION (var));
1119 #if defined ENABLE_CHECKING
1122 bitmap both = BITMAP_ALLOC (NULL);
1123 bitmap_and (both, used_in_real_ops, used_in_virtual_ops);
1124 if (!bitmap_empty_p (both))
1128 EXECUTE_IF_SET_IN_BITMAP (both, 0, i, bi)
1129 fprintf (stderr, "Variable %s used in real and virtual operands\n",
1130 get_name (referenced_var (i)));
1131 internal_error ("SSA corruption");
1134 BITMAP_FREE (used_in_real_ops);
1135 BITMAP_FREE (used_in_virtual_ops);
1144 /* Attempt to coalesce ssa versions X and Y together using the partition
1145 mapping in MAP and checking conflicts in GRAPH. Output any debug info to
1146 DEBUG, if it is nun-NULL. */
1149 attempt_coalesce (var_map map, ssa_conflicts_p graph, int x, int y,
1156 p1 = var_to_partition (map, ssa_name (x));
1157 p2 = var_to_partition (map, ssa_name (y));
1161 fprintf (debug, "(%d)", x);
1162 print_generic_expr (debug, partition_to_var (map, p1), TDF_SLIM);
1163 fprintf (debug, " & (%d)", y);
1164 print_generic_expr (debug, partition_to_var (map, p2), TDF_SLIM);
1170 fprintf (debug, ": Already Coalesced.\n");
1175 fprintf (debug, " [map: %d, %d] ", p1, p2);
1178 if (!ssa_conflicts_test_p (graph, p1, p2))
1180 var1 = partition_to_var (map, p1);
1181 var2 = partition_to_var (map, p2);
1182 z = var_union (map, var1, var2);
1183 if (z == NO_PARTITION)
1186 fprintf (debug, ": Unable to perform partition union.\n");
1190 /* z is the new combined partition. Remove the other partition from
1191 the list, and merge the conflicts. */
1193 ssa_conflicts_merge (graph, p1, p2);
1195 ssa_conflicts_merge (graph, p2, p1);
1198 fprintf (debug, ": Success -> %d\n", z);
1203 fprintf (debug, ": Fail due to conflict\n");
1209 /* Attempt to Coalesce partitions in MAP which occur in the list CL using
1210 GRAPH. Debug output is sent to DEBUG if it is non-NULL. */
1213 coalesce_partitions (var_map map, ssa_conflicts_p graph, coalesce_list_p cl,
1217 tree var1, var2, phi;
1223 /* First, coalesce all the copies across abnormal edges. These are not placed
1224 in the coalesce list because they do not need to be sorted, and simply
1225 consume extra memory/compilation time in large programs. */
1229 FOR_EACH_EDGE (e, ei, bb->preds)
1230 if (e->flags & EDGE_ABNORMAL)
1232 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
1234 tree res = PHI_RESULT (phi);
1235 tree arg = PHI_ARG_DEF (phi, e->dest_idx);
1236 int v1 = SSA_NAME_VERSION (res);
1237 int v2 = SSA_NAME_VERSION (arg);
1239 if (SSA_NAME_VAR (arg) != SSA_NAME_VAR (res))
1240 abnormal_corrupt (phi, e->dest_idx);
1243 fprintf (debug, "Abnormal coalesce: ");
1245 if (!attempt_coalesce (map, graph, v1, v2, debug))
1246 fail_abnormal_edge_coalesce (v1, v2);
1251 /* Now process the items in the coalesce list. */
1253 while ((cost = pop_best_coalesce (cl, &x, &y)) != NO_BEST_COALESCE)
1255 var1 = ssa_name (x);
1256 var2 = ssa_name (y);
1258 /* Assert the coalesces have the same base variable. */
1259 gcc_assert (SSA_NAME_VAR (var1) == SSA_NAME_VAR (var2));
1262 fprintf (debug, "Coalesce list: ");
1263 attempt_coalesce (map, graph, x, y, debug);
1268 /* Reduce the number of copies by coalescing variables in the function. Return
1269 a partition map with the resulting coalesces. */
1272 coalesce_ssa_name (void)
1275 tree_live_info_p liveinfo;
1276 ssa_conflicts_p graph;
1278 bitmap used_in_copies = BITMAP_ALLOC (NULL);
1281 cl = create_coalesce_list ();
1282 map = create_outofssa_var_map (cl, used_in_copies);
1284 /* Don't calculate live ranges for variables not in the coalesce list. */
1285 partition_view_bitmap (map, used_in_copies, true);
1286 BITMAP_FREE (used_in_copies);
1288 if (num_var_partitions (map) < 1)
1290 delete_coalesce_list (cl);
1294 if (dump_file && (dump_flags & TDF_DETAILS))
1295 dump_var_map (dump_file, map);
1297 liveinfo = calculate_live_ranges (map);
1299 if (dump_file && (dump_flags & TDF_DETAILS))
1300 dump_live_info (dump_file, liveinfo, LIVEDUMP_ENTRY);
1302 /* Build a conflict graph. */
1303 graph = build_ssa_conflict_graph (liveinfo);
1304 delete_tree_live_info (liveinfo);
1306 sort_coalesce_list (cl);
1308 if (dump_file && (dump_flags & TDF_DETAILS))
1310 fprintf (dump_file, "\nAfter sorting:\n");
1311 dump_coalesce_list (dump_file, cl);
1314 /* First, coalesce all live on entry variables to their base variable.
1315 This will ensure the first use is coming from the correct location. */
1317 num = num_var_partitions (map);
1318 for (x = 0 ; x < num; x++)
1320 tree var = partition_to_var (map, x);
1323 if (TREE_CODE (var) != SSA_NAME)
1326 root = SSA_NAME_VAR (var);
1327 if (gimple_default_def (cfun, root) == var)
1329 /* This root variable should have not already been assigned
1330 to another partition which is not coalesced with this one. */
1331 gcc_assert (!var_ann (root)->out_of_ssa_tag);
1333 if (dump_file && (dump_flags & TDF_DETAILS))
1335 print_exprs (dump_file, "Must coalesce ", var,
1336 " with the root variable ", root, ".\n");
1338 change_partition_var (map, root, x);
1342 if (dump_file && (dump_flags & TDF_DETAILS))
1343 dump_var_map (dump_file, map);
1345 /* Now coalesce everything in the list. */
1346 coalesce_partitions (map, graph, cl,
1347 ((dump_flags & TDF_DETAILS) ? dump_file
1350 delete_coalesce_list (cl);
1351 ssa_conflicts_delete (graph);