1 /* Coalesce SSA_NAMES together for the out-of-ssa pass.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Andrew MacLeod <amacleod@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "diagnostic.h"
30 #include "tree-flow.h"
32 #include "tree-dump.h"
33 #include "tree-ssa-live.h"
37 /* This set of routines implements a coalesce_list. This is an object which
38 is used to track pairs of ssa_names which are desirable to coalesce
39 together to avoid copies. Costs are associated with each pair, and when
40 all desired information has been collected, the object can be used to
41 order the pairs for processing. */
43 /* This structure defines a pair entry. */
45 typedef struct coalesce_pair
51 typedef const struct coalesce_pair
*const_coalesce_pair_p
;
53 typedef struct cost_one_pair_d
57 struct cost_one_pair_d
*next
;
60 /* This structure maintains the list of coalesce pairs. */
62 typedef struct coalesce_list_d
64 htab_t list
; /* Hash table. */
65 coalesce_pair_p
*sorted
; /* List when sorted. */
66 int num_sorted
; /* Number in the sorted list. */
67 cost_one_pair_p cost_one_list
;/* Single use coalesces with cost 1. */
70 #define NO_BEST_COALESCE -1
71 #define MUST_COALESCE_COST INT_MAX
74 /* Return cost of execution of copy instruction with FREQUENCY
75 possibly on CRITICAL edge and in HOT basic block. */
78 coalesce_cost (int frequency
, bool optimize_for_size
, bool critical
)
80 /* Base costs on BB frequencies bounded by 1. */
86 if (optimize_for_size
)
89 /* Inserting copy on critical edge costs more than inserting it elsewhere. */
96 /* Return the cost of executing a copy instruction in basic block BB. */
99 coalesce_cost_bb (basic_block bb
)
101 return coalesce_cost (bb
->frequency
, optimize_bb_for_size_p (bb
), false);
105 /* Return the cost of executing a copy instruction on edge E. */
108 coalesce_cost_edge (edge e
)
110 if (e
->flags
& EDGE_ABNORMAL
)
111 return MUST_COALESCE_COST
;
113 return coalesce_cost (EDGE_FREQUENCY (e
),
114 optimize_edge_for_size_p (e
),
115 EDGE_CRITICAL_P (e
));
119 /* Retrieve a pair to coalesce from the cost_one_list in CL. Returns the
120 2 elements via P1 and P2. 1 is returned by the function if there is a pair,
121 NO_BEST_COALESCE is returned if there aren't any. */
124 pop_cost_one_pair (coalesce_list_p cl
, int *p1
, int *p2
)
128 ptr
= cl
->cost_one_list
;
130 return NO_BEST_COALESCE
;
132 *p1
= ptr
->first_element
;
133 *p2
= ptr
->second_element
;
134 cl
->cost_one_list
= ptr
->next
;
141 /* Retrieve the most expensive remaining pair to coalesce from CL. Returns the
142 2 elements via P1 and P2. Their calculated cost is returned by the function.
143 NO_BEST_COALESCE is returned if the coalesce list is empty. */
146 pop_best_coalesce (coalesce_list_p cl
, int *p1
, int *p2
)
148 coalesce_pair_p node
;
151 if (cl
->sorted
== NULL
)
152 return pop_cost_one_pair (cl
, p1
, p2
);
154 if (cl
->num_sorted
== 0)
155 return pop_cost_one_pair (cl
, p1
, p2
);
157 node
= cl
->sorted
[--(cl
->num_sorted
)];
158 *p1
= node
->first_element
;
159 *p2
= node
->second_element
;
167 #define COALESCE_HASH_FN(R1, R2) ((R2) * ((R2) - 1) / 2 + (R1))
169 /* Hash function for coalesce list. Calculate hash for PAIR. */
172 coalesce_pair_map_hash (const void *pair
)
174 hashval_t a
= (hashval_t
)(((const_coalesce_pair_p
)pair
)->first_element
);
175 hashval_t b
= (hashval_t
)(((const_coalesce_pair_p
)pair
)->second_element
);
177 return COALESCE_HASH_FN (a
,b
);
181 /* Equality function for coalesce list hash table. Compare PAIR1 and PAIR2,
182 returning TRUE if the two pairs are equivalent. */
185 coalesce_pair_map_eq (const void *pair1
, const void *pair2
)
187 const_coalesce_pair_p
const p1
= (const_coalesce_pair_p
) pair1
;
188 const_coalesce_pair_p
const p2
= (const_coalesce_pair_p
) pair2
;
190 return (p1
->first_element
== p2
->first_element
191 && p1
->second_element
== p2
->second_element
);
195 /* Create a new empty coalesce list object and return it. */
197 static inline coalesce_list_p
198 create_coalesce_list (void)
200 coalesce_list_p list
;
201 unsigned size
= num_ssa_names
* 3;
206 list
= (coalesce_list_p
) xmalloc (sizeof (struct coalesce_list_d
));
207 list
->list
= htab_create (size
, coalesce_pair_map_hash
,
208 coalesce_pair_map_eq
, NULL
);
210 list
->num_sorted
= 0;
211 list
->cost_one_list
= NULL
;
216 /* Delete coalesce list CL. */
219 delete_coalesce_list (coalesce_list_p cl
)
221 gcc_assert (cl
->cost_one_list
== NULL
);
222 htab_delete (cl
->list
);
225 gcc_assert (cl
->num_sorted
== 0);
230 /* Find a matching coalesce pair object in CL for the pair P1 and P2. If
231 one isn't found, return NULL if CREATE is false, otherwise create a new
232 coalesce pair object and return it. */
234 static coalesce_pair_p
235 find_coalesce_pair (coalesce_list_p cl
, int p1
, int p2
, bool create
)
237 struct coalesce_pair p
, *pair
;
241 /* Normalize so that p1 is the smaller value. */
244 p
.first_element
= p2
;
245 p
.second_element
= p1
;
249 p
.first_element
= p1
;
250 p
.second_element
= p2
;
254 hash
= coalesce_pair_map_hash (&p
);
255 pair
= (struct coalesce_pair
*) htab_find_with_hash (cl
->list
, &p
, hash
);
259 gcc_assert (cl
->sorted
== NULL
);
260 pair
= XNEW (struct coalesce_pair
);
261 pair
->first_element
= p
.first_element
;
262 pair
->second_element
= p
.second_element
;
264 slot
= htab_find_slot_with_hash (cl
->list
, pair
, hash
, INSERT
);
265 *(struct coalesce_pair
**)slot
= pair
;
272 add_cost_one_coalesce (coalesce_list_p cl
, int p1
, int p2
)
274 cost_one_pair_p pair
;
276 pair
= XNEW (struct cost_one_pair_d
);
277 pair
->first_element
= p1
;
278 pair
->second_element
= p2
;
279 pair
->next
= cl
->cost_one_list
;
280 cl
->cost_one_list
= pair
;
284 /* Add a coalesce between P1 and P2 in list CL with a cost of VALUE. */
287 add_coalesce (coalesce_list_p cl
, int p1
, int p2
, int value
)
289 coalesce_pair_p node
;
291 gcc_assert (cl
->sorted
== NULL
);
295 node
= find_coalesce_pair (cl
, p1
, p2
, true);
297 /* Once the value is at least MUST_COALESCE_COST - 1, leave it that way. */
298 if (node
->cost
< MUST_COALESCE_COST
- 1)
300 if (value
< MUST_COALESCE_COST
- 1)
308 /* Comparison function to allow qsort to sort P1 and P2 in Ascending order. */
311 compare_pairs (const void *p1
, const void *p2
)
313 const_coalesce_pair_p
const *const pp1
= (const_coalesce_pair_p
const *) p1
;
314 const_coalesce_pair_p
const *const pp2
= (const_coalesce_pair_p
const *) p2
;
317 result
= (* pp2
)->cost
- (* pp1
)->cost
;
318 /* Since qsort does not guarantee stability we use the elements
319 as a secondary key. This provides us with independence from
320 the host's implementation of the sorting algorithm. */
323 result
= (* pp2
)->first_element
- (* pp1
)->first_element
;
325 result
= (* pp2
)->second_element
- (* pp1
)->second_element
;
332 /* Return the number of unique coalesce pairs in CL. */
335 num_coalesce_pairs (coalesce_list_p cl
)
337 return htab_elements (cl
->list
);
341 /* Iterator over hash table pairs. */
345 } coalesce_pair_iterator
;
348 /* Return first partition pair from list CL, initializing iterator ITER. */
350 static inline coalesce_pair_p
351 first_coalesce_pair (coalesce_list_p cl
, coalesce_pair_iterator
*iter
)
353 coalesce_pair_p pair
;
355 pair
= (coalesce_pair_p
) first_htab_element (&(iter
->hti
), cl
->list
);
360 /* Return TRUE if there are no more partitions in for ITER to process. */
363 end_coalesce_pair_p (coalesce_pair_iterator
*iter
)
365 return end_htab_p (&(iter
->hti
));
369 /* Return the next partition pair to be visited by ITER. */
371 static inline coalesce_pair_p
372 next_coalesce_pair (coalesce_pair_iterator
*iter
)
374 coalesce_pair_p pair
;
376 pair
= (coalesce_pair_p
) next_htab_element (&(iter
->hti
));
381 /* Iterate over CL using ITER, returning values in PAIR. */
383 #define FOR_EACH_PARTITION_PAIR(PAIR, ITER, CL) \
384 for ((PAIR) = first_coalesce_pair ((CL), &(ITER)); \
385 !end_coalesce_pair_p (&(ITER)); \
386 (PAIR) = next_coalesce_pair (&(ITER)))
389 /* Prepare CL for removal of preferred pairs. When finished they are sorted
390 in order from most important coalesce to least important. */
393 sort_coalesce_list (coalesce_list_p cl
)
397 coalesce_pair_iterator ppi
;
399 gcc_assert (cl
->sorted
== NULL
);
401 num
= num_coalesce_pairs (cl
);
402 cl
->num_sorted
= num
;
406 /* Allocate a vector for the pair pointers. */
407 cl
->sorted
= XNEWVEC (coalesce_pair_p
, num
);
409 /* Populate the vector with pointers to the pairs. */
411 FOR_EACH_PARTITION_PAIR (p
, ppi
, cl
)
413 gcc_assert (x
== num
);
415 /* Already sorted. */
419 /* If there are only 2, just pick swap them if the order isn't correct. */
422 if (cl
->sorted
[0]->cost
> cl
->sorted
[1]->cost
)
425 cl
->sorted
[0] = cl
->sorted
[1];
431 /* Only call qsort if there are more than 2 items. */
433 qsort (cl
->sorted
, num
, sizeof (coalesce_pair_p
), compare_pairs
);
437 /* Send debug info for coalesce list CL to file F. */
440 dump_coalesce_list (FILE *f
, coalesce_list_p cl
)
442 coalesce_pair_p node
;
443 coalesce_pair_iterator ppi
;
447 if (cl
->sorted
== NULL
)
449 fprintf (f
, "Coalesce List:\n");
450 FOR_EACH_PARTITION_PAIR (node
, ppi
, cl
)
452 tree var1
= ssa_name (node
->first_element
);
453 tree var2
= ssa_name (node
->second_element
);
454 print_generic_expr (f
, var1
, TDF_SLIM
);
455 fprintf (f
, " <-> ");
456 print_generic_expr (f
, var2
, TDF_SLIM
);
457 fprintf (f
, " (%1d), ", node
->cost
);
463 fprintf (f
, "Sorted Coalesce list:\n");
464 for (x
= cl
->num_sorted
- 1 ; x
>=0; x
--)
466 node
= cl
->sorted
[x
];
467 fprintf (f
, "(%d) ", node
->cost
);
468 var
= ssa_name (node
->first_element
);
469 print_generic_expr (f
, var
, TDF_SLIM
);
470 fprintf (f
, " <-> ");
471 var
= ssa_name (node
->second_element
);
472 print_generic_expr (f
, var
, TDF_SLIM
);
479 /* This represents a conflict graph. Implemented as an array of bitmaps.
480 A full matrix is used for conflicts rather than just upper triangular form.
481 this make sit much simpler and faster to perform conflict merges. */
483 typedef struct ssa_conflicts_d
490 /* Return an empty new conflict graph for SIZE elements. */
492 static inline ssa_conflicts_p
493 ssa_conflicts_new (unsigned size
)
497 ptr
= XNEW (struct ssa_conflicts_d
);
498 ptr
->conflicts
= XCNEWVEC (bitmap
, size
);
504 /* Free storage for conflict graph PTR. */
507 ssa_conflicts_delete (ssa_conflicts_p ptr
)
510 for (x
= 0; x
< ptr
->size
; x
++)
511 if (ptr
->conflicts
[x
])
512 BITMAP_FREE (ptr
->conflicts
[x
]);
514 free (ptr
->conflicts
);
519 /* Test if elements X and Y conflict in graph PTR. */
522 ssa_conflicts_test_p (ssa_conflicts_p ptr
, unsigned x
, unsigned y
)
526 #ifdef ENABLE_CHECKING
527 gcc_assert (x
< ptr
->size
);
528 gcc_assert (y
< ptr
->size
);
532 b
= ptr
->conflicts
[x
];
534 /* Avoid the lookup if Y has no conflicts. */
535 return ptr
->conflicts
[y
] ? bitmap_bit_p (b
, y
) : false;
541 /* Add a conflict with Y to the bitmap for X in graph PTR. */
544 ssa_conflicts_add_one (ssa_conflicts_p ptr
, unsigned x
, unsigned y
)
546 /* If there are no conflicts yet, allocate the bitmap and set bit. */
547 if (!ptr
->conflicts
[x
])
548 ptr
->conflicts
[x
] = BITMAP_ALLOC (NULL
);
549 bitmap_set_bit (ptr
->conflicts
[x
], y
);
553 /* Add conflicts between X and Y in graph PTR. */
556 ssa_conflicts_add (ssa_conflicts_p ptr
, unsigned x
, unsigned y
)
558 #ifdef ENABLE_CHECKING
559 gcc_assert (x
< ptr
->size
);
560 gcc_assert (y
< ptr
->size
);
563 ssa_conflicts_add_one (ptr
, x
, y
);
564 ssa_conflicts_add_one (ptr
, y
, x
);
568 /* Merge all Y's conflict into X in graph PTR. */
571 ssa_conflicts_merge (ssa_conflicts_p ptr
, unsigned x
, unsigned y
)
577 if (!(ptr
->conflicts
[y
]))
580 /* Add a conflict between X and every one Y has. If the bitmap doesn't
581 exist, then it has already been coalesced, and we don't need to add a
583 EXECUTE_IF_SET_IN_BITMAP (ptr
->conflicts
[y
], 0, z
, bi
)
584 if (ptr
->conflicts
[z
])
585 bitmap_set_bit (ptr
->conflicts
[z
], x
);
587 if (ptr
->conflicts
[x
])
589 /* If X has conflicts, add Y's to X. */
590 bitmap_ior_into (ptr
->conflicts
[x
], ptr
->conflicts
[y
]);
591 BITMAP_FREE (ptr
->conflicts
[y
]);
595 /* If X has no conflicts, simply use Y's. */
596 ptr
->conflicts
[x
] = ptr
->conflicts
[y
];
597 ptr
->conflicts
[y
] = NULL
;
602 /* Dump a conflicts graph. */
605 ssa_conflicts_dump (FILE *file
, ssa_conflicts_p ptr
)
609 fprintf (file
, "\nConflict graph:\n");
611 for (x
= 0; x
< ptr
->size
; x
++)
612 if (ptr
->conflicts
[x
])
614 fprintf (dump_file
, "%d: ", x
);
615 dump_bitmap (file
, ptr
->conflicts
[x
]);
620 /* This structure is used to efficiently record the current status of live
621 SSA_NAMES when building a conflict graph.
622 LIVE_BASE_VAR has a bit set for each base variable which has at least one
624 LIVE_BASE_PARTITIONS is an array of bitmaps using the basevar table as an
625 index, and is used to track what partitions of each base variable are
626 live. This makes it easy to add conflicts between just live partitions
627 with the same base variable.
628 The values in LIVE_BASE_PARTITIONS are only valid if the base variable is
629 marked as being live. This delays clearing of these bitmaps until
630 they are actually needed again. */
632 typedef struct live_track_d
634 bitmap live_base_var
; /* Indicates if a basevar is live. */
635 bitmap
*live_base_partitions
; /* Live partitions for each basevar. */
636 var_map map
; /* Var_map being used for partition mapping. */
640 /* This routine will create a new live track structure based on the partitions
644 new_live_track (var_map map
)
649 /* Make sure there is a partition view in place. */
650 gcc_assert (map
->partition_to_base_index
!= NULL
);
652 ptr
= (live_track_p
) xmalloc (sizeof (struct live_track_d
));
654 lim
= num_basevars (map
);
655 ptr
->live_base_partitions
= (bitmap
*) xmalloc(sizeof (bitmap
*) * lim
);
656 ptr
->live_base_var
= BITMAP_ALLOC (NULL
);
657 for (x
= 0; x
< lim
; x
++)
658 ptr
->live_base_partitions
[x
] = BITMAP_ALLOC (NULL
);
663 /* This routine will free the memory associated with PTR. */
666 delete_live_track (live_track_p ptr
)
670 lim
= num_basevars (ptr
->map
);
671 for (x
= 0; x
< lim
; x
++)
672 BITMAP_FREE (ptr
->live_base_partitions
[x
]);
673 BITMAP_FREE (ptr
->live_base_var
);
674 free (ptr
->live_base_partitions
);
679 /* This function will remove PARTITION from the live list in PTR. */
682 live_track_remove_partition (live_track_p ptr
, int partition
)
686 root
= basevar_index (ptr
->map
, partition
);
687 bitmap_clear_bit (ptr
->live_base_partitions
[root
], partition
);
688 /* If the element list is empty, make the base variable not live either. */
689 if (bitmap_empty_p (ptr
->live_base_partitions
[root
]))
690 bitmap_clear_bit (ptr
->live_base_var
, root
);
694 /* This function will adds PARTITION to the live list in PTR. */
697 live_track_add_partition (live_track_p ptr
, int partition
)
701 root
= basevar_index (ptr
->map
, partition
);
702 /* If this base var wasn't live before, it is now. Clear the element list
703 since it was delayed until needed. */
704 if (!bitmap_bit_p (ptr
->live_base_var
, root
))
706 bitmap_set_bit (ptr
->live_base_var
, root
);
707 bitmap_clear (ptr
->live_base_partitions
[root
]);
709 bitmap_set_bit (ptr
->live_base_partitions
[root
], partition
);
714 /* Clear the live bit for VAR in PTR. */
717 live_track_clear_var (live_track_p ptr
, tree var
)
721 p
= var_to_partition (ptr
->map
, var
);
722 if (p
!= NO_PARTITION
)
723 live_track_remove_partition (ptr
, p
);
727 /* Return TRUE if VAR is live in PTR. */
730 live_track_live_p (live_track_p ptr
, tree var
)
734 p
= var_to_partition (ptr
->map
, var
);
735 if (p
!= NO_PARTITION
)
737 root
= basevar_index (ptr
->map
, p
);
738 if (bitmap_bit_p (ptr
->live_base_var
, root
))
739 return bitmap_bit_p (ptr
->live_base_partitions
[root
], p
);
745 /* This routine will add USE to PTR. USE will be marked as live in both the
746 ssa live map and the live bitmap for the root of USE. */
749 live_track_process_use (live_track_p ptr
, tree use
)
753 p
= var_to_partition (ptr
->map
, use
);
754 if (p
== NO_PARTITION
)
757 /* Mark as live in the appropriate live list. */
758 live_track_add_partition (ptr
, p
);
762 /* This routine will process a DEF in PTR. DEF will be removed from the live
763 lists, and if there are any other live partitions with the same base
764 variable, conflicts will be added to GRAPH. */
767 live_track_process_def (live_track_p ptr
, tree def
, ssa_conflicts_p graph
)
774 p
= var_to_partition (ptr
->map
, def
);
775 if (p
== NO_PARTITION
)
778 /* Clear the liveness bit. */
779 live_track_remove_partition (ptr
, p
);
781 /* If the bitmap isn't empty now, conflicts need to be added. */
782 root
= basevar_index (ptr
->map
, p
);
783 if (bitmap_bit_p (ptr
->live_base_var
, root
))
785 b
= ptr
->live_base_partitions
[root
];
786 EXECUTE_IF_SET_IN_BITMAP (b
, 0, x
, bi
)
787 ssa_conflicts_add (graph
, p
, x
);
792 /* Initialize PTR with the partitions set in INIT. */
795 live_track_init (live_track_p ptr
, bitmap init
)
800 /* Mark all live on exit partitions. */
801 EXECUTE_IF_SET_IN_BITMAP (init
, 0, p
, bi
)
802 live_track_add_partition (ptr
, p
);
806 /* This routine will clear all live partitions in PTR. */
809 live_track_clear_base_vars (live_track_p ptr
)
811 /* Simply clear the live base list. Anything marked as live in the element
812 lists will be cleared later if/when the base variable ever comes alive
814 bitmap_clear (ptr
->live_base_var
);
818 /* Build a conflict graph based on LIVEINFO. Any partitions which are in the
819 partition view of the var_map liveinfo is based on get entries in the
820 conflict graph. Only conflicts between ssa_name partitions with the same
821 base variable are added. */
823 static ssa_conflicts_p
824 build_ssa_conflict_graph (tree_live_info_p liveinfo
)
826 ssa_conflicts_p graph
;
832 map
= live_var_map (liveinfo
);
833 graph
= ssa_conflicts_new (num_var_partitions (map
));
835 live
= new_live_track (map
);
839 gimple_stmt_iterator gsi
;
841 /* Start with live on exit temporaries. */
842 live_track_init (live
, live_on_exit (liveinfo
, bb
));
844 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
847 gimple stmt
= gsi_stmt (gsi
);
849 /* A copy between 2 partitions does not introduce an interference
850 by itself. If they did, you would never be able to coalesce
851 two things which are copied. If the two variables really do
852 conflict, they will conflict elsewhere in the program.
854 This is handled by simply removing the SRC of the copy from the
855 live list, and processing the stmt normally. */
856 if (is_gimple_assign (stmt
))
858 tree lhs
= gimple_assign_lhs (stmt
);
859 tree rhs1
= gimple_assign_rhs1 (stmt
);
860 if (gimple_assign_copy_p (stmt
)
861 && TREE_CODE (lhs
) == SSA_NAME
862 && TREE_CODE (rhs1
) == SSA_NAME
)
863 live_track_clear_var (live
, rhs1
);
866 FOR_EACH_SSA_TREE_OPERAND (var
, stmt
, iter
, SSA_OP_DEF
)
867 live_track_process_def (live
, var
, graph
);
869 FOR_EACH_SSA_TREE_OPERAND (var
, stmt
, iter
, SSA_OP_USE
)
870 live_track_process_use (live
, var
);
873 /* If result of a PHI is unused, looping over the statements will not
874 record any conflicts since the def was never live. Since the PHI node
875 is going to be translated out of SSA form, it will insert a copy.
876 There must be a conflict recorded between the result of the PHI and
877 any variables that are live. Otherwise the out-of-ssa translation
878 may create incorrect code. */
879 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
881 gimple phi
= gsi_stmt (gsi
);
882 tree result
= PHI_RESULT (phi
);
883 if (live_track_live_p (live
, result
))
884 live_track_process_def (live
, result
, graph
);
887 live_track_clear_base_vars (live
);
890 delete_live_track (live
);
895 /* Shortcut routine to print messages to file F of the form:
896 "STR1 EXPR1 STR2 EXPR2 STR3." */
899 print_exprs (FILE *f
, const char *str1
, tree expr1
, const char *str2
,
900 tree expr2
, const char *str3
)
902 fprintf (f
, "%s", str1
);
903 print_generic_expr (f
, expr1
, TDF_SLIM
);
904 fprintf (f
, "%s", str2
);
905 print_generic_expr (f
, expr2
, TDF_SLIM
);
906 fprintf (f
, "%s", str3
);
910 /* Called if a coalesce across and abnormal edge cannot be performed. PHI is
911 the phi node at fault, I is the argument index at fault. A message is
912 printed and compilation is then terminated. */
915 abnormal_corrupt (gimple phi
, int i
)
917 edge e
= gimple_phi_arg_edge (phi
, i
);
918 tree res
= gimple_phi_result (phi
);
919 tree arg
= gimple_phi_arg_def (phi
, i
);
921 fprintf (stderr
, " Corrupt SSA across abnormal edge BB%d->BB%d\n",
922 e
->src
->index
, e
->dest
->index
);
923 fprintf (stderr
, "Argument %d (", i
);
924 print_generic_expr (stderr
, arg
, TDF_SLIM
);
925 if (TREE_CODE (arg
) != SSA_NAME
)
926 fprintf (stderr
, ") is not an SSA_NAME.\n");
929 gcc_assert (SSA_NAME_VAR (res
) != SSA_NAME_VAR (arg
));
930 fprintf (stderr
, ") does not have the same base variable as the result ");
931 print_generic_stmt (stderr
, res
, TDF_SLIM
);
934 internal_error ("SSA corruption");
938 /* Print a failure to coalesce a MUST_COALESCE pair X and Y. */
941 fail_abnormal_edge_coalesce (int x
, int y
)
943 fprintf (stderr
, "\nUnable to coalesce ssa_names %d and %d",x
, y
);
944 fprintf (stderr
, " which are marked as MUST COALESCE.\n");
945 print_generic_expr (stderr
, ssa_name (x
), TDF_SLIM
);
946 fprintf (stderr
, " and ");
947 print_generic_stmt (stderr
, ssa_name (y
), TDF_SLIM
);
949 internal_error ("SSA corruption");
953 /* This function creates a var_map for the current function as well as creating
954 a coalesce list for use later in the out of ssa process. */
957 create_outofssa_var_map (coalesce_list_p cl
, bitmap used_in_copy
)
959 gimple_stmt_iterator gsi
;
969 #ifdef ENABLE_CHECKING
970 bitmap used_in_real_ops
;
971 bitmap used_in_virtual_ops
;
973 used_in_real_ops
= BITMAP_ALLOC (NULL
);
974 used_in_virtual_ops
= BITMAP_ALLOC (NULL
);
977 map
= init_var_map (num_ssa_names
+ 1);
983 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
985 gimple phi
= gsi_stmt (gsi
);
989 bool saw_copy
= false;
991 res
= gimple_phi_result (phi
);
992 ver
= SSA_NAME_VERSION (res
);
993 register_ssa_partition (map
, res
);
995 /* Register ssa_names and coalesces between the args and the result
997 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
999 edge e
= gimple_phi_arg_edge (phi
, i
);
1000 arg
= PHI_ARG_DEF (phi
, i
);
1001 if (TREE_CODE (arg
) == SSA_NAME
)
1002 register_ssa_partition (map
, arg
);
1003 if (TREE_CODE (arg
) == SSA_NAME
1004 && SSA_NAME_VAR (arg
) == SSA_NAME_VAR (res
))
1007 bitmap_set_bit (used_in_copy
, SSA_NAME_VERSION (arg
));
1008 if ((e
->flags
& EDGE_ABNORMAL
) == 0)
1010 int cost
= coalesce_cost_edge (e
);
1011 if (cost
== 1 && has_single_use (arg
))
1012 add_cost_one_coalesce (cl
, ver
, SSA_NAME_VERSION (arg
));
1014 add_coalesce (cl
, ver
, SSA_NAME_VERSION (arg
), cost
);
1018 if (e
->flags
& EDGE_ABNORMAL
)
1019 abnormal_corrupt (phi
, i
);
1022 bitmap_set_bit (used_in_copy
, ver
);
1025 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1027 stmt
= gsi_stmt (gsi
);
1029 /* Register USE and DEF operands in each statement. */
1030 FOR_EACH_SSA_TREE_OPERAND (var
, stmt
, iter
, (SSA_OP_DEF
|SSA_OP_USE
))
1031 register_ssa_partition (map
, var
);
1033 /* Check for copy coalesces. */
1034 switch (gimple_code (stmt
))
1038 tree lhs
= gimple_assign_lhs (stmt
);
1039 tree rhs1
= gimple_assign_rhs1 (stmt
);
1041 if (gimple_assign_copy_p (stmt
)
1042 && TREE_CODE (lhs
) == SSA_NAME
1043 && TREE_CODE (rhs1
) == SSA_NAME
1044 && SSA_NAME_VAR (lhs
) == SSA_NAME_VAR (rhs1
))
1046 v1
= SSA_NAME_VERSION (lhs
);
1047 v2
= SSA_NAME_VERSION (rhs1
);
1048 cost
= coalesce_cost_bb (bb
);
1049 add_coalesce (cl
, v1
, v2
, cost
);
1050 bitmap_set_bit (used_in_copy
, v1
);
1051 bitmap_set_bit (used_in_copy
, v2
);
1058 unsigned long noutputs
, i
;
1059 unsigned long ninputs
;
1060 tree
*outputs
, link
;
1061 noutputs
= gimple_asm_noutputs (stmt
);
1062 ninputs
= gimple_asm_ninputs (stmt
);
1063 outputs
= (tree
*) alloca (noutputs
* sizeof (tree
));
1064 for (i
= 0; i
< noutputs
; ++i
) {
1065 link
= gimple_asm_output_op (stmt
, i
);
1066 outputs
[i
] = TREE_VALUE (link
);
1069 for (i
= 0; i
< ninputs
; ++i
)
1071 const char *constraint
;
1074 unsigned long match
;
1076 link
= gimple_asm_input_op (stmt
, i
);
1078 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
1079 input
= TREE_VALUE (link
);
1081 if (TREE_CODE (input
) != SSA_NAME
)
1084 match
= strtoul (constraint
, &end
, 10);
1085 if (match
>= noutputs
|| end
== constraint
)
1088 if (TREE_CODE (outputs
[match
]) != SSA_NAME
)
1091 v1
= SSA_NAME_VERSION (outputs
[match
]);
1092 v2
= SSA_NAME_VERSION (input
);
1094 if (SSA_NAME_VAR (outputs
[match
]) == SSA_NAME_VAR (input
))
1096 cost
= coalesce_cost (REG_BR_PROB_BASE
,
1097 optimize_bb_for_size_p (bb
),
1099 add_coalesce (cl
, v1
, v2
, cost
);
1100 bitmap_set_bit (used_in_copy
, v1
);
1101 bitmap_set_bit (used_in_copy
, v2
);
1111 #ifdef ENABLE_CHECKING
1112 /* Mark real uses and defs. */
1113 FOR_EACH_SSA_TREE_OPERAND (var
, stmt
, iter
, (SSA_OP_DEF
|SSA_OP_USE
))
1114 bitmap_set_bit (used_in_real_ops
, DECL_UID (SSA_NAME_VAR (var
)));
1116 /* Validate that virtual ops don't get used in funny ways. */
1117 if (gimple_vuse (stmt
))
1118 bitmap_set_bit (used_in_virtual_ops
,
1119 DECL_UID (SSA_NAME_VAR (gimple_vuse (stmt
))));
1120 #endif /* ENABLE_CHECKING */
1124 /* Now process result decls and live on entry variables for entry into
1125 the coalesce list. */
1127 for (i
= 1; i
< num_ssa_names
; i
++)
1129 var
= map
->partition_to_var
[i
];
1130 if (var
!= NULL_TREE
)
1132 /* Add coalesces between all the result decls. */
1133 if (TREE_CODE (SSA_NAME_VAR (var
)) == RESULT_DECL
)
1135 if (first
== NULL_TREE
)
1139 gcc_assert (SSA_NAME_VAR (var
) == SSA_NAME_VAR (first
));
1140 v1
= SSA_NAME_VERSION (first
);
1141 v2
= SSA_NAME_VERSION (var
);
1142 bitmap_set_bit (used_in_copy
, v1
);
1143 bitmap_set_bit (used_in_copy
, v2
);
1144 cost
= coalesce_cost_bb (EXIT_BLOCK_PTR
);
1145 add_coalesce (cl
, v1
, v2
, cost
);
1148 /* Mark any default_def variables as being in the coalesce list
1149 since they will have to be coalesced with the base variable. If
1150 not marked as present, they won't be in the coalesce view. */
1151 if (gimple_default_def (cfun
, SSA_NAME_VAR (var
)) == var
)
1152 bitmap_set_bit (used_in_copy
, SSA_NAME_VERSION (var
));
1156 #if defined ENABLE_CHECKING
1159 bitmap both
= BITMAP_ALLOC (NULL
);
1160 bitmap_and (both
, used_in_real_ops
, used_in_virtual_ops
);
1161 if (!bitmap_empty_p (both
))
1165 EXECUTE_IF_SET_IN_BITMAP (both
, 0, i
, bi
)
1166 fprintf (stderr
, "Variable %s used in real and virtual operands\n",
1167 get_name (referenced_var (i
)));
1168 internal_error ("SSA corruption");
1171 BITMAP_FREE (used_in_real_ops
);
1172 BITMAP_FREE (used_in_virtual_ops
);
1181 /* Attempt to coalesce ssa versions X and Y together using the partition
1182 mapping in MAP and checking conflicts in GRAPH. Output any debug info to
1183 DEBUG, if it is nun-NULL. */
1186 attempt_coalesce (var_map map
, ssa_conflicts_p graph
, int x
, int y
,
1193 p1
= var_to_partition (map
, ssa_name (x
));
1194 p2
= var_to_partition (map
, ssa_name (y
));
1198 fprintf (debug
, "(%d)", x
);
1199 print_generic_expr (debug
, partition_to_var (map
, p1
), TDF_SLIM
);
1200 fprintf (debug
, " & (%d)", y
);
1201 print_generic_expr (debug
, partition_to_var (map
, p2
), TDF_SLIM
);
1207 fprintf (debug
, ": Already Coalesced.\n");
1212 fprintf (debug
, " [map: %d, %d] ", p1
, p2
);
1215 if (!ssa_conflicts_test_p (graph
, p1
, p2
))
1217 var1
= partition_to_var (map
, p1
);
1218 var2
= partition_to_var (map
, p2
);
1219 z
= var_union (map
, var1
, var2
);
1220 if (z
== NO_PARTITION
)
1223 fprintf (debug
, ": Unable to perform partition union.\n");
1227 /* z is the new combined partition. Remove the other partition from
1228 the list, and merge the conflicts. */
1230 ssa_conflicts_merge (graph
, p1
, p2
);
1232 ssa_conflicts_merge (graph
, p2
, p1
);
1235 fprintf (debug
, ": Success -> %d\n", z
);
1240 fprintf (debug
, ": Fail due to conflict\n");
1246 /* Attempt to Coalesce partitions in MAP which occur in the list CL using
1247 GRAPH. Debug output is sent to DEBUG if it is non-NULL. */
1250 coalesce_partitions (var_map map
, ssa_conflicts_p graph
, coalesce_list_p cl
,
1260 /* First, coalesce all the copies across abnormal edges. These are not placed
1261 in the coalesce list because they do not need to be sorted, and simply
1262 consume extra memory/compilation time in large programs. */
1266 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1267 if (e
->flags
& EDGE_ABNORMAL
)
1269 gimple_stmt_iterator gsi
;
1270 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1273 gimple phi
= gsi_stmt (gsi
);
1274 tree res
= PHI_RESULT (phi
);
1275 tree arg
= PHI_ARG_DEF (phi
, e
->dest_idx
);
1276 int v1
= SSA_NAME_VERSION (res
);
1277 int v2
= SSA_NAME_VERSION (arg
);
1279 if (SSA_NAME_VAR (arg
) != SSA_NAME_VAR (res
))
1280 abnormal_corrupt (phi
, e
->dest_idx
);
1283 fprintf (debug
, "Abnormal coalesce: ");
1285 if (!attempt_coalesce (map
, graph
, v1
, v2
, debug
))
1286 fail_abnormal_edge_coalesce (v1
, v2
);
1291 /* Now process the items in the coalesce list. */
1293 while ((cost
= pop_best_coalesce (cl
, &x
, &y
)) != NO_BEST_COALESCE
)
1295 var1
= ssa_name (x
);
1296 var2
= ssa_name (y
);
1298 /* Assert the coalesces have the same base variable. */
1299 gcc_assert (SSA_NAME_VAR (var1
) == SSA_NAME_VAR (var2
));
1302 fprintf (debug
, "Coalesce list: ");
1303 attempt_coalesce (map
, graph
, x
, y
, debug
);
1307 /* Returns a hash code for P. */
1310 hash_ssa_name_by_var (const void *p
)
1312 const_tree n
= (const_tree
) p
;
1313 return (hashval_t
) htab_hash_pointer (SSA_NAME_VAR (n
));
1316 /* Returns nonzero if P1 and P2 are equal. */
1319 eq_ssa_name_by_var (const void *p1
, const void *p2
)
1321 const_tree n1
= (const_tree
) p1
;
1322 const_tree n2
= (const_tree
) p2
;
1323 return SSA_NAME_VAR (n1
) == SSA_NAME_VAR (n2
);
1326 /* Reduce the number of copies by coalescing variables in the function. Return
1327 a partition map with the resulting coalesces. */
1330 coalesce_ssa_name (void)
1333 tree_live_info_p liveinfo
;
1334 ssa_conflicts_p graph
;
1336 bitmap used_in_copies
= BITMAP_ALLOC (NULL
);
1339 static htab_t ssa_name_hash
;
1341 cl
= create_coalesce_list ();
1342 map
= create_outofssa_var_map (cl
, used_in_copies
);
1344 /* We need to coalesce all names originating same SSA_NAME_VAR
1345 so debug info remains undisturbed. */
1348 ssa_name_hash
= htab_create (10, hash_ssa_name_by_var
,
1349 eq_ssa_name_by_var
, NULL
);
1350 for (i
= 1; i
< num_ssa_names
; i
++)
1352 tree a
= ssa_name (i
);
1354 if (a
&& SSA_NAME_VAR (a
) && !DECL_ARTIFICIAL (SSA_NAME_VAR (a
)))
1356 tree
*slot
= (tree
*) htab_find_slot (ssa_name_hash
, a
, INSERT
);
1362 add_coalesce (cl
, SSA_NAME_VERSION (a
), SSA_NAME_VERSION (*slot
),
1363 MUST_COALESCE_COST
- 1);
1364 bitmap_set_bit (used_in_copies
, SSA_NAME_VERSION (a
));
1365 bitmap_set_bit (used_in_copies
, SSA_NAME_VERSION (*slot
));
1369 htab_delete (ssa_name_hash
);
1371 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1372 dump_var_map (dump_file
, map
);
1374 /* Don't calculate live ranges for variables not in the coalesce list. */
1375 partition_view_bitmap (map
, used_in_copies
, true);
1376 BITMAP_FREE (used_in_copies
);
1378 if (num_var_partitions (map
) < 1)
1380 delete_coalesce_list (cl
);
1384 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1385 dump_var_map (dump_file
, map
);
1387 liveinfo
= calculate_live_ranges (map
);
1389 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1390 dump_live_info (dump_file
, liveinfo
, LIVEDUMP_ENTRY
);
1392 /* Build a conflict graph. */
1393 graph
= build_ssa_conflict_graph (liveinfo
);
1394 delete_tree_live_info (liveinfo
);
1395 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1396 ssa_conflicts_dump (dump_file
, graph
);
1398 sort_coalesce_list (cl
);
1400 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1402 fprintf (dump_file
, "\nAfter sorting:\n");
1403 dump_coalesce_list (dump_file
, cl
);
1406 /* First, coalesce all live on entry variables to their base variable.
1407 This will ensure the first use is coming from the correct location. */
1409 num
= num_var_partitions (map
);
1410 for (x
= 0 ; x
< num
; x
++)
1412 tree var
= partition_to_var (map
, x
);
1415 if (TREE_CODE (var
) != SSA_NAME
)
1418 root
= SSA_NAME_VAR (var
);
1419 if (gimple_default_def (cfun
, root
) == var
)
1421 /* This root variable should have not already been assigned
1422 to another partition which is not coalesced with this one. */
1423 gcc_assert (!var_ann (root
)->out_of_ssa_tag
);
1425 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1427 print_exprs (dump_file
, "Must coalesce ", var
,
1428 " with the root variable ", root
, ".\n");
1430 change_partition_var (map
, root
, x
);
1434 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1435 dump_var_map (dump_file
, map
);
1437 /* Now coalesce everything in the list. */
1438 coalesce_partitions (map
, graph
, cl
,
1439 ((dump_flags
& TDF_DETAILS
) ? dump_file
1442 delete_coalesce_list (cl
);
1443 ssa_conflicts_delete (graph
);