1 /* Generic partial redundancy elimination with lazy code motion
3 Copyright (C) 1998 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC 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 2, or (at your option)
12 GNU CC 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 GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* These routines are meant to be used by various optimization
23 passes which can be modeled as lazy code motion problems.
24 Including, but not limited to:
26 * Traditional partial redundancy elimination.
28 * Placement of caller/caller register save/restores.
34 * Conversion of flat register files to a stacked register
37 * Dead load/store elimination.
39 These routines accept as input:
41 * Basic block information (number of blocks, lists of
42 predecessors and successors). Note the granularity
43 does not need to be basic block, they could be statements
46 * Bitmaps of local properties (computed, transparent and
47 anticipatable expressions).
49 The output of these routines is bitmap of redundant computations
50 and a bitmap of optimal placement points. */
58 #include "hard-reg-set.h"
61 #include "insn-config.h"
63 #include "basic-block.h"
65 /* Edge based LCM routines. */
66 static void compute_antinout_edge PROTO ((sbitmap *, sbitmap *,
67 sbitmap *, sbitmap *));
68 static void compute_earliest PROTO((struct edge_list *, int, sbitmap *,
69 sbitmap *, sbitmap *, sbitmap *,
71 static void compute_laterin PROTO((struct edge_list *, sbitmap *,
72 sbitmap *, sbitmap *, sbitmap *));
73 static void compute_insert_delete PROTO ((struct edge_list *edge_list,
74 sbitmap *, sbitmap *, sbitmap *,
75 sbitmap *, sbitmap *));
77 /* Edge based LCM routines on a reverse flowgraph. */
78 static void compute_farthest PROTO ((struct edge_list *, int, sbitmap *,
79 sbitmap *, sbitmap*, sbitmap *,
81 static void compute_nearerout PROTO((struct edge_list *, sbitmap *,
82 sbitmap *, sbitmap *, sbitmap *));
83 static void compute_rev_insert_delete PROTO ((struct edge_list *edge_list,
84 sbitmap *, sbitmap *, sbitmap *,
85 sbitmap *, sbitmap *));
88 /* Edge based lcm routines. */
90 /* Compute expression anticipatability at entrance and exit of each block.
91 This is done based on the flow graph, and not on the pred-succ lists.
92 Other than that, its pretty much identical to compute_antinout. */
95 compute_antinout_edge (antloc, transp, antin, antout)
103 basic_block *worklist, *tos;
105 /* Allocate a worklist array/queue. Entries are only added to the
106 list if they were not already on the list. So the size is
107 bounded by the number of basic blocks. */
108 tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
111 /* We want a maximal solution, so make an optimistic initialization of
113 sbitmap_vector_ones (antin, n_basic_blocks);
115 /* Put every block on the worklist; this is necessary because of the
116 optimistic initialization of ANTIN above. */
117 for (bb = 0; bb < n_basic_blocks; bb++)
119 *tos++ = BASIC_BLOCK (bb);
120 BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
123 /* Mark blocks which are predecessors of the exit block so that we
124 can easily identify them below. */
125 for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next)
126 e->src->aux = EXIT_BLOCK_PTR;
128 /* Iterate until the worklist is empty. */
129 while (tos != worklist)
131 /* Take the first entry off the worklist. */
132 basic_block b = *--tos;
135 if (b->aux == EXIT_BLOCK_PTR)
137 /* Do not clear the aux field for blocks which are
138 predecessors of the EXIT block. That way we never
139 add then to the worklist again. */
140 sbitmap_zero (antout[bb]);
144 /* Clear the aux field of this block so that it can be added to
145 the worklist again if necessary. */
147 sbitmap_intersection_of_succs (antout[bb], antin, bb);
150 if (sbitmap_a_or_b_and_c (antin[bb], antloc[bb], transp[bb], antout[bb]))
152 /* If the in state of this block changed, then we need
153 to add the predecessors of this block to the worklist
154 if they are not already on the worklist. */
155 for (e = b->pred; e; e = e->pred_next)
157 if (!e->src->aux && e->src != ENTRY_BLOCK_PTR)
168 /* Compute the earliest vector for edge based lcm. */
170 compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest)
171 struct edge_list *edge_list;
173 sbitmap *antin, *antout, *avout, *kill, *earliest;
175 sbitmap difference, temp_bitmap;
177 basic_block pred, succ;
179 num_edges = NUM_EDGES (edge_list);
181 difference = sbitmap_alloc (n_exprs);
182 temp_bitmap = sbitmap_alloc (n_exprs);
184 for (x = 0; x < num_edges; x++)
186 pred = INDEX_EDGE_PRED_BB (edge_list, x);
187 succ = INDEX_EDGE_SUCC_BB (edge_list, x);
188 if (pred == ENTRY_BLOCK_PTR)
189 sbitmap_copy (earliest[x], antin[succ->index]);
192 if (succ == EXIT_BLOCK_PTR)
194 sbitmap_zero (earliest[x]);
198 sbitmap_difference (difference, antin[succ->index],
200 sbitmap_not (temp_bitmap, antout[pred->index]);
201 sbitmap_a_and_b_or_c (earliest[x], difference, kill[pred->index],
210 /* later(p,s) is dependent on the calculation of laterin(p).
211 laterin(p) is dependent on the calculation of later(p2,p).
213 laterin(ENTRY) is defined as all 0's
214 later(ENTRY, succs(ENTRY)) are defined using laterin(ENTRY)
215 laterin(succs(ENTRY)) is defined by later(ENTRY, succs(ENTRY)).
217 If we progress in this manner, starting with all basic blocks
218 in the work list, anytime we change later(bb), we need to add
219 succs(bb) to the worklist if they are not already on the worklist.
223 We prime the worklist all the normal basic blocks. The ENTRY block can
224 never be added to the worklist since it is never the successor of any
225 block. We explicitly prevent the EXIT block from being added to the
228 We optimistically initialize LATER. That is the only time this routine
229 will compute LATER for an edge out of the entry block since the entry
230 block is never on the worklist. Thus, LATERIN is neither used nor
231 computed for the ENTRY block.
233 Since the EXIT block is never added to the worklist, we will neither
234 use nor compute LATERIN for the exit block. Edges which reach the
235 EXIT block are handled in the normal fashion inside the loop. However,
236 the insertion/deletion computation needs LATERIN(EXIT), so we have
240 compute_laterin (edge_list, earliest, antloc, later, laterin)
241 struct edge_list *edge_list;
242 sbitmap *earliest, *antloc, *later, *laterin;
244 int bb, num_edges, i;
246 basic_block *worklist, *tos;
248 num_edges = NUM_EDGES (edge_list);
250 /* Allocate a worklist array/queue. Entries are only added to the
251 list if they were not already on the list. So the size is
252 bounded by the number of basic blocks. */
253 tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
254 * (n_basic_blocks + 1));
256 /* Initialize a mapping from each edge to its index. */
257 for (i = 0; i < num_edges; i++)
258 INDEX_EDGE (edge_list, i)->aux = (void *)i;
260 /* We want a maximal solution, so initially consider LATER true for
261 all edges. This allows propagation through a loop since the incoming
262 loop edge will have LATER set, so if all the other incoming edges
263 to the loop are set, then LATERIN will be set for the head of the
266 If the optimistic setting of LATER on that edge was incorrect (for
267 example the expression is ANTLOC in a block within the loop) then
268 this algorithm will detect it when we process the block at the head
269 of the optimistic edge. That will requeue the affected blocks. */
270 sbitmap_vector_ones (later, num_edges);
272 /* Add all the blocks to the worklist. This prevents an early exit from
273 the loop given our optimistic initialization of LATER above. */
274 for (bb = n_basic_blocks - 1; bb >= 0; bb--)
276 basic_block b = BASIC_BLOCK (bb);
281 /* Iterate until the worklist is empty. */
282 while (tos != worklist)
284 /* Take the first entry off the worklist. */
285 basic_block b = *--tos;
288 /* Compute the intersection of LATERIN for each incoming edge to B. */
290 sbitmap_ones (laterin[bb]);
291 for (e = b->pred; e != NULL; e = e->pred_next)
292 sbitmap_a_and_b (laterin[bb], laterin[bb], later[(int)e->aux]);
294 /* Calculate LATER for all outgoing edges. */
295 for (e = b->succ; e != NULL; e = e->succ_next)
297 if (sbitmap_union_of_diff (later[(int)e->aux],
298 earliest[(int)e->aux],
299 laterin[e->src->index],
300 antloc[e->src->index]))
302 /* If LATER for an outgoing edge was changed, then we need
303 to add the target of the outgoing edge to the worklist. */
304 if (e->dest != EXIT_BLOCK_PTR && e->dest->aux == 0)
313 /* Computation of insertion and deletion points requires computing LATERIN
314 for the EXIT block. We allocated an extra entry in the LATERIN array
315 for just this purpose. */
316 sbitmap_ones (laterin[n_basic_blocks]);
317 for (e = EXIT_BLOCK_PTR->pred; e != NULL; e = e->pred_next)
318 sbitmap_a_and_b (laterin[n_basic_blocks],
319 laterin[n_basic_blocks],
325 /* Compute the insertion and deletion points for edge based LCM. */
327 compute_insert_delete (edge_list, antloc, later, laterin,
329 struct edge_list *edge_list;
330 sbitmap *antloc, *later, *laterin, *insert, *delete;
334 for (x = 0; x < n_basic_blocks; x++)
335 sbitmap_difference (delete[x], antloc[x], laterin[x]);
337 for (x = 0; x < NUM_EDGES (edge_list); x++)
339 basic_block b = INDEX_EDGE_SUCC_BB (edge_list, x);
340 if (b == EXIT_BLOCK_PTR)
341 sbitmap_difference (insert[x], later[x], laterin[n_basic_blocks]);
343 sbitmap_difference (insert[x], later[x], laterin[b->index]);
347 /* Given local properties TRANSP, ANTLOC, AVOUT, KILL return the
348 insert and delete vectors for edge based LCM. Returns an
349 edgelist which is used to map the insert vector to what edge
350 an expression should be inserted on. */
353 pre_edge_lcm (file, n_exprs, transp, avloc, antloc, kill, insert, delete)
354 FILE *file ATTRIBUTE_UNUSED;
363 sbitmap *antin, *antout, *earliest;
364 sbitmap *avin, *avout;
365 sbitmap *later, *laterin;
366 struct edge_list *edge_list;
369 edge_list = create_edge_list ();
370 num_edges = NUM_EDGES (edge_list);
372 #ifdef LCM_DEBUG_INFO
375 fprintf (file, "Edge List:\n");
376 verify_edge_list (file, edge_list);
377 print_edge_list (file, edge_list);
378 dump_sbitmap_vector (file, "transp", "", transp, n_basic_blocks);
379 dump_sbitmap_vector (file, "antloc", "", antloc, n_basic_blocks);
380 dump_sbitmap_vector (file, "avloc", "", avloc, n_basic_blocks);
381 dump_sbitmap_vector (file, "kill", "", kill, n_basic_blocks);
385 /* Compute global availability. */
386 avin = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
387 avout = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
388 compute_available (avloc, kill, avout, avin);
393 /* Compute global anticipatability. */
394 antin = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
395 antout = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
396 compute_antinout_edge (antloc, transp, antin, antout);
398 #ifdef LCM_DEBUG_INFO
401 dump_sbitmap_vector (file, "antin", "", antin, n_basic_blocks);
402 dump_sbitmap_vector (file, "antout", "", antout, n_basic_blocks);
406 /* Compute earliestness. */
407 earliest = sbitmap_vector_alloc (num_edges, n_exprs);
408 compute_earliest (edge_list, n_exprs, antin, antout, avout, kill, earliest);
410 #ifdef LCM_DEBUG_INFO
412 dump_sbitmap_vector (file, "earliest", "", earliest, num_edges);
419 later = sbitmap_vector_alloc (num_edges, n_exprs);
420 /* Allocate an extra element for the exit block in the laterin vector. */
421 laterin = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs);
422 compute_laterin (edge_list, earliest, antloc, later, laterin);
425 #ifdef LCM_DEBUG_INFO
428 dump_sbitmap_vector (file, "laterin", "", laterin, n_basic_blocks + 1);
429 dump_sbitmap_vector (file, "later", "", later, num_edges);
435 *insert = sbitmap_vector_alloc (num_edges, n_exprs);
436 *delete = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
437 compute_insert_delete (edge_list, antloc, later, laterin, *insert, *delete);
442 #ifdef LCM_DEBUG_INFO
445 dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
446 dump_sbitmap_vector (file, "pre_delete_map", "", *delete, n_basic_blocks);
453 /* Compute the AVIN and AVOUT vectors from the AVLOC and KILL vectors.
454 Return the number of passes we performed to iterate to a solution. */
456 compute_available (avloc, kill, avout, avin)
457 sbitmap *avloc, *kill, *avout, *avin;
461 basic_block *worklist, *tos;
463 /* Allocate a worklist array/queue. Entries are only added to the
464 list if they were not already on the list. So the size is
465 bounded by the number of basic blocks. */
466 tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
469 /* We want a maximal solution. */
470 sbitmap_vector_ones (avout, n_basic_blocks);
472 /* Put every block on the worklist; this is necessary because of the
473 optimistic initialization of AVOUT above. */
474 for (bb = n_basic_blocks - 1; bb >= 0; bb--)
476 *tos++ = BASIC_BLOCK (bb);
477 BASIC_BLOCK (bb)->aux = BASIC_BLOCK (bb);
480 /* Mark blocks which are successors of the entry block so that we
481 can easily identify them below. */
482 for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
483 e->dest->aux = ENTRY_BLOCK_PTR;
485 /* Iterate until the worklist is empty. */
486 while (tos != worklist)
488 /* Take the first entry off the worklist. */
489 basic_block b = *--tos;
492 /* If one of the predecessor blocks is the ENTRY block, then the
493 intersection of avouts is the null set. We can identify such blocks
494 by the special value in the AUX field in the block structure. */
495 if (b->aux == ENTRY_BLOCK_PTR)
497 /* Do not clear the aux field for blocks which are
498 successors of the ENTRY block. That way we never
499 add then to the worklist again. */
500 sbitmap_zero (avin[bb]);
504 /* Clear the aux field of this block so that it can be added to
505 the worklist again if necessary. */
507 sbitmap_intersection_of_preds (avin[bb], avout, bb);
510 if (sbitmap_union_of_diff (avout[bb], avloc[bb], avin[bb], kill[bb]))
512 /* If the out state of this block changed, then we need
513 to add the successors of this block to the worklist
514 if they are not already on the worklist. */
515 for (e = b->succ; e; e = e->succ_next)
517 if (!e->dest->aux && e->dest != EXIT_BLOCK_PTR)
528 /* Compute the farthest vector for edge based lcm. */
530 compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
532 struct edge_list *edge_list;
534 sbitmap *st_avout, *st_avin, *st_antin, *kill, *farthest;
536 sbitmap difference, temp_bitmap;
538 basic_block pred, succ;
540 num_edges = NUM_EDGES (edge_list);
542 difference = sbitmap_alloc (n_exprs);
543 temp_bitmap = sbitmap_alloc (n_exprs);
545 for (x = 0; x < num_edges; x++)
547 pred = INDEX_EDGE_PRED_BB (edge_list, x);
548 succ = INDEX_EDGE_SUCC_BB (edge_list, x);
549 if (succ == EXIT_BLOCK_PTR)
550 sbitmap_copy (farthest[x], st_avout[pred->index]);
553 if (pred == ENTRY_BLOCK_PTR)
555 sbitmap_zero (farthest[x]);
559 sbitmap_difference (difference, st_avout[pred->index],
560 st_antin[succ->index]);
561 sbitmap_not (temp_bitmap, st_avin[succ->index]);
562 sbitmap_a_and_b_or_c (farthest[x], difference,
563 kill[succ->index], temp_bitmap);
571 /* Compute nearer and nearerout vectors for edge based lcm.
573 This is the mirror of compute_laterin, additional comments on the
574 implementation can be found before compute_laterin. */
577 compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout)
578 struct edge_list *edge_list;
579 sbitmap *farthest, *st_avloc, *nearer, *nearerout;
581 int bb, num_edges, i;
583 basic_block *worklist, *tos;
585 num_edges = NUM_EDGES (edge_list);
587 /* Allocate a worklist array/queue. Entries are only added to the
588 list if they were not already on the list. So the size is
589 bounded by the number of basic blocks. */
590 tos = worklist = (basic_block *) xmalloc (sizeof (basic_block)
591 * (n_basic_blocks + 1));
593 /* Initialize NEARER for each edge and build a mapping from an edge to
595 for (i = 0; i < num_edges; i++)
596 INDEX_EDGE (edge_list, i)->aux = (void *)i;
598 /* We want a maximal solution. */
599 sbitmap_vector_ones (nearer, num_edges);
601 /* Add all the blocks to the worklist. This prevents an early exit
602 from the loop given our optimistic initialization of NEARER. */
603 for (bb = 0; bb < n_basic_blocks; bb++)
605 basic_block b = BASIC_BLOCK (bb);
610 /* Iterate until the worklist is empty. */
611 while (tos != worklist)
613 /* Take the first entry off the worklist. */
614 basic_block b = *--tos;
617 /* Compute the intersection of NEARER for each outgoing edge from B. */
619 sbitmap_ones (nearerout[bb]);
620 for (e = b->succ; e != NULL; e = e->succ_next)
621 sbitmap_a_and_b (nearerout[bb], nearerout[bb], nearer[(int)e->aux]);
623 /* Calculate NEARER for all incoming edges. */
624 for (e = b->pred; e != NULL; e = e->pred_next)
626 if (sbitmap_union_of_diff (nearer[(int)e->aux],
627 farthest[(int)e->aux],
628 nearerout[e->dest->index],
629 st_avloc[e->dest->index]))
631 /* If NEARER for an incoming edge was changed, then we need
632 to add the source of the incoming edge to the worklist. */
633 if (e->src != ENTRY_BLOCK_PTR && e->src->aux == 0)
642 /* Computation of insertion and deletion points requires computing NEAREROUT
643 for the ENTRY block. We allocated an extra entry in the NEAREROUT array
644 for just this purpose. */
645 sbitmap_ones (nearerout[n_basic_blocks]);
646 for (e = ENTRY_BLOCK_PTR->succ; e != NULL; e = e->succ_next)
647 sbitmap_a_and_b (nearerout[n_basic_blocks],
648 nearerout[n_basic_blocks],
649 nearer[(int)e->aux]);
654 /* Compute the insertion and deletion points for edge based LCM. */
656 compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout,
658 struct edge_list *edge_list;
659 sbitmap *st_avloc, *nearer, *nearerout, *insert, *delete;
663 for (x = 0; x < n_basic_blocks; x++)
664 sbitmap_difference (delete[x], st_avloc[x], nearerout[x]);
666 for (x = 0; x < NUM_EDGES (edge_list); x++)
668 basic_block b = INDEX_EDGE_PRED_BB (edge_list, x);
669 if (b == ENTRY_BLOCK_PTR)
670 sbitmap_difference (insert[x], nearer[x], nearerout[n_basic_blocks]);
672 sbitmap_difference (insert[x], nearer[x], nearerout[b->index]);
676 /* Given local properties TRANSP, ST_AVLOC, ST_ANTLOC, KILL return the
677 insert and delete vectors for edge based reverse LCM. Returns an
678 edgelist which is used to map the insert vector to what edge
679 an expression should be inserted on. */
682 pre_edge_rev_lcm (file, n_exprs, transp, st_avloc, st_antloc, kill,
684 FILE *file ATTRIBUTE_UNUSED;
693 sbitmap *st_antin, *st_antout;
694 sbitmap *st_avout, *st_avin, *farthest;
695 sbitmap *nearer, *nearerout;
696 struct edge_list *edge_list;
699 edge_list = create_edge_list ();
700 num_edges = NUM_EDGES (edge_list);
702 st_antin = (sbitmap *) sbitmap_vector_alloc (n_basic_blocks, n_exprs);
703 st_antout = (sbitmap *) sbitmap_vector_alloc (n_basic_blocks, n_exprs);
704 sbitmap_vector_zero (st_antin, n_basic_blocks);
705 sbitmap_vector_zero (st_antout, n_basic_blocks);
706 compute_antinout_edge (st_antloc, transp, st_antin, st_antout);
708 /* Compute global anticipatability. */
709 st_avout = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
710 st_avin = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
711 compute_available (st_avloc, kill, st_avout, st_avin);
713 #ifdef LCM_DEBUG_INFO
716 fprintf (file, "Edge List:\n");
717 verify_edge_list (file, edge_list);
718 print_edge_list (file, edge_list);
719 dump_sbitmap_vector (file, "transp", "", transp, n_basic_blocks);
720 dump_sbitmap_vector (file, "st_avloc", "", st_avloc, n_basic_blocks);
721 dump_sbitmap_vector (file, "st_antloc", "", st_antloc, n_basic_blocks);
722 dump_sbitmap_vector (file, "st_antin", "", st_antin, n_basic_blocks);
723 dump_sbitmap_vector (file, "st_antout", "", st_antout, n_basic_blocks);
724 dump_sbitmap_vector (file, "st_kill", "", kill, n_basic_blocks);
728 #ifdef LCM_DEBUG_INFO
731 dump_sbitmap_vector (file, "st_avout", "", st_avout, n_basic_blocks);
732 dump_sbitmap_vector (file, "st_avin", "", st_avin, n_basic_blocks);
736 /* Compute farthestness. */
737 farthest = sbitmap_vector_alloc (num_edges, n_exprs);
738 compute_farthest (edge_list, n_exprs, st_avout, st_avin, st_antin,
741 #ifdef LCM_DEBUG_INFO
743 dump_sbitmap_vector (file, "farthest", "", farthest, num_edges);
749 nearer = sbitmap_vector_alloc (num_edges, n_exprs);
750 /* Allocate an extra element for the entry block. */
751 nearerout = sbitmap_vector_alloc (n_basic_blocks + 1, n_exprs);
752 compute_nearerout (edge_list, farthest, st_avloc, nearer, nearerout);
754 #ifdef LCM_DEBUG_INFO
757 dump_sbitmap_vector (file, "nearerout", "", nearerout,
759 dump_sbitmap_vector (file, "nearer", "", nearer, num_edges);
765 *insert = sbitmap_vector_alloc (num_edges, n_exprs);
766 *delete = sbitmap_vector_alloc (n_basic_blocks, n_exprs);
767 compute_rev_insert_delete (edge_list, st_avloc, nearer, nearerout, *insert, *delete);
772 #ifdef LCM_DEBUG_INFO
775 dump_sbitmap_vector (file, "pre_insert_map", "", *insert, num_edges);
776 dump_sbitmap_vector (file, "pre_delete_map", "", *delete, n_basic_blocks);